Open64: osprey/libkapi/kapi

00001 /*
00002  * Copyright (c) 2000, Intel Corporation
00003  * All rights reserved.
00004  *
00005  * WARRANTY DISCLAIMER
00006  *
00007  * THESE MATERIALS ARE PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00008  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
00009  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00010  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS 
00011  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00012  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00013  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
00014  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
00015  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
00016  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THESE
00017  * MATERIALS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00018  *
00019  * Intel Corporation is the author of the Materials, and requests that all
00020  * problem reports or change requests be submitted to it directly at
00021  * http://developer.intel.com/opensource.
00022  */
00023 
00024 /* Non MED section begin */
00025 
00026 /* static char sccs_id[] = "@(#)sbv.h 1.1  08/02/96  13:01:46"; */
00027 
00028 #ifndef _KAPI_BV_H_
00029 #define _KAPI_BV_H_
00030 
00031 #include <inttypes.h>
00032 #include <stdio.h>
00033 
00034 #ifdef __cplusplus
00035 extern "C" {
00036 #endif
00037 /* Non MED section end */
00038 /*---------------------------**
00039 **                           **
00040 ** Bit Vector Library Macros **
00041 **                           **
00042 **                           **
00043 **---------------------------*/
00044 
00045 
00046 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00047 /* ------------------- 32 bit stuff ------------------------- */
00048 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00049 
00050 typedef uint32_t bv32_t;         /* 32-bit long bit vector */
00051 
00052 #define i2bv32( i ) ( 1 << (i) )
00053 
00054 #define ZERO_bv32( bv )       \
00055     ((bv) = 0)
00056 
00057 #define ONE_bv32(bv)  \
00058   ((bv)=0xFFFFFFFF)
00059 
00060 #define bv32ZEROS() ( 0 )
00061 
00062 #define bv32ONES( len ) \
00063    ( ((len) == 0) ? 0 : ( ( (len) < 32 ) ? ( 1 << (len) ) - 1 : 0xFFFFFFFF ) )
00064 
00065 #define bv32ONES_MASK( len, pos ) \
00066    ( bv32ONES(len) << ( pos ) )
00067 
00068 #define bv32SHL( bv32Src, len ) \
00069    ( ((len)>=32) ? 0 : ( (bv32Src) << (len) ) )
00070 
00071 #define bv32SHRL( bv32Src, len ) \
00072    ( ( (len)>=32) ? 0 : ( ( (uint32_t) (bv32Src) ) >> (len) ) )
00073 
00074 #define bv32EXTRACTU( bv32Src, len, pos ) \
00075      ( bv32SHRL( (bv32Src), (pos) ) & bv32ONES(len) )
00076 
00077 
00078 #define isbv32ZERO( bv ) \
00079    ( (bv) == 0 )
00080 
00081 #define isbv32BITSET( bv, pos )              \
00082    ( ( (bv) & ( 1 << ((pos)) ) ) )
00083 
00084 
00085 #define bv32AND( bv1, bv2 ) \
00086    ( (bv1) & (bv2) )
00087 
00088 #define bv32OR( bv1, bv2 ) \
00089    ( (bv1) | (bv2) )
00090 
00091 #define bv32XOR( bv1, bv2 ) \
00092    ( (bv1) ^ (bv2) )
00093 
00094 #define bv32NOT( bvRes, bv ) \
00095    { (bvRes) = ~(bv); }
00096 
00097 
00098 #define UNSETBIT_bv32( bv, pos ) {      \
00099        (bv) &= ~( 1 << (pos) );  } 
00100 
00101 #define SETBIT_bv32( bv, pos ) {      \
00102        (bv) |= ( 1 << (pos) );  } 
00103 
00104 #define COPY_bv32( bvTar, bvSrc ) {       \
00105    (bvTar) = (bvSrc);  }
00106 
00107 extern char *bv322pch(  bv32_t  bv32,  char *pch );
00108 
00109 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00110 /* ------------------- 64 bit stuff ------------------------- */
00111 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00112 
00113 typedef struct _BV64_T {
00114    uint32_t i1, i2;   /* 64 bit long vector */
00115 } bv64_t;
00116 
00117 
00118 #define isbv64ZERO( bv ) \
00119    ( (bv.i1) == 0 && (bv.i2) == 0  )
00120 
00121 #define isbv64BITSET( bv, pos )              \
00122    ( ( (pos) < 32 ) ? (                      \
00123        ( bv.i1 & ( 1 << ((pos)) ) ) ) : (    \
00124      ( ( bv.i2 & ( 1 << ((pos)-32) ) ) ) ) ) 
00125 
00126 
00127 #define ZERO_bv64( bv )       \
00128    { (bv.i1) = 0; (bv.i2) = 0;  }
00129 
00130 #define SETBIT_bv64( bv, pos ) {      \
00131    { if ( (pos) < 32 ) {               \
00132        bv.i1 |= ( 1 << (pos) );      \
00133    } else if ( (pos) < 64 ) { \
00134        bv.i2 |= ( 1 << ((pos)-32) ); \
00135    }  } }
00136 
00137 #define COPY_bv64( bvTar, bvSrc ) {       \
00138    bvTar.i1 = bvSrc.i1;                 \
00139    bvTar.i2 = bvSrc.i2; }
00140 
00141 #define ONES_bv64( bv64Tar, len ) \
00142    { \
00143       if ( (len) == 0 ) { \
00144          bv64Tar.i1 = 0; \
00145          bv64Tar.i2 = 0; \
00146       } if ( (len) <= 32 ) { \
00147          bv64Tar.i1 = bv32ONES( len ); \
00148          bv64Tar.i2 = 0; \
00149       } else { \
00150          bv64Tar.i1 = 0xFFFFFFFF; \
00151          bv64Tar.i2 = bv32ONES( (len)-32 ); \
00152       }  \
00153    }
00154 
00155 
00156 #define OR_SELF_bv64( bvRes, bv1 ) \
00157    { (bvRes.i1) |= ( bv1.i1 );      \
00158    (bvRes.i2) |= ( bv1.i2 ); }
00159 
00160 #define AND_SELF_bv64( bvRes, bv1 ) \
00161    { (bvRes.i1) &=  ( bv1.i1 );           \
00162    (bvRes.i2) &=  ( bv1.i2 ); }
00163 
00164 #define OR_2_bv64( bvRes, bv1, bv2 )    \
00165    { (bvRes.i1) = (bv1.i1) | ( bv2.i1 ); \
00166    (bvRes.i2) = (bv1.i2) | ( bv2.i2 ); }
00167 
00168 #define AND_2_bv64( bvRes, bv1, bv2 )   \
00169    { (bvRes.i1) = (bv1.i1) & ( bv2.i1 ); \
00170    (bvRes.i2) = (bv1.i2) & ( bv2.i2 ); }
00171 
00172 #define OR_3SELF_bv64( bvRes, bv1, bv2, bv3 ) \
00173    { (bvRes.i1) |= (bv1.i1) | ( bv2.i1 ) | (bv3.i1); \
00174    (bvRes.i2) |= (bv1.i2) | ( bv2.i2 ) | (bv3.i2); }
00175 
00176 #define AND_3SELF_bv64( bvRes, bv1, bv2, bv3 )        \
00177    { (bvRes.i1) &= (bv1.i1) & ( bv2.i1 ) & ( bv3.i1 ); \
00178    (bvRes.i2) &= (bv1.i2) & ( bv2.i2 ) & ( bv3.i2 ); }
00179 
00180 #define NOT_bv64( bvRes, bv ) \
00181    { (bvRes.i1) = ~(bv.i1);    \
00182    (bvRes.i2) = ~(bv.i2); }
00183 
00184 #define SHL_bv64( bv64Tar, bv64Src, len ) \
00185    { \
00186  \
00187       bv64Tar.i1 = bv32SHL( bv64Src.i1, (len) ); \
00188       bv64Tar.i2 = bv32SHL( bv64Src.i2, (len) ); \
00189  \
00190       /* compute high order len bits of i1 */ \
00191       if ( (len) > 32 ) { \
00192          bv64Tar.i2 |= bv32SHL( bv64Src.i1, (len)-32 ); \
00193       } else { \
00194          bv64Tar.i2 |= bv32EXTRACTU( bv64Src.i1, (len), 32-(len) ); \
00195       } \
00196    }
00197 
00198 
00199 #define SHRL_bv64( bv64Tar, bv64Src, len ) \
00200    { \
00201       bv64Tar.i1 = bv32SHRL( bv64Src.i1, (len) ); \
00202       bv64Tar.i2 = bv32SHRL( bv64Src.i2, (len) ); \
00203  \
00204       /* extract low order bits of i2 */ \
00205       if ( (len) > 32 ) { \
00206          bv64Tar.i1 |= bv32SHRL( bv64Src.i2, (len)-32 ); \
00207       } else { \
00208          bv64Tar.i1 |= bv32SHL( bv32EXTRACTU( bv64Src.i2, (len), 0 ), 32-(len) ); \
00209       } \
00210    }
00211 
00212 #define EXTRACTU_bv64( bv64Tar, bv64Src, len, pos ) \
00213    { \
00214      SHRL_bv64( bv64Tar, bv64Src, (pos) ) \
00215      bv64Tar.i1 &= bv32ONES( len ); \
00216      bv64Tar.i2 &= ( (len)>32 ) ? bv32ONES(64 - (len)) : 0; \
00217    }
00218 
00219 extern char *bv642pch(  bv64_t  bv64,  char *pch );
00220 
00221 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00222 /* ------------------- 128 bit stuff ------------------------ */
00223 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00224 
00225 typedef struct _BV128_T {
00226    uint32_t i1, i2, i3, i4;   /* 128 bit long vector */
00227 } bv128_t;
00228 
00229 
00230 #define OR_SELF_bv128( bvRes, bv1 ) \
00231    { (bvRes.i1) |= ( bv1.i1 ); \
00232    (bvRes.i2) |= ( bv1.i2 ); \
00233    (bvRes.i3) |= ( bv1.i3 ); \
00234    (bvRes.i4) |= ( bv1.i4 ); }
00235 
00236 #define AND_SELF_bv128( bvRes, bv1 ) \
00237   {  (bvRes.i1) &=  ( bv1.i1 ); \
00238    (bvRes.i2) &=  ( bv1.i2 ); \
00239    (bvRes.i3) &=  ( bv1.i3 ); \
00240    (bvRes.i4) &=  ( bv1.i4 ); }
00241 
00242 #define OR_2_bv128( bvRes, bv1, bv2 )   \
00243    { (bvRes.i1) = (bv1.i1) | ( bv2.i1 ); \
00244    (bvRes.i2) = (bv1.i2) | ( bv2.i2 ); \
00245    (bvRes.i3) = (bv1.i3) | ( bv2.i3 ); \
00246    (bvRes.i4) = (bv1.i4) | ( bv2.i4 ); }
00247 
00248 #define AND_2_bv128( bvRes, bv1, bv2 )  \
00249    { (bvRes.i1) = (bv1.i1) & ( bv2.i1 ); \
00250    (bvRes.i2) = (bv1.i2) & ( bv2.i2 ); \
00251    (bvRes.i3) = (bv1.i3) & ( bv2.i3 ); \
00252    (bvRes.i4) = (bv1.i4) & ( bv2.i4 ); }
00253 
00254 #define OR_3SELF_bv128( bvRes, bv1, bv2, bv3 )      \
00255    { (bvRes.i1) |= (bv1.i1) | ( bv2.i1 ) | (bv3.i1); \
00256    (bvRes.i2) |= (bv1.i2) | ( bv2.i2 ) | (bv3.i2); \
00257    (bvRes.i3) |= (bv1.i3) | ( bv2.i3 ) | (bv3.i3); \
00258    (bvRes.i4) |= (bv1.i4) | ( bv2.i4 ) | (bv3.i4); }
00259 
00260 #define AND_3SELF_bv128( bvRes, bv1, bv2, bv3 )       \
00261    { (bvRes.i1) &= (bv1.i1) & ( bv2.i1 ) & ( bv3.i1 ); \
00262    (bvRes.i2) &= (bv1.i2) & ( bv2.i2 ) & ( bv3.i2 ); \
00263    (bvRes.i3) &= (bv1.i3) & ( bv2.i3 ) & ( bv3.i3 ); \
00264    (bvRes.i4) &= (bv1.i4) & ( bv2.i4 ) & ( bv3.i4 ); }
00265 
00266 #define NOT_bv128( bvRes, bv ) \
00267    { (bvRes.i1) = ~(bv.i1);     \
00268    (bvRes.i2) = ~(bv.i2);     \
00269    (bvRes.i3) = ~(bv.i3);     \
00270    (bvRes.i4) = ~(bv.i4); }
00271    
00272 #define ZERO_bv128( bv )       \
00273    { (bv.i1) = 0; (bv.i2) = 0;  \
00274    (bv.i3) = 0; (bv.i4) = 0;  }
00275 
00276 #define ONE_bv128(bv) \
00277    { (bv.i1) = 0xFFFFFFFF; (bv.i2) = 0xFFFFFFFF;  \
00278    (bv.i3) = 0xFFFFFFFF; (bv.i4) = 0xFFFFFFFF;  }
00279 
00280 
00281 #define isbv128ZERO( bv )             \
00282    (    (bv.i1) == 0 && (bv.i2) == 0  \
00283      && (bv.i3) == 0 && (bv.i4) == 0 )
00284 
00285 #define isbv128BITSET( bv, pos )               \
00286    ( ( (pos) < 32 ) ? (                        \
00287        ( bv.i1 & ( 1 << ((pos)) ) ) ) : (      \
00288      ( (pos) < 64 ) ? (                        \
00289         ( bv.i2 & ( 1 << ((pos)-32) ) ) ) : (  \
00290      ( (pos) < 96 ) ? (                        \
00291         ( bv.i3 & ( 1 << ((pos)-64) ) ) ) :    \
00292      ( bv.i4 & ( 1 << ((pos)-96) ) ) ) ) )    
00293 
00294 #define SETBIT_bv128( bv, pos )       \
00295    { if ( (pos) < 32 ) {               \
00296        bv.i1 |= ( 1 << (pos) );      \
00297    } else if ( (pos) < 64 ) {        \
00298        bv.i2 |= ( 1 << ((pos)-32) ); \
00299    } else if ( (pos) < 96 ) {        \
00300        bv.i3 |= ( 1 << ((pos)-64) ); \
00301    } else {                          \
00302        bv.i4 |= ( 1 << ((pos)-96) ); \
00303    } }
00304 
00305 #define COPY_bv128( bvTar, bvSrc )       \
00306    { bvTar.i1 = bvSrc.i1;                 \
00307    bvTar.i2 = bvSrc.i2;                 \
00308    bvTar.i3 = bvSrc.i3;                 \
00309    bvTar.i4 = bvSrc.i4; }
00310 
00311 extern char *bv1282pch( bv128_t bv128, char *pch );
00312 
00313 
00314 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00315 /* ------------------- Arbitrary  bit stuff ----------------- */
00316 /* = = = = = = = = = = = = = = = = == = = = = = = = = = = = = */
00317 
00318 typedef struct _BV_T {
00319    int n32Chunks;
00320    uint32_t *pint32Data;
00321 } bv_t;
00322 
00323 #define BYTE_LENGTHbv( pbv ) \
00324      ( 4 * (pbv)->n32Chunks )
00325 
00326 #define BIT_LENGTHbv( pbv ) \
00327      ( 32 * (pbv)->n32Chunks )
00328 
00329 #define isbvBITSET( pbv, pos )               \
00330    ( (pbv)->n32Chunks == 0 ? 0 : ((pbv)->pint32Data[ (pos) >> 5 ] &   ( 1 << ((pos) & 0x1F )) ) )
00331 
00332 #define SETBIT_bv( pbv, pos )       \
00333    { (pbv)->pint32Data[ (pos) >> 5 ] |=  ( 1 << ((pos) & 0x1F) ); }
00334 
00335 #define UNSETBIT_bv( pbv, pos )       \
00336    { (pbv)->pint32Data[ (pos) >> 5 ] &= ~( 1 << ((pos) & 0x1F) ); }
00337 
00338 #define ONE_bv( pbv )       \
00339    {  \
00340      memset( (pbv)->pint32Data, 0xFFFFFFFF,  BYTE_LENGTHbv(pbv) );  \
00341    }
00342 
00343 #define ZERO_bv( pbv )       \
00344    {  \
00345      memset( (pbv)->pint32Data, 0,  BYTE_LENGTHbv(pbv) );  \
00346    }
00347 
00348 extern bv_t *pbvMake  ( int iLength,    int fOn );
00349 extern bv_t *pbvDup( bv_t *pbv );
00350 extern void bvInit ( bv_t *pbv, int iLength, int fOn );
00351 extern void bvResize( bv_t *pbv, int iNewLength, int fOn );
00352 
00353 extern int  fEqual_bv( bv_t *pbv1, bv_t *pbv2 );
00354 
00355 extern bv_t *pbvOr ( bv_t *pbvTarget, bv_t *pbvSrc1, bv_t *pbvSrc2 );
00356 extern bv_t *pbvAnd( bv_t *pbvTarget, bv_t *pbvSrc1, bv_t *pbvSrc2 );
00357 extern bv_t *pbvXor( bv_t *pbvTarget, bv_t *pbvSrc1, bv_t *pbvSrc2 );
00358 
00359 /* output routines */
00360 
00361 /* Non MED section begin */
00362 extern void Printbv( FILE *fp, bv_t *pbv );
00363 /* Non MED section end */
00364 
00365 extern void Free_pbv( bv_t *pbv );
00366 
00367 
00368 
00369 #define u32ALLOCATED( length ) ( ( ((length-1) / 32) + 1 ))
00370 
00371 /* Non MED section begin */
00372 #ifdef __cplusplus
00373 }
00374 #endif
00375 
00376 #endif
00377 /* Non MED section end */
osprey/libkapi/kapi_bv.h
