From 2cf1ede05b9e8418fff5fea5f448155e1abd50f4 Mon Sep 17 00:00:00 2001 From: Walter Bright Date: Wed, 5 Jan 2022 20:58:05 -0800 Subject: [PATCH] bring up to date with dmd --- dm/src/dmc/cgelem.d | 63 +++-- dm/src/dmc/debugprint.d | 32 ++- dm/src/dmc/dexp2.d | 3 + dm/src/dmc/dnwc.d | 4 +- dm/src/dmc/dvec.d | 49 +++- dm/src/dmc/global.d | 3 + dm/src/dmc/gloop.d | 10 +- dm/src/dmc/gsroa.d | 134 ++++++++++- dm/src/dmc/makefile | 514 +++++++++++++++++++++------------------- 9 files changed, 521 insertions(+), 291 deletions(-) diff --git a/dm/src/dmc/cgelem.d b/dm/src/dmc/cgelem.d index 25b12459..5086e728 100644 --- a/dm/src/dmc/cgelem.d +++ b/dm/src/dmc/cgelem.d @@ -1,4 +1,6 @@ /** + * Local optimizations of elem trees + * * Compiler implementation of the * $(LINK2 http://www.dlang.org, D programming language). * @@ -787,12 +789,40 @@ private elem * elmemset(elem *e, goal_t goal) case SHORTSIZE: tym = TYshort; goto L1; case LONGSIZE: tym = TYlong; goto L1; case LLONGSIZE: if (_tysize[TYint] == 2) - goto Ldefault; + goto default; tym = TYllong; goto L1; + + case 16: if (REGSIZE == 8 && e1.Eoper == OPrelconst) + goto L1; + goto default; L1: { tym_t ety = e.Ety; memset(&value, value & 0xFF, value.sizeof); + if (nbytes == 2 * REGSIZE && e1.Eoper == OPrelconst) + { + /* Rewrite as: + * (*e1.0 = value),(*e1.4 = value),(e1) + */ + tym = REGSIZE == 8 ? TYllong : TYint; + + auto e1a = el_copytree(e1); + e1a.Eoper = OPvar; + e1a.Ety = tym; + auto ea = el_bin(OPeq,TYint,e1a,el_long(tym,value)); + + auto e1b = el_copytree(e1); + e1b.Eoper = OPvar; + e1b.Ety = tym; + e1b.EV.Voffset += REGSIZE; + auto eb = el_bin(OPeq,tym,e1b,el_long(tym,value)); + + e.EV.E1 = null; + el_free(e); + e = el_combine(el_combine(ea, eb), e1); + e = optelem(e, GOALvalue); + return e; + } evalue.EV.Vullong = value; evalue.Ety = tym; e.Eoper = OPeq; @@ -807,11 +837,10 @@ private elem * elmemset(elem *e, goal_t goal) e.EV.E2 = el_selecte2(e.EV.E2); e = el_combine(e, tmp); e = optelem(e,GOALvalue); - break; } + break; default: - Ldefault: break; } } @@ -3268,7 +3297,7 @@ private elem * elbit(elem *e, goal_t goal) e.Eoper = OPu8_16; e.EV.E2 = null; el_free(e2); - goto L1; + return optelem(e,GOALvalue); // optimize result } if (w + b == sz) // if field is left-justified @@ -3282,7 +3311,7 @@ private elem * elbit(elem *e, goal_t goal) e.Eoper = OPs8_16; e.EV.E2 = null; el_free(e2); - goto L1; + return optelem(e,GOALvalue); // optimize result } m = ~cast(targ_ullong)0; c = sz - (w + b); @@ -3297,7 +3326,6 @@ private elem * elbit(elem *e, goal_t goal) e.EV.E1 = el_bin(OPshr,tym1, el_bin(OPshl,tym1,e.EV.E1,el_long(TYint,c)), el_long(TYint,b)); -L1: return optelem(e,GOALvalue); // optimize result } @@ -3684,7 +3712,9 @@ elem * elstruct(elem *e, goal_t goal) } } else if (I32 && targ1 && targ2) + { tym = TYllong; + } assert(tym != TYstruct); } assert(tym != ~0); @@ -3772,6 +3802,8 @@ elem * elstruct(elem *e, goal_t goal) break; } } + //printf("elstruct return\n"); + //elem_print(e); return e; } @@ -4071,13 +4103,6 @@ static if (0) if (e1.Eoper == OPcomma) return cgel_lvalue(e); -version (MARS) -{ - // No bit fields to deal with - return e; -} -else -{ if (e1.Eoper != OPbit) return e; if (e1.EV.E1.Eoper == OPcomma || OTassign(e1.EV.E1.Eoper)) @@ -4139,7 +4164,6 @@ else el_free(e); return optelem(eres,GOALvalue); } -} /********************************** */ @@ -4186,8 +4210,7 @@ private elem * elopass(elem *e, goal_t goal) { e = fixconvop(e); return optelem(e,GOALvalue); } -version (SCPP) // have bit fields to worry about? -{ + goal_t wantres = goal; if (e1.Eoper == OPbit) { @@ -4266,7 +4289,7 @@ version (SCPP) // have bit fields to worry about? e = optelem(eres,GOALvalue); return e; } -} + { if (e1.Eoper == OPcomma || OTassign(e1.Eoper)) e = cgel_lvalue(e); // replace (e,v)op=e2 with e,(v op= e2) @@ -5732,7 +5755,7 @@ private elem * optelem(elem *e, goal_t goal) beg: //__gshared uint count; //printf("count: %u\n", ++count); - //{ printf("xoptelem: %p ",e); WROP(e.Eoper); printf(" goal x%x\n", goal); } + //{ printf("xoptelem: %p %s goal x%x\n",e, oper_str(e.Eoper), goal); } assert(e); elem_debug(e); assert(e.Ecount == 0); // no CSEs @@ -6208,11 +6231,11 @@ beg: } // if (debugb) -// { print("optelem: %p ",e); WROP(op); print("\n"); } +// { print("optelem: %p %s\n",e, oper_str(op)); } static if (0) { - { print("xoptelem: %p ",e); WROP(e.Eoper); print("\n"); } + printf("xoptelem: %p %s\n", e, oper_str(e.Eoper)); elem_print(e); e = (*elxxx[op])(e, goal); printf("After:\n"); diff --git a/dm/src/dmc/debugprint.d b/dm/src/dmc/debugprint.d index b44aa805..6cd4a396 100644 --- a/dm/src/dmc/debugprint.d +++ b/dm/src/dmc/debugprint.d @@ -1,4 +1,6 @@ /** + * Pretty print data structures + * * Compiler implementation of the * $(LINK2 http://www.dlang.org, D programming language). * @@ -133,6 +135,21 @@ void WROP(uint oper) ferr(" "); } +/*************************** + * Convert OPER to string. + * Params: + * oper = operator number + * Returns: + * pointer to string + */ + +@trusted +const(char)* oper_str(uint oper) +{ + assert(oper < OPMAX); + return debtab[oper]; +} + /******************************* * Write TYxxxx */ @@ -158,6 +175,10 @@ void WRTYxx(tym_t t) // if (t & mTYtransu) // printf("mTYtransu|"); //#endif + if (t & mTYxmmgpr) + printf("mTYxmmgpr|"); + if (t & mTYgprxmm) + printf("mTYgprxmm|"); t = tybasic(t); if (t >= TYMAX) { printf("TY %x\n",cast(int)t); @@ -210,7 +231,8 @@ void WReqn(elem *e) return; if (OTunary(e.Eoper)) { - WROP(e.Eoper); + ferr(oper_str(e.Eoper)); + ferr(" "); if (OTbinary(e.EV.E1.Eoper)) { nest++; ferr("("); @@ -238,7 +260,8 @@ void WReqn(elem *e) else WReqn(e.EV.E1); ferr(" "); - WROP(e.Eoper); + ferr(oper_str(e.Eoper)); + ferr(" "); if (e.Eoper == OPstreq) printf("%d", cast(int)type_size(e.ET)); ferr(" "); @@ -286,12 +309,13 @@ void WReqn(elem *e) case OPhalt: case OPdctor: case OPddtor: - WROP(e.Eoper); + ferr(oper_str(e.Eoper)); + ferr(" "); break; case OPstrthis: break; default: - WROP(e.Eoper); + ferr(oper_str(e.Eoper)); assert(0); } } diff --git a/dm/src/dmc/dexp2.d b/dm/src/dmc/dexp2.d index 6b565ed4..9bfacb51 100644 --- a/dm/src/dmc/dexp2.d +++ b/dm/src/dmc/dexp2.d @@ -1352,6 +1352,7 @@ err: /************************* + * C11 6.5.2.1-2 * E1[E2] is converted to *(E1 + E2*s1) * No error checking is done. */ @@ -2134,7 +2135,9 @@ elem *convertchk(elem *e) } /************************** + * C11 6.3.2.1-3 * If e is , convert it to . + * C11 6.3.2.1-4 * If e is , convert it to . */ diff --git a/dm/src/dmc/dnwc.d b/dm/src/dmc/dnwc.d index 9b5b4b1d..55b14a92 100644 --- a/dm/src/dmc/dnwc.d +++ b/dm/src/dmc/dnwc.d @@ -3360,14 +3360,14 @@ private type * getprototype(const char *fident,type *tret) tp2.Tflags &= ~TFfuncparam; type_free(pt); - /* Convert function to pointer to function */ + // C11 6.7.6.3-8 Convert function to pointer to function if (tyfunc(tparam.Tty)) { tparam = newpointer(tparam); tparam.Tnext.Tcount--; tparam.Tcount++; } - /* Convert to in prototypes */ + // C11 6.7.6.3-7 Convert to in prototypes else if (tybasic(tparam.Tty) == TYarray) tparam = topointer(tparam); diff --git a/dm/src/dmc/dvec.d b/dm/src/dmc/dvec.d index b25fa2e8..7b03a79a 100644 --- a/dm/src/dmc/dvec.d +++ b/dm/src/dmc/dvec.d @@ -179,8 +179,16 @@ __gshared VecGlobal vecGlobal; private pure vec_base_t MASK(uint b) { return cast(vec_base_t)1 << (b & VECMASK); } +/**** + * Returns: + * number of bits in the vector + */ @trusted pure ref inout(vec_base_t) vec_numbits(inout vec_t v) { return v[-1]; } +/**** + * Returns: + * number of bytes in the vector + */ @trusted pure ref inout(vec_base_t) vec_dim(inout vec_t v) { return v[-2]; } @@ -312,6 +320,7 @@ void vec_clearbit(size_t b, vec_t v) */ @trusted +pure size_t vec_testbit(size_t b, const vec_t v) { if (!v) @@ -319,7 +328,7 @@ size_t vec_testbit(size_t b, const vec_t v) debug { if (!(v && b < vec_numbits(v))) - printf("vec_testbit(v = %p,b = %d): numbits = %d dim = %d\n", + printf("vec_setbit(v = %p,b = %d): numbits = %d dim = %d\n", v, cast(int) b, cast(int) (v ? vec_numbits(v) : 0), cast(int) (v ? vec_dim(v) : 0)); } assert(v && b < vec_numbits(v)); @@ -363,6 +372,33 @@ size_t vec_index(size_t b, const vec_t vec) return vec_numbits(vec); } +/******************************** + * Count number of set bits in vector `v` + * Params: + * v = vector + * Returns: + * number of set bits + */ +@safe +pure +uint vec_numBitsSet(const vec_t vec) +{ + uint n = 0; + size_t length = vec_numbits(vec); + for (size_t i = 0; (i = vec_index(i, vec)) < length; ++i) + ++n; + return n; +} + +uint vec_numBitsSet2(const vec_t vec) +{ + uint n = 0; + foreach (i; VecRange(vec)) + ++n; + return n; +} + + /******************************** * Compute v1 &= v2. */ @@ -648,3 +684,14 @@ void vec_print(const vec_t v) } +struct VecRange +{ + uint i; + const vec_t v; + + @nogc @safe nothrow pure: + this(const vec_t v) { this.v = v; i = vec_index(0, v); } + bool empty() const { return i == vec_numbits(v); } + uint front() const { return i; } + void popFront() { i = vec_index(i + 1, v); } +} diff --git a/dm/src/dmc/global.d b/dm/src/dmc/global.d index 9d93076e..3f7ccd7c 100644 --- a/dm/src/dmc/global.d +++ b/dm/src/dmc/global.d @@ -1,4 +1,6 @@ /** + * Declarations for back end + * * Compiler implementation of the * $(LINK2 http://www.dlang.org, D programming language). * @@ -432,6 +434,7 @@ extern __gshared const(char)*[32] regstring; void WRclass(int c); void WRTYxx(tym_t t); void WROP(uint oper); +@trusted const(char)* oper_str(uint oper); void WRBC(uint bc); void WRarglst(list_t a); void WRblock(block *b); diff --git a/dm/src/dmc/gloop.d b/dm/src/dmc/gloop.d index 9cb56a02..c28a7591 100644 --- a/dm/src/dmc/gloop.d +++ b/dm/src/dmc/gloop.d @@ -34,7 +34,6 @@ import dmd.backend.oper; import dmd.backend.global; import dmd.backend.goh; import dmd.backend.el; -import dmd.backend.outbuf; import dmd.backend.symtab; import dmd.backend.ty; import dmd.backend.type; @@ -3735,9 +3734,14 @@ bool loopunroll(ref Loop l) /* For simplification, only unroll loops that consist only * of a head and tail, and the tail is the exit block. */ - int numblocks = 0; + const numblocks = vec_numBitsSet(l.Lloop); +{ + assert(dfo.length == vec_numbits(l.Lloop)); + int n = 0; for (int i = 0; (i = cast(uint) vec_index(i, l.Lloop)) < dfo.length; ++i) // for each block in loop - ++numblocks; + ++n; + assert(n == numblocks); +} if (numblocks != 2) { if (log) printf("\tnot 2 blocks, but %d\n", numblocks); diff --git a/dm/src/dmc/gsroa.d b/dm/src/dmc/gsroa.d index 4df75c2f..2c2bfbbd 100644 --- a/dm/src/dmc/gsroa.d +++ b/dm/src/dmc/gsroa.d @@ -1,4 +1,10 @@ /** + * SROA structured replacement of aggregate optimization + * + * This 'slices' a two register wide aggregate into two separate register-sized variables, + * enabling much better enregistering. + * SROA (Scalar Replacement Of Aggregates) is the common term for this. + * * Compiler implementation of the * $(LINK2 http://www.dlang.org, D programming language). * @@ -41,16 +47,13 @@ extern (C++): nothrow: @safe: +enum log = false; // print logging info + int REGSIZE(); alias SLICESIZE = REGSIZE; // slices are all register-sized enum MAXSLICES = 2; // max # of pieces we can slice an aggregate into -/* This 'slices' a two register wide aggregate into two separate register-sized variables, - * enabling much better enregistering. - * SROA (Scalar Replacement Of Aggregates) is the common term for this. - */ - struct SymInfo { bool canSlice; @@ -99,20 +102,73 @@ extern (D) private void sliceStructs_Gather(ref const symtab_t symtab, SymInfo[] const t = s.Stype; if (tybasic(t.Tty) == TYstruct) { + if (t.Ttag.Sstruct.Sflags & STRbitfields) + { + // Can get "used before set" errors from slicing this + // Would be workable if the symbol was flagged instead of the type + sia[si].canSlice = false; + return; + } + if (const targ1 = t.Ttag.Sstruct.Sarg1type) if (const targ2 = t.Ttag.Sstruct.Sarg2type) { sia[si].ty[0] = targ1.Tty; sia[si].ty[1] = targ2.Tty; + + if (config.fpxmmregs && + tyxmmreg(targ1.Tty) && !tyxmmreg(targ2.Tty) || + !tyxmmreg(targ1.Tty) && tyxmmreg(targ2.Tty)) + + { + /* https://issues.dlang.org/show_bug.cgi?22438 + * disable till fixed + */ + if (log) printf(" [%d] can't because xmmgpr or gprxmm\n", cast(int)si); + sia[si].canSlice = false; + return; + } } } + else if (tybasic(t.Tty) == TYarray) + { + // could be an array of floats, deal with this later + if (log) printf(" [%d] can't because array of floats\n", cast(int)si); + sia[si].canSlice = false; + return; + } } - sia[si].accessSlice = true; if (sz == SLICESIZE) + { sia[si].ty[n] = tybasic(e.Ety); + if (SLICESIZE == 4 && config.fpxmmregs && tyxmmreg(e.Ety)) + { + /* for 32 bits, OPstreq is converted to a TYllong. + * It needs to be converted to cfloat, otherwise XMM + * registers cannot be handled. This fails: + * struct F { float x, y; } + * void foo(F p1, ref F rfp) { rfp = F(p.x, p.y); } + */ + if (log) printf(" [%d] can't because 32 bit XMM\n", cast(int)si); + sia[si].canSlice = false; + return; + } + if (config.fpxmmregs && tyxmmreg(e.Ety)) + { + /* Too many issues with mixing XMM with non-XMM + * One problem is an OPpair with one operand a long, the other XMM. + * Giving it up for now. + */ + if (log) printf(" [%d] can't because XMM\n", cast(int)si); + sia[si].canSlice = false; + return; + } + } + sia[si].accessSlice = true; } else { + if (log) printf(" [%d] can't because NOTSLICE 1\n", cast(int)si); sia[si].canSlice = false; } } @@ -135,6 +191,11 @@ extern (D) private void sliceStructs_Gather(ref const symtab_t symtab, SymInfo[] assert(si < symtab.length); if (nthSlice(e1) == NOTSLICE) { + if (log) + { + printf(" [%d] can't because NOTSLICE 2\n", cast(int)si); + elem_print(e); + } sia[si].canSlice = false; } // Disable SROA on OSX32 (because XMM registers?) @@ -191,6 +252,7 @@ extern (D) private void sliceStructs_Replace(ref symtab_t symtab, const SymInfo[ const n = nthSlice(e); if (getSize(e) == 2 * SLICESIZE) { + if (log) { printf("slicing struct before "); elem_print(e); } // Rewrite e as (si0 OPpair si0+1) elem *e1 = el_calloc(); el_copy(e1, e); @@ -227,12 +289,15 @@ extern (D) private void sliceStructs_Replace(ref symtab_t symtab, const SymInfo[ if (!tyfloating(e2.Ety)) e2.Ety = tyop; } + if (log) { printf("slicing struct after\n"); elem_print(e); } } else if (n == 0) // the first slice of the symbol is the same as the original { + if (log) { printf("slicing slice 0 "); elem_print(e); } } else // the nth slice { + if (log) { printf("slicing slice %d ", n); elem_print(e); } e.EV.Vsym = symtab[sia[si].si0 + n]; e.EV.Voffset -= n * SLICESIZE; //printf("replaced with:\n"); @@ -242,6 +307,20 @@ extern (D) private void sliceStructs_Replace(ref symtab_t symtab, const SymInfo[ return; } + case OPrelconst: + { + Symbol *s = e.EV.Vsym; + const si = s.Ssymnum; + //printf("e: %d %d\n", si, sia[si].canSlice); + //elem_print(e); + if (si != SYMIDX.max && sia[si].canSlice) + { + printf("shouldn't be slicing %s\n", s.Sident.ptr); + assert(0); + } + return; + } + default: if (OTunary(e.Eoper)) { @@ -262,7 +341,9 @@ extern (D) private void sliceStructs_Replace(ref symtab_t symtab, const SymInfo[ @trusted void sliceStructs(ref symtab_t symtab, block* startblock) { - if (debugc) printf("sliceStructs() %s\n", funcsym_p.Sident.ptr); +if (1) +{ + if (log) printf("\n************ sliceStructs() %s *******************\n", funcsym_p.Sident.ptr); const sia_length = symtab.length; /* 3 is because it is used for two arrays, sia[] and sia2[]. * sia2[] can grow to twice the size of sia[], as symbols can get split into two. @@ -280,10 +361,11 @@ void sliceStructs(ref symtab_t symtab, block* startblock) sip = cast(SymInfo *)malloc(3 * sia_length * SymInfo.sizeof); assert(sip); } + memset(sip, 0, 3 * sia_length * SymInfo.sizeof); SymInfo[] sia = sip[0 .. sia_length]; SymInfo[] sia2 = sip[sia_length .. sia_length * 3]; - if (0) foreach (si; 0 .. symtab.length) + if (log) foreach (si; 0 .. symtab.length) { Symbol *s = symtab[si]; printf("[%d]: %p %d %s\n", cast(int)si, s, cast(int)type_size(s.Stype), s.Sident.ptr); @@ -293,10 +375,12 @@ void sliceStructs(ref symtab_t symtab, block* startblock) foreach (si; 0 .. symtab.length) { Symbol *s = symtab[si]; - //printf("slice1: %s\n", s.Sident.ptr); + if (log) printf("slice1 [%d]: %s\n", cast(int)si, s.Sident.ptr); + //if (strcmp(s.Sident.ptr, "__inlineretval3".ptr) == 0) { printf("can't\n"); sia[si].canSlice = false; continue; } if (!(s.Sflags & SFLunambig)) // if somebody took the address of s { + if (log) printf(" can't because SFLunambig\n"); sia[si].canSlice = false; continue; } @@ -305,6 +389,7 @@ void sliceStructs(ref symtab_t symtab, block* startblock) if (sz != 2 * SLICESIZE || tyfv(s.Stype.Tty) || tybasic(s.Stype.Tty) == TYhptr) // because there is no TYseg { + if (log) printf(" can't because size or pointer type\n"); sia[si].canSlice = false; continue; } @@ -323,6 +408,7 @@ void sliceStructs(ref symtab_t symtab, block* startblock) if (tyxmmreg(s.Stype.Tty) && isXMMreg(s.Spreg) && s.Spreg2 == NOREG) { + if (log) printf(" can't because XMM reg\n"); sia[si].canSlice = false; } break; @@ -331,6 +417,7 @@ void sliceStructs(ref symtab_t symtab, block* startblock) case SCpseudo: case SCstatic: case SCbprel: + if (log) printf(" can't because Sclass\n"); sia[si].canSlice = false; break; @@ -362,6 +449,7 @@ void sliceStructs(ref symtab_t symtab, block* startblock) // If never did access it as a slice, don't slice if (!sia[si].accessSlice) { + if (log) printf(" can't slice %s because no accessSlice\n", symtab[si].Sident.ptr); sia[si].canSlice = false; continue; } @@ -374,8 +462,10 @@ void sliceStructs(ref symtab_t symtab, block* startblock) const idlen = 2 + strlen(sold.Sident.ptr) + 2; char *id = cast(char *)malloc(idlen + 1); assert(id); - sprintf(id, "__%s_%d", sold.Sident.ptr, SLICESIZE); - if (debugc) printf("creating slice symbol %s\n", id); + const len = sprintf(id, "__%s_%d", sold.Sident.ptr, SLICESIZE); + assert(len == idlen); +// if (log) printf("retyping slice symbol %s %s\n", sold.Sident.ptr, tym_str(sia[si].ty[0])); +// if (log) printf("creating slice symbol %s %s\n", id, tym_str(sia[si].ty[1])); Symbol *snew = symbol_calloc(id, cast(uint)idlen); free(id); snew.Sclass = sold.Sclass; @@ -419,10 +509,22 @@ void sliceStructs(ref symtab_t symtab, block* startblock) sliceStructs_Replace(symtab, sia2, b.Belem); } + static if (0) + { + printf("after slicing:\n"); + foreach (b; BlockRange(startblock)) + { + if (b.Belem) + elem_print(b.Belem); + } + printf("after slicing done\n"); + } + Ldone: if (sip != tmp.ptr) free(sip); } +} /************************************* @@ -440,13 +542,21 @@ int nthSlice(const(elem)* e) return NOTSLICE; const sliceSize = SLICESIZE; + /* if sz is less than sliceSize, this causes problems because if, say, + * sz is 4 while sliceSize is 8, and sz gets enregistered, then assigning to + * the lower 4 bytes of sz will zero out the upper 4 bytes. + * /~https://github.com/dlang/dmd/pull/13220 + */ + if (sz != sliceSize) + return NOTSLICE; + /* See if e fits in a slice */ const lwr = e.EV.Voffset; const upr = lwr + sz; if (0 <= lwr && upr <= sliceSize) return 0; - if (sliceSize < lwr && upr <= sliceSize * 2) + if (sliceSize <= lwr && upr <= sliceSize * 2) return 1; return NOTSLICE; diff --git a/dm/src/dmc/makefile b/dm/src/dmc/makefile index 19a5842a..6d3a8d17 100644 --- a/dm/src/dmc/makefile +++ b/dm/src/dmc/makefile @@ -13,6 +13,13 @@ DMCDIR=\dm +#DMDDIR=e:\dmd2.074 +#DMDDIR79=e:\dmd2.079 +DMDDIR=e:\dmd2.079 +DMDDIR74=e:\dmd2.074 +DMDDIR79=e:\dmd2.079 +DMDDIR92=e:\dmd2.092 + CBX=. NTDLLSHELL=ntdllshell TK=tk @@ -63,7 +70,16 @@ LFLAGS=/map/e/f/packcode/noe; ##### Tools # D compiler -DMD=dmd +DMD=$(DMDDIR)\windows\bin\dmd +DMD74=$(DMDDIR74)\windows\bin\dmd +DMD79=$(DMDDIR79)\windows\bin\dmd +DMDXX=$(DMDDIR74)\windows\bin\dmd + +DMD=$(DMDDIR92)\windows\bin\dmd +DMD74=$(DMDDIR92)\windows\bin\dmd +DMD79=$(DMDDIR92)\windows\bin\dmd +DMDXX=$(DMDDIR92)\windows\bin\dmd + # C++ compiler CC=dmc # Make program @@ -93,80 +109,80 @@ LINKN=$(DMCDIR)\bin\link /de # Makerules: .c.obj: - $(CC) -c $(CFLAGS) $(PREC) $* + $(CC) -c $(CFLAGS) $(PREC) $* .asm.obj: - $(CC) -c $(CFLAGS) $* + $(CC) -c $(CFLAGS) $* ################ DUMMY ######################### noparameter: - echo no parameter + echo no parameter ################ RELEASES ######################### release: - make clean - make scppn - make clean - make sppn - make clean - make scppnd - make clean - make sppnd - make clean - make htodn - make clean + make clean + make scppn + make clean + make sppn + make clean + make scppnd + make clean + make sppnd + make clean + make htodn + make clean ################ NT COMMAND LINE RELEASE ######################### scppn: -# make TARGET=SCPP OPT=-o "DEBUG=-gt -g -DSTATIC= -Nc" LFLAGS=/noi/noe/map scppn.exe - make TARGET=SCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map/co scppn.exe -# make TARGET=SCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map scppn.exe +# make TARGET=SCPP OPT=-o "DEBUG=-gt -g -DSTATIC= -Nc" LFLAGS=/noi/noe/map scppn.exe + make TARGET=SCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map/co scppn.exe +# make TARGET=SCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map scppn.exe sppn: - make TARGET=SPP OPT=-o+space DEBUG= LFLAGS=/noi/noe/map sppn.exe + make TARGET=SPP OPT=-o+space DEBUG= LFLAGS=/noi/noe/map sppn.exe htodn: - make TARGET=HTOD XFLG=-DSCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map htodn.exe + make TARGET=HTOD XFLG=-DSCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map htodn.exe htod: - make TARGET=HTOD XFLG=-DSCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map htod.exe + make TARGET=HTOD XFLG=-DSCPP OPT=-o "DEBUG= -DSTATIC= -Nc" LFLAGS=/noi/noe/map htod.exe ################ NT COMMAND LINE DEBUG ######################### debcppn: - make TARGET=SCPP OPT= "DEBUG=-D -g -DMEM_DEBUG" \ - DDEBUG=-debug LFLAGS=/noi/noe/co/m scppn.exe + make TARGET=SCPP OPT= "DEBUG=-D -g -DMEM_DEBUG" \ + DDEBUG=-debug LFLAGS=/noi/noe/co/m scppn.exe debppn: - make TARGET=SPP OPT= "DEBUG=-D -g -DMEM_DEBUG" \ - DDEBUG=-debug LFLAGS=/noi/noe/co/m sppn.exe + make TARGET=SPP OPT= "DEBUG=-D -g -DMEM_DEBUG" \ + DDEBUG=-debug LFLAGS=/noi/noe/co/m sppn.exe debhtodn: - make TARGET=HTOD XFLG=-DSCPP OPT= "DEBUG=-D -g -DMEM_DEBUG" \ - DDEBUG=-debug LFLAGS=/noi/noe/co/m htodn.exe + make TARGET=HTOD XFLG=-DSCPP OPT= "DEBUG=-D -g -DMEM_DEBUG" \ + DDEBUG=-debug LFLAGS=/noi/noe/co/m htodn.exe ################ NT DLL RELEASE ######################### scppnd: - make TARGET=SCPP OPT=-o+space "XFLG=$(NTDLL)" DEBUG= DDEBUG= LFLAGS=/noi/noe/map BASE=18087936 DDLLFLAGS=-version=_WINDLL scppnd.dll -# make TARGET=SCPP OPT=-o+space "XFLG=$(NTDLL)" DEBUG=-g DDEBUG=-debug LFLAGS=/noi/noe/map/co BASE=18087936 DDLLFLAGS=-version=_WINDLL scppnd.dll + make TARGET=SCPP OPT=-o+space "XFLG=$(NTDLL)" DEBUG= DDEBUG= LFLAGS=/noi/noe/map BASE=18087936 DDLLFLAGS=-version=_WINDLL scppnd.dll +# make TARGET=SCPP OPT=-o+space "XFLG=$(NTDLL)" DEBUG=-g DDEBUG=-debug LFLAGS=/noi/noe/map/co BASE=18087936 DDLLFLAGS=-version=_WINDLL scppnd.dll sppnd: - make TARGET=SPP OPT=-o+space "XFLG=$(NTDLL)" DEBUG= DDEBUG=-debug LFLAGS=/noi/noe/map BASE=21430272 DDLLFLAGS=-version=_WINDLL sppnd.dll + make TARGET=SPP OPT=-o+space "XFLG=$(NTDLL)" DEBUG= DDEBUG=-debug LFLAGS=/noi/noe/map BASE=21430272 DDLLFLAGS=-version=_WINDLL sppnd.dll ################ NT DLL DEBUG ######################### debcppnd: - make TARGET=SCPP OPT= "DEBUG=-g -D -DMEM_DEBUG -DTERMCODE" "XFLG=$(NTDLL)" \ - DDEBUG=-debug LFLAGS=/noi/noe/map/co DDLLFLAGS=-version=_WINDLL scppnd.dll + make TARGET=SCPP OPT= "DEBUG=-g -D -DMEM_DEBUG -DTERMCODE" "XFLG=$(NTDLL)" \ + DDEBUG=-debug LFLAGS=/noi/noe/map/co DDLLFLAGS=-version=_WINDLL scppnd.dll debppnd: - make TARGET=SPP OPT=-o+space "XFLG=$(NTDLL)" \ - DDEBUG=-debug LFLAGS=/noi/noe/map/co DDLLFLAGS=-version=_WINDLL sppnd.dll + make TARGET=SPP OPT=-o+space "XFLG=$(NTDLL)" \ + DDEBUG=-debug LFLAGS=/noi/noe/map/co DDLLFLAGS=-version=_WINDLL sppnd.dll ######################################### @@ -191,82 +207,82 @@ ALLOBJS= $(OBJ1a) $(OBJ1b) $(OBJ1c) $(OBJ1d) $(OBJ1e) $(OBJ1f) $(OBJ1g) \ ######################################### $(TARGET)n.exe : $(ALLOBJS) $(TARGET)n.lnk $(TARGET)n.def - $(LINKN) @$*.lnk + $(LINKN) @$*.lnk $(TARGET)nd.dll : $(ALLOBJS) $(TARGET)nd.lnk $(TARGET)nd.def - $(LINKN) @$*.lnk + $(LINKN) @$*.lnk ######################################### $(TARGET)n.def : makefile - echo NAME $(TARGET) > $*.def - echo SUBSYSTEM CONSOLE >> $*.def - echo EXETYPE NT >> $*.def - echo CODE SHARED EXECUTE >> $*.def - echo STUB '$(LIBNT)\NTSTUB.EXE' >> $*.def - echo INCLUDE $(TARGET)n.tra >> $*.def + echo NAME $(TARGET) > $*.def + echo SUBSYSTEM CONSOLE >> $*.def + echo EXETYPE NT >> $*.def + echo CODE SHARED EXECUTE >> $*.def + echo STUB '$(LIBNT)\NTSTUB.EXE' >> $*.def + echo INCLUDE $(TARGET)n.tra >> $*.def $(TARGET)nd.def : makefile - echo LIBRARY "$*.dll" > $*.def - echo DESCRIPTION '$(TARGET) as a DLL' >> $*.def - echo EXETYPE NT >> $*.def - echo SUBSYSTEM WINDOWS >> $*.def - echo CODE SHARED EXECUTE >> $*.def - echo DATA WRITE >> $*.def - echo EXPORTS >> $*.def - echo _$(TARGET)Version=_DllVersion@0 @1 >> $*.def - echo _$(TARGET)Entry=_DllEntry@12 @2 >> $*.def - echo _NetSpawnVersion=_NetSpawnVersion@0 @3 >> $*.def -# echo _NetSpawnVersion@0 @4 >> $*.def + echo LIBRARY "$*.dll" > $*.def + echo DESCRIPTION '$(TARGET) as a DLL' >> $*.def + echo EXETYPE NT >> $*.def + echo SUBSYSTEM WINDOWS >> $*.def + echo CODE SHARED EXECUTE >> $*.def + echo DATA WRITE >> $*.def + echo EXPORTS >> $*.def + echo _$(TARGET)Version=_DllVersion@0 @1 >> $*.def + echo _$(TARGET)Entry=_DllEntry@12 @2 >> $*.def + echo _NetSpawnVersion=_NetSpawnVersion@0 @3 >> $*.def + #echo _NetSpawnVersion@0 @4 >> $*.def ######################################## $(TARGET)n.lnk : makefile - echo $(OBJ1a)+ > $*.lnk - echo $(OBJ1b)+ >> $*.lnk - echo $(OBJ1c)+ >> $*.lnk - echo $(OBJ1d)+ >> $*.lnk - echo $(OBJ1e)+ >> $*.lnk - echo $(OBJ1f)+ >> $*.lnk - echo $(OBJ1g)+ >> $*.lnk - echo $(OBJ2a)+ >> $*.lnk - echo $(OBJ2b)+ >> $*.lnk - echo $(OBJ2c)+ >> $*.lnk - echo $(OBJ2d)+ >> $*.lnk - echo $(OBJ2e)+ >> $*.lnk - echo $(OBJ2f)$(LFLAGS) >> $*.lnk - echo $* >> $*.lnk - echo $* >> $*.lnk - echo tdb+ >> $*.lnk - echo $(SNN)+ >> $*.lnk - echo $(LIBNT)\kernel32+ >> $*.lnk - echo $(LIBNT)\user32 >> $*.lnk - echo $*.def; >> $*.lnk + echo $(OBJ1a)+ > $*.lnk + echo $(OBJ1b)+ >> $*.lnk + echo $(OBJ1c)+ >> $*.lnk + echo $(OBJ1d)+ >> $*.lnk + echo $(OBJ1e)+ >> $*.lnk + echo $(OBJ1f)+ >> $*.lnk + echo $(OBJ1g)+ >> $*.lnk + echo $(OBJ2a)+ >> $*.lnk + echo $(OBJ2b)+ >> $*.lnk + echo $(OBJ2c)+ >> $*.lnk + echo $(OBJ2d)+ >> $*.lnk + echo $(OBJ2e)+ >> $*.lnk + echo $(OBJ2f)$(LFLAGS) >> $*.lnk + echo $* >> $*.lnk + echo $* >> $*.lnk + echo tdb+ >> $*.lnk + echo $(SNN)+ >> $*.lnk + echo $(LIBNT)\kernel32+ >> $*.lnk + echo $(LIBNT)\user32 >> $*.lnk + echo $*.def; >> $*.lnk $(TARGET)nd.lnk : makefile - echo $(NTDLLSHELL)\lib\netsploc+ > $*.lnk - echo $(OBJ1a)+ >> $*.lnk - echo $(OBJ1b)+ >> $*.lnk - echo $(OBJ1c)+ >> $*.lnk - echo $(OBJ1d)+ >> $*.lnk - echo $(OBJ1e)+ >> $*.lnk - echo $(OBJ1f)+ >> $*.lnk - echo $(OBJ1g)+ >> $*.lnk - echo $(OBJ2a)+ >> $*.lnk - echo $(OBJ2b)+ >> $*.lnk - echo $(OBJ2c)+ >> $*.lnk - echo $(OBJ2d)+ >> $*.lnk - echo $(OBJ2e)+ >> $*.lnk - echo $(OBJ2f)$(LFLAGS)/base:$(BASE) >> $*.lnk - echo $*.dll >> $*.lnk - echo $* >> $*.lnk - echo $(NTDLLSHELL)\lib\spwnlnd+ >> $*.lnk - echo tdb+ >> $*.lnk - echo $(SNN)+ >> $*.lnk - echo $(LIBNT)\kernel32+ >> $*.lnk - echo $(LIBNT)\user32 >> $*.lnk - echo $*.def; >> $*.lnk + echo $(NTDLLSHELL)\lib\netsploc+ > $*.lnk + echo $(OBJ1a)+ >> $*.lnk + echo $(OBJ1b)+ >> $*.lnk + echo $(OBJ1c)+ >> $*.lnk + echo $(OBJ1d)+ >> $*.lnk + echo $(OBJ1e)+ >> $*.lnk + echo $(OBJ1f)+ >> $*.lnk + echo $(OBJ1g)+ >> $*.lnk + echo $(OBJ2a)+ >> $*.lnk + echo $(OBJ2b)+ >> $*.lnk + echo $(OBJ2c)+ >> $*.lnk + echo $(OBJ2d)+ >> $*.lnk + echo $(OBJ2e)+ >> $*.lnk + echo $(OBJ2f)$(LFLAGS)/base:$(BASE) >> $*.lnk + echo $*.dll >> $*.lnk + echo $* >> $*.lnk + echo $(NTDLLSHELL)\lib\spwnlnd+ >> $*.lnk + echo tdb+ >> $*.lnk + echo $(SNN)+ >> $*.lnk + echo $(LIBNT)\kernel32+ >> $*.lnk + echo $(LIBNT)\user32 >> $*.lnk + echo $*.def; >> $*.lnk #################################################### @@ -279,10 +295,10 @@ CCH= $(TK)\mem.h $(TK)\list.h $(TK)\vec.h ##################### GENERATED SOURCE ##################### msgs2.d msgs2.h msgs2.c : msgsx.exe - msgsx + msgsx msgsx.exe : msgsx.c - dmc msgsx -D$(TARGET) + dmc msgsx -D$(TARGET) ##################### ZIP ################################ @@ -308,15 +324,15 @@ HTODSRC= ppexp.d unialpha.d entity.d cpp.di dmcdll.di nspace.d dinit.d \ FRONTSRC= dmcdll.h scdll.h \ tdb.h \ \ - errmsgs2.c tdbx.c \ - msgsx.c \ - trace.c dmcdll.c \ - tk.c + errmsgs2.c tdbx.c \ + msgsx.c \ + trace.c dmcdll.c \ + tk.c # Back end BACKDSRC= bcomplex.d cc.d cdef.d cgcv.d code.d code_x86.d cv4.d \ - dwarf.d dwarf2.d el.d exh.d global.d iasm.d mach.d md5.di \ - mscoff.d obj.d oper.d rtlsym.d ty.d type.d xmm.d \ + dwarf.d dwarf2.d el.d exh.d global.d iasm.d mach.d md5.di \ + mscoff.d obj.d oper.d rtlsym.d ty.d type.d xmm.d \ divcoeff.d dvec.d dlist.d filespec.d evalu8.d go.d gsroa.d \ glocal.d goh.d md5.d mem.d varstats.di aarray.d @@ -344,10 +360,10 @@ BACKSRC= \ SRC= $(FRONTSRC) $(FRONTDSRC) $(BACKSRC) $(BACKDSRC) TKSRC= $(TK)\mem.h $(TK)\list.h $(TK)\vec.h $(TK)\filespec.h \ - $(TK)\mem.c + $(TK)\mem.c SHELLSRC= $(NTDLLSHELL)\include\dllrun.h $(NTDLLSHELL)\include\network.h \ - $(NTDLLSHELL)\include\nsidde.h $(NTDLLSHELL)\include\netspawn.h + $(NTDLLSHELL)\include\nsidde.h $(NTDLLSHELL)\include\netspawn.h LIBSRC= $(NTDLLSHELL)\lib\spwnlnd.lib $(NTDLLSHELL)\lib\netsploc.obj @@ -361,373 +377,373 @@ htod.exe : $(HTODSRC) msgs2.d dspeller.obj castab.d $(DMD) $(DFLAGS) $(HTODSRC) msgs2.d dspeller.obj -J. zip: - del dm$(VERSION).zip - zip32 -u dm$(VERSION) $(RELEASE) + del dm$(VERSION).zip + zip32 -u dm$(VERSION) $(RELEASE) zipsrc: - del dm$(VERSION)src.zip - zip32 -u dm$(VERSION)src $(SRC) tdb.lib $(LICENSE) backend.txt - zip32 -u dm$(VERSION)src $(TKSRC) - zip32 -u dm$(VERSION)src $(SHELLSRC) - zip32 -u dm$(VERSION)src $(LIBSRC) - zip32 -u dm$(VERSION)src $(BUILDSRC) + del dm$(VERSION)src.zip + zip32 -u dm$(VERSION)src $(SRC) tdb.lib $(LICENSE) backend.txt + zip32 -u dm$(VERSION)src $(TKSRC) + zip32 -u dm$(VERSION)src $(SHELLSRC) + zip32 -u dm$(VERSION)src $(LIBSRC) + zip32 -u dm$(VERSION)src $(BUILDSRC) detab: - detab $(SRC) $(TKSRC) $(SHELLSRC) + detab $(SRC) $(TKSRC) $(SHELLSRC) tolf: - tolf $(SRC) $(TKSRC) $(SHELLSRC) $(BUILDSRC) $(LICENSE) + tolf $(SRC) $(TKSRC) $(SHELLSRC) $(BUILDSRC) $(LICENSE) install: - cp $(SRC) $(BUILDSRC) tdb.lib $(LICENSE) \dm\src\dmc - cp $(TKSRC) \dm\src\dmc\tk - cp $(SHELLSRC) \dm\src\dmc\ntdllshell\include - cp $(LIBSRC) \dm\src\dmc\ntdllshell\lib + cp $(SRC) $(BUILDSRC) tdb.lib $(LICENSE) \dm\src\dmc + cp $(TKSRC) \dm\src\dmc\tk + cp $(SHELLSRC) \dm\src\dmc\ntdllshell\include + cp $(LIBSRC) \dm\src\dmc\ntdllshell\lib installbin: - cp scppn.exe sppn.exe scppnd.dll sppnd.dll htodn.exe \dm\bin + cp scppn.exe sppn.exe scppnd.dll sppnd.dll htodn.exe \dm\bin git: detab tolf $(BUILDSRC) - $(SCP) $(SRC) $(BUILDSRC) tdb.lib $(LICENSE) $(SCPDIR)/Compiler/dm/src/dmc/ - $(SCP) $(TKSRC) $(SCPDIR)/Compiler/dm/src/dmc/tk - $(SCP) $(SHELLSRC) $(SCPDIR)/Compiler/dm/src/dmc/ntdllshell/include - $(SCP) $(LIBSRC) $(SCPDIR)/Compiler/dm/src/dmc/ntdllshell/lib + $(SCP) $(SRC) $(BUILDSRC) tdb.lib $(LICENSE) $(SCPDIR)/Compiler/dm/src/dmc/ + $(SCP) $(TKSRC) $(SCPDIR)/Compiler/dm/src/dmc/tk + $(SCP) $(SHELLSRC) $(SCPDIR)/Compiler/dm/src/dmc/ntdllshell/include + $(SCP) $(LIBSRC) $(SCPDIR)/Compiler/dm/src/dmc/ntdllshell/lib gitback: detab tolf $(BACKSRC) - $(SCP) $(BACKSRC) walter@mercury:forks/dmd/src/backend/ + $(SCP) $(BACKSRC) walter@mercury:forks/dmd/src/backend/ ##################### SPECIAL BUILDS ##################### os.obj : os.c - $(CC) -c $(CFLAGS) os.c + $(CC) -c $(CFLAGS) os.c strtold.obj : strtold.c - $(CC) -c -o strtold.c + $(CC) -c -o strtold.c adl.obj : adl.d - $(DMD) -c $(DFLAGS) adl.d + $(DMD) -c $(DFLAGS) adl.d backconfig.obj : backconfig.d - $(DMD) -c $(DFLAGS) backconfig.d + $(DMD) -c $(DFLAGS) backconfig.d barray.obj : barray.d - $(DMD) -c $(DFLAGS) barray.d + $(DMD) -c $(DFLAGS) barray.d bcomplex.obj : bcomplex.d - $(DMD) -c $(DFLAGS) bcomplex.d + $(DMD79) -c $(DFLAGS) bcomplex.d blockopt.obj : blockopt.d - $(DMD) -c $(DFLAGS) blockopt.d + $(DMD) -c $(DFLAGS) blockopt.d dblklst.obj : dblklst.d - $(DMD) -c $(DFLAGS) dblklst.d + $(DMD) -c $(DFLAGS) dblklst.d cgcs.obj : cgcs.d - $(DMD) -c $(DFLAGS) cgcs.d + $(DMD) -c $(DFLAGS) cgcs.d dcode.obj : dcode.d - $(DMD) -c $(DFLAGS) dcode.d + $(DMD) -c $(DFLAGS) dcode.d cgcod.obj : cgcod.d - $(DMD) -c $(DFLAGS) -J. cgcod.d + $(DMD) -c $(DFLAGS) -J. cgcod.d cod1.obj : cod1.d - $(DMD) -c $(DFLAGS) cod1.d + $(DMD) -c $(DFLAGS) cod1.d cod2.obj : cod2.d - $(DMD) -c $(DFLAGS) cod2.d + $(DMD) -c $(DFLAGS) cod2.d cod3.obj : cod3.d - $(DMD) -c $(DFLAGS) cod3.d + $(DMD) -c $(DFLAGS) cod3.d cod4.obj : cod4.d - $(DMD) -c $(DFLAGS) cod4.d + $(DMD) -c $(DFLAGS) cod4.d cod5.obj : cod5.d - $(DMD) -c $(DFLAGS) cod5.d + $(DMD) -c $(DFLAGS) cod5.d codebuilder.obj : codebuilder.d - $(DMD) -c $(DFLAGS) -J. codebuilder.d + $(DMD) -c $(DFLAGS) -J. codebuilder.d code_x86.obj : code_x86.d - $(DMD) -c $(DFLAGS) code_x86.d + $(DMD) -c $(DFLAGS) code_x86.d cg.obj : cg.d - $(DMD) -c $(DFLAGS) -J. cg.d + $(DMD) -c $(DFLAGS) -J. cg.d cg87.obj : cg87.d - $(DMD) -c $(DFLAGS) -J. cg87.d + $(DMD) -c $(DFLAGS) -J. cg87.d cgcse.obj : cgcse.d - $(DMD) -c $(DFLAGS) cgcse.d + $(DMD) -c $(DFLAGS) cgcse.d cgelem.obj : cgelem.d - $(DMD) -c $(DFLAGS) -J. cgelem.d + $(DMD) -c $(DFLAGS) -J. cgelem.d cgen.obj : cgen.d - $(DMD) -c $(DFLAGS) cgen.d + $(DMD) -c $(DFLAGS) cgen.d cgobj.obj : cgobj.d code.d - $(DMDXX) -c $(DFLAGS) -J. cgobj.d code.d + $(DMDXX) -c $(DFLAGS) -J. cgobj.d code.d mscoffobj.obj : mscoffobj.d - $(DMD) -c $(DFLAGS) -J. mscoffobj.d + $(DMD) -c $(DFLAGS) -J. mscoffobj.d dvarstats.obj : dvarstats.d - $(DMD) -c $(DFLAGS) -J. dvarstats.d + $(DMD) -c $(DFLAGS) -J. dvarstats.d cgreg.obj : cgreg.d - $(DMD) -c $(DFLAGS) cgreg.d + $(DMD) -c $(DFLAGS) cgreg.d cgsched.obj : cgsched.d - $(DMD) -c $(DFLAGS) cgsched.d + $(DMD) -c $(DFLAGS) cgsched.d cgxmm.obj : cgxmm.d - $(DMD) -c $(DFLAGS) cgxmm.d + $(DMD) -c $(DFLAGS) cgxmm.d compress.obj : compress.d - $(DMD) -c $(DFLAGS) compress.d + $(DMD) -c $(DFLAGS) compress.d cv8.obj : cv8.d - $(DMD) -c $(DFLAGS) cv8.d + $(DMD) -c $(DFLAGS) cv8.d dcgcv.obj : dcgcv.d - $(DMD) -c $(DFLAGS) dcgcv.d + $(DMD) -c $(DFLAGS) dcgcv.d dcpp.obj : msgs2.d dcpp.d - $(DMD) -c $(DFLAGS) dcpp.d + $(DMD) -c $(DFLAGS) dcpp.d debugprint.obj : debugprint.d - $(DMD) -c $(DFLAGS) debugprint.d + $(DMD) -c $(DFLAGS) debugprint.d denum.obj : denum.d - $(DMD) -c $(DFLAGS) denum.d + $(DMD) -c $(DFLAGS) denum.d dt.obj : dt.d - $(DMD) -c $(DFLAGS) dt.d + $(DMD) -c $(DFLAGS) dt.d dwarfdbginf.obj : dwarfdbginf.d - $(DMD) -c $(DFLAGS) dwarfdbginf.d + $(DMD) -c $(DFLAGS) dwarfdbginf.d err.obj : err.d - $(DMD) -c $(DFLAGS) err.d + $(DMD) -c $(DFLAGS) err.d dexp2.obj : dexp2.d castab.d - $(DMD) -c $(DFLAGS) -J. dexp2.d + $(DMD) -c $(DFLAGS) -J. dexp2.d dfile.obj : dfile.d - $(DMD) -c $(DFLAGS) -J. dfile.d + $(DMD) -c $(DFLAGS) -J. dfile.d dgetcmd.obj : dgetcmd.d - $(DMD) -c $(DFLAGS) dgetcmd.d + $(DMD) -c $(DFLAGS) dgetcmd.d diasm.obj : diasm.d - $(DMD) -c $(DFLAGS) diasm.d + $(DMD) -c $(DFLAGS) diasm.d dmsc.obj : dmsc.d - $(DMD) -c $(DFLAGS) dmsc.d + $(DMD) -c $(DFLAGS) dmsc.d dnwc.obj : dnwc.d - $(DMD) -c $(DFLAGS) dnwc.d + $(DMD) -c $(DFLAGS) dnwc.d dph.obj : dph.d page.di - $(DMD) -c $(DFLAGS) dph.d + $(DMD79) -c $(DFLAGS) dph.d dpragma.obj : dpragma.d - $(DMD) -c $(DFLAGS) dpragma.d + $(DMD) -c $(DFLAGS) dpragma.d dscope.obj : dscope.d - $(DMD) -c $(DFLAGS) dscope.d + $(DMD) -c $(DFLAGS) dscope.d dspeller.obj : dspeller.d - $(DMD) -c $(DFLAGS) dspeller.d + $(DMD) -c $(DFLAGS) dspeller.d dtemplate.obj : dtemplate.d - $(DMD) -c $(DFLAGS) dtemplate.d + $(DMD79) -c $(DFLAGS) dtemplate.d dtype.obj : dtype.d - $(DMD) -c $(DFLAGS) dtype.d + $(DMD79) -c $(DFLAGS) dtype.d dwarfeh.obj : dwarfeh.d - $(DMD) -c $(DFLAGS) dwarfeh.d + $(DMD) -c $(DFLAGS) dwarfeh.d elem.obj : elem.d - $(DMD) -c $(DFLAGS) elem.d + $(DMD) -c $(DFLAGS) elem.d elpicpie.obj : elpicpie.d - $(DMD) -c $(DFLAGS) elpicpie.d + $(DMD) -c $(DFLAGS) elpicpie.d evalu8.obj : evalu8.d - $(DMD) -c $(DFLAGS) evalu8.d + $(DMD) -c $(DFLAGS) evalu8.d filespec.obj : filespec.d - $(DMD) -c $(DFLAGS) filespec.d + $(DMD) -c $(DFLAGS) filespec.d func.obj : func.d - $(DMD) -c $(DFLAGS) func.d + $(DMD) -c $(DFLAGS) func.d gdag.obj : gdag.d - $(DMD) -c $(DFLAGS) gdag.d + $(DMD) -c $(DFLAGS) gdag.d gflow.obj : gflow.d - $(DMD) -c $(DFLAGS) gflow.d + $(DMD) -c $(DFLAGS) gflow.d glocal.obj : glocal.d - $(DMD) -c $(DFLAGS) glocal.d + $(DMD) -c $(DFLAGS) glocal.d global.obj : global.d - $(DMD) -c $(DFLAGS) global.d + $(DMD) -c $(DFLAGS) global.d gloop.obj : gloop.d - $(DMD) -c $(DFLAGS) gloop.d + $(DMD) -c $(DFLAGS) gloop.d go.obj : go.d - $(DMD) -c $(DFLAGS) go.d + $(DMD) -c $(DFLAGS) go.d goh.obj : goh.d - $(DMD) -c $(DFLAGS) goh.d + $(DMD) -c $(DFLAGS) goh.d gother.obj : gother.d - $(DMD) -c $(DFLAGS) gother.d + $(DMD) -c $(DFLAGS) gother.d gsroa.obj : gsroa.d - $(DMD) -c $(DFLAGS) gsroa.d + $(DMD) -c $(DFLAGS) gsroa.d ini.obj : ini.d - $(DMD) -c $(DFLAGS) ini.d + $(DMD) -c $(DFLAGS) ini.d dinit.obj : dinit.d - $(DMD) -c $(DFLAGS) dinit.d + $(DMD) -c $(DFLAGS) dinit.d nspace.obj : nspace.d - $(DMD) -c $(DFLAGS) nspace.d + $(DMD) -c $(DFLAGS) nspace.d divcoeff.obj : divcoeff.d - $(DMD) -c $(DFLAGS) divcoeff.d + $(DMD) -c $(DFLAGS) divcoeff.d dvec.obj : dvec.d - $(DMD) -c $(DFLAGS) dvec.d + $(DMD) -c $(DFLAGS) dvec.d loadline.obj : loadline.d msgs2.d - $(DMD) -c $(DFLAGS) loadline.d + $(DMD) -c $(DFLAGS) loadline.d dinline.obj : dinline.d - $(DMD) -c $(DFLAGS) dinline.d + $(DMD) -c $(DFLAGS) dinline.d html.obj : html.d - $(DMD) -c $(DFLAGS) html.d + $(DMD) -c $(DFLAGS) html.d htod.obj : htod.d - $(DMD) -c $(DFLAGS) htod.d + $(DMD) -c $(DFLAGS) htod.d oper.obj : oper.d - $(DMD) -c $(DFLAGS) oper.d + $(DMD) -c $(DFLAGS) oper.d parser.obj : parser.d - $(DMD) -c $(DFLAGS) parser.d + $(DMD) -c $(DFLAGS) parser.d poptelem.obj : poptelem.d - $(DMD) -c $(DFLAGS) poptelem.d + $(DMD) -c $(DFLAGS) poptelem.d precomp.obj : precomp.d - $(DMD) -c $(DFLAGS) precomp.d + $(DMD) -c $(DFLAGS) precomp.d dlist.obj : dlist.d - $(DMD) -c $(DFLAGS) dlist.d + $(DMD) -c $(DFLAGS) dlist.d dstruct.obj : dstruct.d - $(DMD) -c $(DFLAGS) dstruct.d + $(DMD) -c $(DFLAGS) dstruct.d dth.obj : dt.d - $(DMD) -c $(DFLAGS) dt.d -ofdth.obj + $(DMD) -c $(DFLAGS) dt.d -ofdth.obj dtoken.obj : dtoken.d - $(DMD) -c $(DFLAGS) dtoken.d + $(DMD) -c $(DFLAGS) dtoken.d xtoken.obj : xtoken.d - $(DMD) -c $(DFLAGS) xtoken.d + $(DMD) -c $(DFLAGS) xtoken.d dutil.obj : dutil.d - $(DMD) -c $(DFLAGS) dutil.d + $(DMD) -c $(DFLAGS) dutil.d ee.obj : ee.d - $(DMD) -c $(DFLAGS) ee.d + $(DMD) -c $(DFLAGS) ee.d eh.obj : msgs2.d eh.d - $(DMD) -c $(DFLAGS) eh.d + $(DMD) -c $(DFLAGS) eh.d entity.obj : entity.d - $(DMD) -c $(DFLAGS) entity.d + $(DMD) -c $(DFLAGS) entity.d exp.obj : exp.d - $(DMD) -c $(DFLAGS) exp.d + $(DMD) -c $(DFLAGS) exp.d filename.obj : filename.d - $(DMD) -c $(DFLAGS) filename.d + $(DMD) -c $(DFLAGS) filename.d newman.obj : newman.d - $(DMD) -c $(DFLAGS) newman.d + $(DMD) -c $(DFLAGS) newman.d nteh.obj : nteh.d - $(DMD) -c $(DFLAGS) nteh.d + $(DMD) -c $(DFLAGS) nteh.d obj.obj : obj.d - $(DMD) -c $(DFLAGS) obj.d + $(DMD) -c $(DFLAGS) obj.d objrecor.obj : objrecor.d - $(DMD) -c $(DFLAGS) objrecor.d + $(DMD) -c $(DFLAGS) objrecor.d out.obj : out.d - $(DMD) -c $(DFLAGS) out.d + $(DMD) -c $(DFLAGS) out.d outbuf.obj : outbuf.d - $(DMD) -c $(DFLAGS) outbuf.d + $(DMD) -c $(DFLAGS) outbuf.d pdata.obj : pdata.d - $(DMD) -c $(DFLAGS) pdata.d + $(DMD) -c $(DFLAGS) pdata.d phstring.obj : phstring.d - $(DMD) -c $(DFLAGS) phstring.d + $(DMD) -c $(DFLAGS) phstring.d ppexp.obj : ppexp.d - $(DMD) -c $(DFLAGS) ppexp.d + $(DMD) -c $(DFLAGS) ppexp.d pseudo.obj : pseudo.d - $(DMD) -c $(DFLAGS) pseudo.d + $(DMD) -c $(DFLAGS) pseudo.d ptrntab.obj : ptrntab.d - $(DMD) -c $(DFLAGS) ptrntab.d + $(DMD) -c $(DFLAGS) ptrntab.d rawstring.obj : rawstring.d - $(DMD) -c $(DFLAGS) rawstring.d + $(DMD) -c $(DFLAGS) rawstring.d drtlsym.obj : rtlsym.d drtlsym.d - $(DMD) -c $(DFLAGS) drtlsym.d + $(DMD) -c $(DFLAGS) drtlsym.d rtti.obj : rtti.d - $(DMD) -c $(DFLAGS) rtti.d + $(DMD) -c $(DFLAGS) rtti.d stubobj.obj : stubobj.d - $(DMD) -c $(DFLAGS) stubobj.d + $(DMD) -c $(DFLAGS) stubobj.d symbol.obj : symbol.d - $(DMD) -c $(DFLAGS) symbol.d + $(DMD) -c $(DFLAGS) symbol.d symtab.obj : symtab.d - $(DMD) -c $(DFLAGS) symtab.d + $(DMD) -c $(DFLAGS) symtab.d tytostr.obj : tytostr.d - $(DMD) -c $(DFLAGS) tytostr.d + $(DMD) -c $(DFLAGS) tytostr.d unialpha.obj : unialpha.d - $(DMD) -c $(DFLAGS) unialpha.d + $(DMD) -c $(DFLAGS) unialpha.d utf.obj : utf.d - $(DMD) -c $(DFLAGS) utf.d + $(DMD) -c $(DFLAGS) utf.d var.obj : var.d - $(DMD) -c $(DFLAGS) var.d + $(DMD) -c $(DFLAGS) var.d ################# Source file dependencies ############### @@ -773,19 +789,19 @@ tdbx.obj : $(DEP) $(tdbx.dep) tdbx.c ################### Utilities ################ clean: - del *.obj - del *.lnk - del *.sym - del *.dep - del *.def -# del *.bak - del msgsx.exe - del *.map - del *.tmp - del *.lst - del *.exp - del *.dbg - del *.res - del msgs.c msgs2.d msgs2.h msgs2.c + del *.obj + del *.lnk + del *.sym + del *.dep + del *.def +# del *.bak + del msgsx.exe + del *.map + del *.tmp + del *.lst + del *.exp + del *.dbg + del *.res + del msgs.c msgs2.d msgs2.h msgs2.c ###################################