evaluating segments of a byte in C - c

Question

I am trying to do disassembly of Intel 8080 without using disassembly tables. I read in bytes of memory and split them into sections of bits: (7, 6), (5, 4, 3), (2, 1, 0). I want to know what are the numerical values of these sections, here is an example:
given this byte:
0b00110000
bits 7 and 6 evaluate to:
0b00 -> 0
bits 5 through 3:
0b110 -> 6
bits 2 through 0:
0b000 -> 0
Now, I am very inexperienced with C and I'm having a hard time coming up with an elegant and simple solution to this problem. So far my idea was the following:
Create 3 copies of the byte (1 per section)
Clear all bits apart from the ones I'm interested in (bitwise AND mask)
Shift the byte an appropriate number of bits
Read the value
would this do the job or is there a better way?

Answer 1

If you think about what needs to be done, you only need be concerned about unary >> shift operator and the & operator. It also helps to come up with a bit mask to isolate only those wanted bits out of whatever intermediate calculation as may be required. (a bit mask is simply a variable holding a number whose 1 bits and 0 bits can by used in a bitwise operation to give you your desired result).
Here, in all your separating of bits, you will only be concerned with the 2 or 3 lower bits after you shift to get your final result. In the case you are looking at (7,6), there are no further bits to mask leaving only the case where you are looking at the lower 3 bits that will require a mask.
From a bit-mask (or what's the magic number) standpoint, you want a mask that will preserve the last 3-bits and discard all remaining higher bits. So for an 8-bit value you want 00000111, or simply the number 7.
To begin, if you want to examine the highest 2 bits in an 8-bit number, then you simply need to shift your number by 6 to the right, e.g. given a byte b holding the total value 0x00110000 in your case, you need.
b >> 6;
There is no need to mask anything here since no higher bits remain.
For bits (5,4,3) in your example, you need to shift to the right by 3, then you will need to & the intermediate result with your mask (7 or b00000111) to get rid of the two bits that remain (6,7), e.g.
uint8_t mask = 7;
...
(b >> 3) & mask;
In the last part, your (2,1,0) bits, no shifting is required, you just need to wipe out all bits over bit 2, e.g. get rid of (7,6,5,4,3) using your mask,
b & mask
Putting that altogether, using exact width types, you can do something similar to the following. The program takes your byte value as its first argument (using 48, e.g. 0x0011000 by default if no argument is given) and outputs the results of the shifts and masks:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>
int main (int argc, char *argv[]) {
uint64_t tmp = argc > 1 ? strtoul (argv[1], NULL, 0) : 48;
uint8_t b = 0,
mask = 7;
if (tmp > UINT8_MAX) {
fprintf (stderr, "input exceeds UINT8_MAX.\n");
return 1;
}
b = (uint8_t)tmp;
printf ("(7,6) 0x%02" PRIx8 "\n", b >> 6);
printf ("(5,4,3) 0x%02" PRIx8 "\n", (b >> 3) & mask);
printf ("(2,1,0) 0x%02" PRIx8 "\n", b & mask);
return 0;
}
Example Use/Output
$ /bin/bytes_233
(7,6) 0x00
(5,4,3) 0x06
(2,1,0) 0x00
Look things over and let me know if you have further questions.

Answer 2

To parse out specific bits of a binary value, we use bit shifts and bit masks. Any segment of bits can be obtained in this manner, using the concept of:
(data >> n) & mask
Where data is the raw data, n is the bit position where this data starts and mask is a bit mask of "all ones", corresponding to the length of the segment.
The mask of "all ones" can be obtained from knowing the segment size: (1u << size) - 1. If a segment's size is for example 3 bits, then 1<<3 gives 1000b. 1000b - 1 = 111b, which is a "all ones" mask of 3 bits.
So if we know the size in bits and the bit position (offset), we can get the data. Example:
#include <stdio.h>
#include <inttypes.h>
#define SEG1_BITS 2
#define SEG1_OFFSET 6
#define SEG2_BITS 3
#define SEG2_OFFSET 3
#define SEG3_BITS 2
#define SEG3_OFFSET 0
#define SEG1(d) ( ((uint32_t)d >> SEG1_OFFSET) & ((1u<<SEG1_BITS)-1) )
#define SEG2(d) ( ((uint32_t)d >> SEG2_OFFSET) & ((1u<<SEG2_BITS)-1) )
#define SEG3(d) ( ((uint32_t)d >> SEG3_OFFSET) & ((1u<<SEG3_BITS)-1) )
int main (void)
{
uint8_t data = 0x30;
printf("%"PRIu32"\n", SEG1(data));
printf("%"PRIu32"\n", SEG2(data));
printf("%"PRIu32"\n", SEG3(data));
return 0;
}
Advanced version with "X macro" to avoid code repetition:
#include <stdio.h>
#include <inttypes.h>
#define SEG_LIST \
/*bits, offset */ \
X(2, 6) \
X(3, 3) \
X(2, 0)
#define SEG(data, bits, n) ( ((uint32_t)data >> n) & ((1u<<bits)-1) )
int main (void)
{
uint8_t data = 0x30;
#define X(bits, n) printf("%"PRIu32"\n", SEG(data, bits, n));
SEG_LIST
#undef X
return 0;
}

Answer 3

Since the problem turned out to be of expansive nature, I had to generalise it and wrote this method:
uint8_t bitsAsValue(uint8_t* byte, int start, int end) {
uint8_t mask = 0b00000000;
uint8_t mask_setter = 0b00000001;
for (int i = start; i <= end; i++) {
mask |= (mask_setter << i);
}
uint8_t value = *byte & mask;
value = value >> start;
return value;
}
It will extract the value from a continuous segment of a byte.