How to do bitmasking for unsigned long int? - c++

Question

I am working on branch predicter implementation in that I need to create a Branch history register (BHR) which stores 1111 into the first 4 bits of an unsigned int, after every prediction. We will get output from Finite-state machine and that is updated into the BHR using left-shift. Can you explain for me how to do that?
Here's what I've tried:
struct BHR
{
long int BHR_index;
unsigned input = 0b1111u, n_bits = 4u, *bits =new unsigned[n_bits], bit = 0;
};
int main(int argc, char** argv)
{
long int table_size = 1227;
BHR *table = new BHR[table_size];
for(int k = 0;k<=table_size;k++)
{
for(table->bit = 0; table ->bit < table ->n_bits; ++table->bit)
table[k].bits[table -> bit] = (table -> input >> table ->bit)&1;
}
free(table->bits);
}
I did bit masking like this but I am getting thread 1: EXC_BAD_ACCESS (code=1, address=0x0) error in Xcode. Can anyone please help me.

Answer 1

If by "starting 4 bits" you mean the low (least significant) 4 bits, then this mask will clear all others, leaving those 4 bits intact:
unsigned long int someValue = 12345;
unsigned long int low4bits = someValue & 0xF;
This AND mask (& operator) works by clearing all bits in the destination that aren't set in both operands. So, as the value of 0xF in binary is ...0001111, all other bits will be cleared.
If you want the high (most significant) 4 bits, then you need to know the size of unsigned long int (although see below). If (as is common) this is 32-bits, then the mask you need will be as follows:
unsigned long int someValue = 12345;
unsigned long int high4bits = someValue & 0xF0000000;
Feel free to ask for further explanation and/or clarification.
EDIT:
Actually, there is a way to get the mask for the high 4 bits of an unsigned long int even if you don't know its actual size, but it maybe a bit confusing. The code below is not the most 'efficient' way, perhaps; rather, it is designed to illustrate the process:
unsigned long int zeroValue = 0; // All bits are clear.
unsigned long int notZero = ~zeroValue; // ~ inverts all bits, so now all set
unsigned long int top4Clear = notZero >> 4; // shift set bits by 4, and zero-pad top 4
unsigned long int top4Mask = ~top4Clear; // Again, the ~ operator inverts all bits
With this top4Mask value, we can now clear all but the high (most significant) bits:
unsigned long int someValue = 12345;
unsigned long int high4bits = someValue & top4Mask;

Answer 2

Another way is to use bit-fields that do the bit masking for you:
struct ulong4b {
unsigned long value : 4;
};
int main() {
ulong4b a;
a.value = 1; // Stores the lower 4 bits only.
unsigned long value = a.value; // Reads the lower 4 bits only.
}

Answer 3

I think that this macro will help you if you want to extract bits from a number :
#define GET_BITS(number, offbits, nbits) (((number) >> (offbits)) & ((1 << (nbits)) - 1))
int x = 12345;
int last4bits = GET_BITS(x, 0, 4); // last4bits = x & 0x0000000F;
int first4bits = GET_BITS(x, 32 - 4, 4); // first4bits = x & 0xF0000000;