[BACK]Return to cgen-bitset.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / opcodes

Annotation of src/external/gpl3/binutils.old/dist/opcodes/cgen-bitset.c, Revision 1.1.1.3

1.1       christos    1: /* CGEN generic opcode support.
1.1.1.3 ! christos    2:    Copyright (C) 2002-2016 Free Software Foundation, Inc.
1.1       christos    3:
                      4:    This file is part of libopcodes.
                      5:
                      6:    This library is free software; you can redistribute it and/or modify
                      7:    it under the terms of the GNU General Public License as published by
                      8:    the Free Software Foundation; either version 3, or (at your option)
                      9:    any later version.
                     10:
                     11:    It is distributed in the hope that it will be useful, but WITHOUT
                     12:    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
                     13:    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
                     14:    License for more details.
                     15:
                     16:    You should have received a copy of the GNU General Public License along
                     17:    with this program; if not, write to the Free Software Foundation, Inc.,
                     18:    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
                     19:
                     20: /* Functions for manipulating CGEN_BITSET.  */
                     21:
                     22: #include "libiberty.h"
                     23: #include "cgen/bitset.h"
                     24: #include <string.h>
                     25:
                     26: /* Create a bit mask.  */
                     27:
                     28: CGEN_BITSET *
                     29: cgen_bitset_create (unsigned bit_count)
                     30: {
                     31:   CGEN_BITSET * mask = xmalloc (sizeof (* mask));
                     32:   cgen_bitset_init (mask, bit_count);
                     33:   return mask;
                     34: }
                     35:
                     36: /* Initialize an existing bit mask.  */
                     37:
                     38: void
                     39: cgen_bitset_init (CGEN_BITSET * mask, unsigned bit_count)
                     40: {
                     41:   if (! mask)
                     42:     return;
                     43:   mask->length = (bit_count / 8) + 1;
                     44:   mask->bits = xmalloc (mask->length);
                     45:   cgen_bitset_clear (mask);
                     46: }
                     47:
                     48: /* Clear the bits of a bit mask.  */
                     49:
                     50: void
                     51: cgen_bitset_clear (CGEN_BITSET * mask)
                     52: {
                     53:   unsigned i;
                     54:
                     55:   if (! mask)
                     56:     return;
                     57:
                     58:   for (i = 0; i < mask->length; ++i)
                     59:     mask->bits[i] = 0;
                     60: }
                     61:
                     62: /* Add a bit to a bit mask.  */
                     63:
                     64: void
                     65: cgen_bitset_add (CGEN_BITSET * mask, unsigned bit_num)
                     66: {
                     67:   int byte_ix, bit_ix;
                     68:   int bit_mask;
                     69:
                     70:   if (! mask)
                     71:     return;
                     72:   byte_ix = bit_num / 8;
                     73:   bit_ix = bit_num % 8;
                     74:   bit_mask = 1 << (7 - bit_ix);
                     75:   mask->bits[byte_ix] |= bit_mask;
                     76: }
                     77:
                     78: /* Set a bit mask.  */
                     79:
                     80: void
                     81: cgen_bitset_set (CGEN_BITSET * mask, unsigned bit_num)
                     82: {
                     83:   if (! mask)
                     84:     return;
                     85:   cgen_bitset_clear (mask);
                     86:   cgen_bitset_add (mask, bit_num);
                     87: }
                     88:
                     89: /* Test for a bit in a bit mask.
                     90:    Returns 1 if the bit is found  */
                     91:
                     92: int
                     93: cgen_bitset_contains (CGEN_BITSET * mask, unsigned bit_num)
                     94: {
                     95:   int byte_ix, bit_ix;
                     96:   int bit_mask;
                     97:
                     98:   if (! mask)
                     99:     return 1; /* No bit restrictions.  */
                    100:
                    101:   byte_ix = bit_num / 8;
                    102:   bit_ix = 7 - (bit_num % 8);
                    103:   bit_mask = 1 << bit_ix;
                    104:   return (mask->bits[byte_ix] & bit_mask) >> bit_ix;
                    105: }
                    106:
                    107: /* Compare two bit masks for equality.
                    108:    Returns 0 if they are equal.  */
                    109:
                    110: int
                    111: cgen_bitset_compare (CGEN_BITSET * mask1, CGEN_BITSET * mask2)
                    112: {
                    113:   if (mask1 == mask2)
                    114:     return 0;
                    115:   if (! mask1 || ! mask2)
                    116:     return 1;
                    117:   if (mask1->length != mask2->length)
                    118:     return 1;
                    119:   return memcmp (mask1->bits, mask2->bits, mask1->length);
                    120: }
                    121:
                    122: /* Test two bit masks for common bits.
                    123:    Returns 1 if a common bit is found.  */
                    124:
                    125: int
                    126: cgen_bitset_intersect_p (CGEN_BITSET * mask1, CGEN_BITSET * mask2)
                    127: {
                    128:   unsigned i, limit;
                    129:
                    130:   if (mask1 == mask2)
                    131:     return 1;
                    132:   if (! mask1 || ! mask2)
                    133:     return 0;
                    134:   limit = mask1->length < mask2->length ? mask1->length : mask2->length;
                    135:
                    136:   for (i = 0; i < limit; ++i)
                    137:     if ((mask1->bits[i] & mask2->bits[i]))
                    138:       return 1;
                    139:
                    140:   return 0;
                    141: }
                    142:
                    143: /* Make a copy of a bit mask.  */
                    144:
                    145: CGEN_BITSET *
                    146: cgen_bitset_copy (CGEN_BITSET * mask)
                    147: {
                    148:   CGEN_BITSET* newmask;
                    149:
                    150:   if (! mask)
                    151:     return NULL;
                    152:   newmask = cgen_bitset_create ((mask->length * 8) - 1);
                    153:   memcpy (newmask->bits, mask->bits, mask->length);
                    154:   return newmask;
                    155: }
                    156:
                    157: /* Combine two bit masks.  */
                    158:
                    159: void
                    160: cgen_bitset_union (CGEN_BITSET * mask1, CGEN_BITSET * mask2,
                    161:                   CGEN_BITSET * result)
                    162: {
                    163:   unsigned i;
                    164:
                    165:   if (! mask1 || ! mask2 || ! result
                    166:       || mask1->length != mask2->length
                    167:       || mask1->length != result->length)
                    168:     return;
                    169:
                    170:   for (i = 0; i < result->length; ++i)
                    171:     result->bits[i] = mask1->bits[i] | mask2->bits[i];
                    172: }

CVSweb <webmaster@jp.NetBSD.org>