CODEWITHSUNDEEP
cfile32-bit
akalikin
akalikin

Reputation: 1127

fetch 32bit instruction from binary file in C

I need to read 32bit instructions from a binary file. so what i have right now is:

unsigned char buffer[4];
fread(buffer,sizeof(buffer),1,file);

which will put 4 bytes in an array

how should I approach that to connect those 4 bytes together in order to process 32bit instruction later? Or should I even start in a different way and not use fread?

my weird method right now is to create an array of ints of size 32 and the fill it with bits from buffer array

Upvotes: 1

Views: 3050

Answers (4)

Reshetnikov Artyom
Reshetnikov Artyom

Reputation: 1

@luser droog

There are two bugs in your code.

The size of the variable "instruction" must not be 4 bytes: for example, Turbo C assumes sizeof(int) to be 2. Obviously, your program fails in this case. But, what is much more important and not so obvious: your program will also fail in case sizeof(int) be more than 4 bytes! To understand this, consider the following example:

int main()
{   const unsigned char a[4] = {0x21,0x43,0x65,0x87};
    const unsigned char* p = &a;
    unsigned long x = (((((p[3] << 8) + p[2]) << 8) + p[1]) << 8) + p[0];
    printf("%08lX\n", x);
    return 0;
}

This program prints "FFFFFFFF87654321" under amd64, because an unsigned char variable becomes SIGNED INT when it is used! So, changing the type of the variable "instruction" from "int" to "long" does not solve the problem.

The only way is to write something like:

unsigned long instruction;

instruction = 0;
for (int i = 0, unsigned char* p = buffer + 3; i < 4; i++, p--) {
    instruction <<= 8;
    instruction += *p;
}

Upvotes: 0

luser droog
luser droog

Reputation: 19484

If you know that the int in the file is the same endian as the machine the program's running on, then you can read straight into the int. No need for a char buffer.

unsigned int instruction;
fread(&instruction,sizeof(instruction),1,file);

If you know the endianness of the int in the file, but not the machine the program's running on, then you'll need to add and shift the bytes together.

unsigned char buffer[4];
unsigned int instruction;
fread(buffer,sizeof(buffer),1,file);

//big-endian
instruction = (buffer[0]<<24) + (buffer[1]<<16) + (buffer[2]<<8) + buffer[3];

//little-endian
instruction = (buffer[3]<<24) + (buffer[2]<<16) + (buffer[1]<<8) + buffer[0];

Another way to think of this is that it's a positional number system in base-256. So just like you combine digits in a base-10.

257 
= 2*100 + 5*10 + 7
= 2*10^2 + 5*10^1 + 7*10^0

So you can also combine them using Horner's rule.

//big-endian
instruction = ((((buffer[0]*256) + buffer[1]*256) + buffer[2]*256) + buffer[3]);

//little-endian
instruction = ((((buffer[3]*256) + buffer[2]*256) + buffer[1]*256) + buffer[0]);

Upvotes: 0

M Oehm
M Oehm

Reputation: 29116

The answer depends on how the 32-bit integer is stored in the binary file. (I'll assume that the integer is unsigned, because it really is an id, and use the type uint32_t from <stdint.h>.)

Native byte order The data was written out as integer on this machine. Just read the integer with fread:

uint32_t op;

fread(&op, sizeof(op), 1, file);

Rationale: fread read the raw representation of the integer into memory. The matching fwrite does the reverse: It writes the raw representation to thze file. If you don't need to exchange the file between platforms, this is a good method to store and read data.

Little-endian byte order The data is stored as four bytes, least significant byte first:

uint32_t op = 0u;

op |= getc(file);            // 0x000000AA
op |= getc(file) << 8;       // 0x0000BBaa
op |= getc(file) << 16;      // 0x00CCbbaa
op |= getc(file) << 24;      // 0xDDccbbaa

Rationale: getc reads a char and returns an integer between 0 and 255. (The case where the stream runs out and getc returns the negative value EOF is not considered here for brevity, viz laziness.) Build your integer by shifting each byte you read by multiples of 8 and or them with the existing value. The comments sketch how it works. The capital letters are being read, the lower-case letters were already there. Zeros have not yet been assigned.

Big-endian byte order The data is stored as four bytes, least significant byte last:

uint32_t op = 0u;

op |= getc(file) << 24;      // 0xAA000000
op |= getc(file) << 16;      // 0xaaBB0000
op |= getc(file) << 8;       // 0xaabbCC00
op |= getc(file);            // 0xaabbccDD

Rationale: Pretty much the same as above, only that you shift the bytes in another order.

You can imagine little-endian and big-endian as writing the number one hundred and twenty tree (CXXIII) as either 321 or 123. The bit-shifting is similar to shifting decimal digtis when dividing by or multiplying with powers of 10, only that you shift my 8 bits to multiply with 2^8 = 256 here.

Upvotes: 2

Arshan
Arshan

Reputation: 744

Add

unsigned int instruction;
memcpy(&instruction,buffer,4);

to your code. This will copy the 4 bytes of buffer to a single 32-bit variable. Hence you will get connected 4 bytes :)

Upvotes: 1

Related Questions