From ad8a3f5159a168596a3fc7b8b6956bfbcd07a277 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Sat, 6 Oct 2012 15:09:00 -0700 Subject: New AIG optimization package. --- src/base/abci/abc.c | 4 + src/base/abci/abcNpn.c | 4 + src/opt/dau/dau.c | 53 ++++++ src/opt/dau/dauCore.c | 112 ++++++++++++ src/opt/dau/dauDsd.c | 446 ++++++++++++++++++++++++++++++++++++++++++++++++ src/opt/dau/dauInt.h | 69 ++++++++ src/opt/dau/module.make | 3 + 7 files changed, 691 insertions(+) create mode 100644 src/opt/dau/dau.c create mode 100644 src/opt/dau/dauCore.c create mode 100644 src/opt/dau/dauDsd.c create mode 100644 src/opt/dau/dauInt.h create mode 100644 src/opt/dau/module.make (limited to 'src') diff --git a/src/base/abci/abc.c b/src/base/abci/abc.c index d1acef62..ed20c0f7 100644 --- a/src/base/abci/abc.c +++ b/src/base/abci/abc.c @@ -823,6 +823,10 @@ void Abc_Init( Abc_Frame_t * pAbc ) extern void Dar_LibStart(); Dar_LibStart(); } + { + extern void Dau_DsdTest(); + Dau_DsdTest(); + } } /**Function************************************************************* diff --git a/src/base/abci/abcNpn.c b/src/base/abci/abcNpn.c index 9494cba2..85664f6b 100644 --- a/src/base/abci/abcNpn.c +++ b/src/base/abci/abcNpn.c @@ -202,6 +202,10 @@ void Abc_TruthNpnPerform( Abc_TtStore_t * p, int NpnType, int fVerbose ) { for ( i = 0; i < p->nFuncs; i++ ) { + extern void Dau_DsdTestOne( word t, int i ); + assert( p->nVars == 6 ); + Dau_DsdTestOne( *p->pFuncs[i], i ); + if ( fVerbose ) printf( "%7d : ", i ); if ( fVerbose ) diff --git a/src/opt/dau/dau.c b/src/opt/dau/dau.c new file mode 100644 index 00000000..c8929ae7 --- /dev/null +++ b/src/opt/dau/dau.c @@ -0,0 +1,53 @@ +/**CFile**************************************************************** + + FileName [dau.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [DAG-aware unmapping.] + + Synopsis [] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: dau.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "dauInt.h" + +ABC_NAMESPACE_IMPL_START + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ + + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + +ABC_NAMESPACE_IMPL_END + diff --git a/src/opt/dau/dauCore.c b/src/opt/dau/dauCore.c new file mode 100644 index 00000000..3922108b --- /dev/null +++ b/src/opt/dau/dauCore.c @@ -0,0 +1,112 @@ +/**CFile**************************************************************** + + FileName [dauCore.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [DAG-aware unmapping.] + + Synopsis [Disjoint-support decomposition.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: dauCore.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "dauInt.h" +#include "aig/aig/aig.h" + +ABC_NAMESPACE_IMPL_START + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +// parameter structure +typedef struct Xyz_ParTry_t_ Xyz_ParTry_t; +struct Xyz_ParTry_t_ +{ + int Par; +}; + +// operation manager +typedef struct Xyz_ManTry_t_ Xyz_ManTry_t; +struct Xyz_ManTry_t_ +{ + Xyz_ParTry_t * pPar; // parameters + Aig_Man_t * pAig; // user's AIG +}; + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Xyz_ManTry_t * Xyz_ManTryAlloc( Aig_Man_t * pAig, Xyz_ParTry_t * pPar ) +{ + Xyz_ManTry_t * p; + p = ABC_CALLOC( Xyz_ManTry_t, 1 ); + p->pAig = pAig; + p->pPar = pPar; + return p; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Xyz_ManTryFree( Xyz_ManTry_t * p ) +{ + ABC_FREE( p ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Xyz_ManPerform( Aig_Man_t * pAig, Xyz_ParTry_t * pPar ) +{ + Xyz_ManTry_t * p; + int RetValue; + p = Xyz_ManTryAlloc( pAig, pPar ); + RetValue = 1; + Xyz_ManTryFree( p ); + return RetValue; +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + +ABC_NAMESPACE_IMPL_END + diff --git a/src/opt/dau/dauDsd.c b/src/opt/dau/dauDsd.c new file mode 100644 index 00000000..1b690cb9 --- /dev/null +++ b/src/opt/dau/dauDsd.c @@ -0,0 +1,446 @@ +/**CFile**************************************************************** + + FileName [dauDsd.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [DAG-aware unmapping.] + + Synopsis [Disjoint-support decomposition.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: dauDsd.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "dauInt.h" + +ABC_NAMESPACE_IMPL_START + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +static word s_Truth6[6] = +{ + 0xAAAAAAAAAAAAAAAA, + 0xCCCCCCCCCCCCCCCC, + 0xF0F0F0F0F0F0F0F0, + 0xFF00FF00FF00FF00, + 0xFFFF0000FFFF0000, + 0xFFFFFFFF00000000 +}; + +// ! = not; (a + b) = a and b; [a + b] = a xor b; = ITE( a, b, c ) + + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Computes truth table for the DSD formula.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Dau_DsdFindMatch( char * p ) +{ + int Counter = 0; + assert( *p == '(' || *p == '[' || *p == '<' ); + while ( *p ) + { + if ( *p == '(' || *p == '[' || *p == '<' ) + Counter++; + else if ( *p == ')' || *p == ']' || *p == '>' ) + Counter--; + if ( Counter == 0 ) + return p; + p++; + } + return NULL; +} +word Dau_DsdToTruth_rec( char ** p ) +{ + int fCompl = 0; + if ( **p == '!' ) + (*p)++, fCompl = 1; + if ( **p >= 'a' && **p <= 'f' ) + return fCompl ? ~s_Truth6[**p - 'a'] : s_Truth6[**p - 'a']; + if ( **p == '(' || **p == '[' || **p == '<' ) + { + word Res = 0; + char * q = Dau_DsdFindMatch( *p ); + assert( q != NULL ); + assert( (**p == '(') == (*q == ')') ); + assert( (**p == '[') == (*q == ']') ); + assert( (**p == '<') == (*q == '>') ); + if ( **p == '(' ) // and/or + { + Res = ~0; + for ( (*p)++; *p < q; (*p)++ ) + Res &= Dau_DsdToTruth_rec( p ); + } + else if ( **p == '[' ) // xor + { + Res = 0; + for ( (*p)++; *p < q; (*p)++ ) + Res ^= Dau_DsdToTruth_rec( p ); + } + else if ( **p == '<' ) // mux + { + word Temp[3], * pTemp = Temp; + for ( (*p)++; *p < q; (*p)++ ) + *pTemp++ = Dau_DsdToTruth_rec( p ); + assert( pTemp == Temp + 3 ); + Res = (Temp[0] & Temp[1]) | (~Temp[0] & Temp[2]); + } + else assert( 0 ); + assert( *p == q ); + return fCompl ? ~Res : Res; + } + assert( 0 ); + return 0; +} +word Dau_DsdToTruth( char * p ) +{ + word Res; + if ( *p == '0' ) + Res = 0; + else if ( *p == '1' ) + Res = ~0; + else + Res = Dau_DsdToTruth_rec( &p ); + assert( *++p == 0 ); + return Res; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Dau_DsdTest2() +{ +// char * p = Abc_UtilStrsav( "!(ab!(de[cf]))" ); + char * p = Abc_UtilStrsav( "!(a![d]b)" ); + word t = Dau_DsdToTruth( p ); +} + + + +/**Function************************************************************* + + Synopsis [Performs DSD.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline word Dau_DsdCof0( word t, int iVar ) +{ + assert( iVar >= 0 && iVar < 6 ); + return (t &~s_Truth6[iVar]) | ((t &~s_Truth6[iVar]) << (1<= 0 && iVar < 6 ); + return (t & s_Truth6[iVar]) | ((t & s_Truth6[iVar]) >> (1<= 0 && iVar < 6 ); + return (t & s_Truth6[iVar]) != ((t << (1<= pBuffer + PosStart; pTemp[Len-1] = *pTemp, pTemp-- ) + if ( pTemp < pStop && *pTemp == (char)Symb ) + { + for ( i = 0; i < Len; i++ ) + pTemp[i] = pNext[i]; + Pos += Len - 1; + pStop = pTemp; + // check if there is symbol left + for ( ; pTemp >= pBuffer + PosStart; pTemp-- ) + if ( *pTemp == (char)Symb ) + break; + break; + } + } while ( pTemp >= pBuffer + PosStart ); + return Pos; +} +static inline int Dau_DsdPerformReplace( char * pBuffer, int PosStart, int Pos, int Symb, char * pNext ) +{ + static char pTemp[1000]; + char * pCur = pTemp; + int i, k, RetValue; + for ( i = PosStart; i < Pos; i++ ) + if ( pBuffer[i] != Symb ) + *pCur++ = pBuffer[i]; + else + for ( k = 0; pNext[k]; k++ ) + *pCur++ = pNext[k]; + RetValue = PosStart + (pCur - pTemp); + for ( i = PosStart; i < RetValue; i++ ) + pBuffer[i] = pTemp[i-PosStart]; + return RetValue; +} +int Dau_DsdPerform_rec( word t, char * pBuffer, int Pos, int * pVars, int nVars ) +{ + char pNest[10]; + word Cof0[6], Cof1[6], Cof[4]; + int pVarsNew[6], nVarsNew, PosStart; + int v, u, vBest, CountBest; + // copy remaining variables + nVarsNew = 0; + for ( v = 0; v < nVars; v++ ) + if ( Dau_DsdVarPres( t, pVars[v] ) ) + pVarsNew[ nVarsNew++ ] = pVars[v]; + assert( nVarsNew > 0 ); + if ( nVarsNew == 1 ) + { + if ( t == s_Truth6[ pVarsNew[0] ] ) + { + pBuffer[Pos++] = 'a' + pVarsNew[0]; + return Pos; + } + if ( t == ~s_Truth6[ pVarsNew[0] ] ) + { + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = 'a' + pVarsNew[0]; + return Pos; + } + assert( 0 ); + return Pos; + } + for ( v = 0; v < nVarsNew; v++ ) + { + Cof0[v] = Dau_DsdCof0( t, pVarsNew[v] ); + Cof1[v] = Dau_DsdCof1( t, pVarsNew[v] ); + assert( Cof0[v] != Cof1[v] ); + if ( Cof0[v] == 0 ) + { + pBuffer[Pos++] = '('; + pBuffer[Pos++] = 'a' + pVarsNew[v]; + Pos = Dau_DsdPerform_rec( Cof1[v], pBuffer, Pos, pVarsNew, nVarsNew ); + pBuffer[Pos++] = ')'; + return Pos; + } + if ( Cof0[v] == ~0 ) + { + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = '('; + pBuffer[Pos++] = 'a' + pVarsNew[v]; + Pos = Dau_DsdPerform_rec( ~Cof1[v], pBuffer, Pos, pVarsNew, nVarsNew ); + pBuffer[Pos++] = ')'; + return Pos; + } + if ( Cof1[v] == 0 ) + { + pBuffer[Pos++] = '('; + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = 'a' + pVarsNew[v]; + Pos = Dau_DsdPerform_rec( Cof0[v], pBuffer, Pos, pVarsNew, nVarsNew ); + pBuffer[Pos++] = ')'; + return Pos; + } + if ( Cof1[v] == ~0 ) + { + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = '('; + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = 'a' + pVarsNew[v]; + Pos = Dau_DsdPerform_rec( ~Cof0[v], pBuffer, Pos, pVarsNew, nVarsNew ); + pBuffer[Pos++] = ')'; + return Pos; + } + if ( Cof0[v] == ~Cof1[v] ) + { + pBuffer[Pos++] = '['; + pBuffer[Pos++] = 'a' + pVarsNew[v]; + Pos = Dau_DsdPerform_rec( Cof0[v], pBuffer, Pos, pVarsNew, nVarsNew ); + pBuffer[Pos++] = ']'; + return Pos; + } + } + for ( v = 0; v < nVarsNew; v++ ) + for ( u = v+1; u < nVarsNew; u++ ) + { + Cof[0] = Dau_DsdCof0( Cof0[v], pVarsNew[u] ); + Cof[1] = Dau_DsdCof1( Cof0[v], pVarsNew[u] ); + Cof[2] = Dau_DsdCof0( Cof1[v], pVarsNew[u] ); + Cof[3] = Dau_DsdCof1( Cof1[v], pVarsNew[u] ); + if ( Cof[0] == Cof[1] && Cof[0] == Cof[2] ) // vu + { + PosStart = Pos; + sprintf( pNest, "(%c%c)", 'a' + pVarsNew[v], 'a' + pVarsNew[u] ); + Pos = Dau_DsdPerform_rec( (s_Truth6[pVarsNew[u]] & Cof[3]) | (~s_Truth6[pVarsNew[u]] & Cof[0]), pBuffer, Pos, pVarsNew, nVarsNew ); + Pos = Dau_DsdPerformReplace( pBuffer, PosStart, Pos, 'a' + pVarsNew[u], pNest ); + return Pos; + } + if ( Cof[0] == Cof[1] && Cof[0] == Cof[3] ) // v!u + { + PosStart = Pos; + sprintf( pNest, "(%c!%c)", 'a' + pVarsNew[v], 'a' + pVarsNew[u] ); + Pos = Dau_DsdPerform_rec( (s_Truth6[pVarsNew[u]] & Cof[2]) | (~s_Truth6[pVarsNew[u]] & Cof[0]), pBuffer, Pos, pVarsNew, nVarsNew ); + Pos = Dau_DsdPerformReplace( pBuffer, PosStart, Pos, 'a' + pVarsNew[u], pNest ); + return Pos; + } + if ( Cof[0] == Cof[2] && Cof[0] == Cof[3] ) // !vu + { + PosStart = Pos; + sprintf( pNest, "(!%c%c)", 'a' + pVarsNew[v], 'a' + pVarsNew[u] ); + Pos = Dau_DsdPerform_rec( (s_Truth6[pVarsNew[u]] & Cof[1]) | (~s_Truth6[pVarsNew[u]] & Cof[0]), pBuffer, Pos, pVarsNew, nVarsNew ); + Pos = Dau_DsdPerformReplace( pBuffer, PosStart, Pos, 'a' + pVarsNew[u], pNest ); + return Pos; + } + if ( Cof[1] == Cof[2] && Cof[1] == Cof[3] ) // !v!u + { + PosStart = Pos; + sprintf( pNest, "(!%c!%c)", 'a' + pVarsNew[v], 'a' + pVarsNew[u] ); + Pos = Dau_DsdPerform_rec( (s_Truth6[pVarsNew[u]] & Cof[0]) | (~s_Truth6[pVarsNew[u]] & Cof[1]), pBuffer, Pos, pVarsNew, nVarsNew ); + Pos = Dau_DsdPerformReplace( pBuffer, PosStart, Pos, 'a' + pVarsNew[u], pNest ); + return Pos; + } + if ( Cof[0] == Cof[3] && Cof[1] == Cof[2] ) // v+u + { + PosStart = Pos; + sprintf( pNest, "[%c%c]", 'a' + pVarsNew[v], 'a' + pVarsNew[u] ); + Pos = Dau_DsdPerform_rec( (s_Truth6[pVarsNew[u]] & Cof[1]) | (~s_Truth6[pVarsNew[u]] & Cof[0]), pBuffer, Pos, pVarsNew, nVarsNew ); + Pos = Dau_DsdPerformReplace( pBuffer, PosStart, Pos, 'a' + pVarsNew[u], pNest ); + return Pos; + } + } + // look for MUX + vBest = -1; + CountBest = 10; + for ( v = 0; v < nVarsNew; v++ ) + { + int CountCur = 0; + for ( u = 0; u < nVarsNew; u++ ) + if ( u != v && Dau_DsdVarPres(Cof0[v], pVarsNew[u]) && Dau_DsdVarPres(Cof1[v], pVarsNew[u]) ) + CountCur++; + if ( CountBest > CountCur ) + { + CountBest = CountCur; + vBest = v; + } + if ( CountCur == 0 ) + break; + } + // perform MUX decomposition + pBuffer[Pos++] = '<'; + pBuffer[Pos++] = 'a' + pVarsNew[vBest]; + Pos = Dau_DsdPerform_rec( Cof1[vBest], pBuffer, Pos, pVarsNew, nVarsNew ); + Pos = Dau_DsdPerform_rec( Cof0[vBest], pBuffer, Pos, pVarsNew, nVarsNew ); + pBuffer[Pos++] = '>'; + return Pos; +} +char * Dau_DsdPerform( word t ) +{ + static char pBuffer[1000]; + int pVarsNew[6] = {0, 1, 2, 3, 4, 5}; + int Pos = 0; + if ( t == 0 ) + pBuffer[Pos++] = '0'; + else if ( t == ~0 ) + pBuffer[Pos++] = '1'; + else + Pos = Dau_DsdPerform_rec( t, pBuffer, Pos, pVarsNew, 6 ); + pBuffer[Pos++] = 0; + return pBuffer; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Dau_DsdTest() +{ +// word t = s_Truth6[0] & s_Truth6[1] & s_Truth6[2]; +// word t = ~s_Truth6[0] | (s_Truth6[1] ^ ~s_Truth6[2]); +// word t = (s_Truth6[1] & s_Truth6[2]) | (s_Truth6[0] & s_Truth6[3]); +// word t = (~s_Truth6[1] & ~s_Truth6[2]) | (s_Truth6[0] ^ s_Truth6[3]); +// word t = ((~s_Truth6[1] & ~s_Truth6[2]) | (s_Truth6[0] ^ s_Truth6[3])) ^ s_Truth6[5]; +// word t = ((s_Truth6[1] & ~s_Truth6[2]) ^ (s_Truth6[0] & s_Truth6[3])) & s_Truth6[5]; +// word t = (~(~s_Truth6[0] & ~s_Truth6[4]) & s_Truth6[2]) | (~s_Truth6[1] & ~s_Truth6[0] & ~s_Truth6[4]); +// word t = 0x0000000000005F3F; +// word t = 0xF3F5030503050305; +// word t = (s_Truth6[0] & s_Truth6[1] & (s_Truth6[2] ^ s_Truth6[4])) | (~s_Truth6[0] & ~s_Truth6[1] & ~(s_Truth6[2] ^ s_Truth6[4])); +// word t = 0x05050500f5f5f5f3; + word t = 0xFFAF00ACFFAF00AC; + char * p = Dau_DsdPerform( t ); + word t2 = Dau_DsdToTruth( p ); + if ( t != t2 ) + printf( "Verification failed.\n" ); +} +void Dau_DsdTestOne( word t, int i ) +{ + char * p; + word t2, t1; +// t = t & 0xFFFFFFFF; +// t |= (t << 32); + p = Dau_DsdPerform( t ); + return; + + t2 = Dau_DsdToTruth( p ); + if ( t != t2 ) + { + printf( "%8d : ", i ); + printf( "%30s ", p ); +// printf( "Verification failed. " ); + Kit_DsdPrintFromTruth( (unsigned *)&t, 6 ); +/* + printf( " " ); + t1 = Dau_DsdCof1(t, 3); + Kit_DsdPrintFromTruth( (unsigned *)&t1, 6 ); + + printf( " " ); + t1 = Dau_DsdCof0(t, 3); + Kit_DsdPrintFromTruth( (unsigned *)&t1, 6 ); +*/ + printf( " " ); + Kit_DsdPrintFromTruth( (unsigned *)&t2, 6 ); + printf( "\n" ); + } +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + +ABC_NAMESPACE_IMPL_END + + diff --git a/src/opt/dau/dauInt.h b/src/opt/dau/dauInt.h new file mode 100644 index 00000000..ba229c97 --- /dev/null +++ b/src/opt/dau/dauInt.h @@ -0,0 +1,69 @@ +/**CFile**************************************************************** + + FileName [dauInt.h] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [DAG-aware unmapping.] + + Synopsis [Interal declarations.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: dauInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#ifndef ABC__DAU_INT__h +#define ABC__DAU_INT__h + + +//////////////////////////////////////////////////////////////////////// +/// INCLUDES /// +//////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include "misc/vec/vec.h" + +//////////////////////////////////////////////////////////////////////// +/// PARAMETERS /// +//////////////////////////////////////////////////////////////////////// + + +ABC_NAMESPACE_HEADER_START + + +//////////////////////////////////////////////////////////////////////// +/// BASIC TYPES /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// MACRO DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +/*=== zzz.c ==========================================================*/ + + + +ABC_NAMESPACE_HEADER_END + + + +#endif + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + diff --git a/src/opt/dau/module.make b/src/opt/dau/module.make new file mode 100644 index 00000000..5fd9ef90 --- /dev/null +++ b/src/opt/dau/module.make @@ -0,0 +1,3 @@ +SRC += src/opt/dau/dau.c \ + src/opt/dau/daCore.c \ + src/opt/dau/daDsd.c -- cgit v1.2.3