convert struct of bitfields to binary format - c

Question

R Instruction J Instruction J Instruction Instruction Table
So, I'm trying to convert 32bit instructions to machine-code binary.
Instruction for example: add #3, #5, #9:
has an opcode of 0.
rs will have the first operand value (3), rt will have the 2nd value (5) and rd will have the 3rd (9).
funct 1
6 bits of unused value, just 0s
#x - represent a register in memory
therefore the above R-type instruction will be represented in binary like so:
opCode rs rt rd funct unused
000001 00011 00101 01001 00001 000000 - 32 bits/4B instruction
My attempt to store each instruction:
typedef union __attribute__((__packed__))
{
struct
{
unsigned opcode : 6;
unsigned rs : 5;
unsigned rt : 5;
unsigned rd : 5;
unsigned funct : 5;
unsigned unused : 6;
} r;
struct
{
unsigned first : 8;
unsigned second : 8;
unsigned third : 8;
unsigned fourth : 8;
} bytes;
} r_instruction;
typedef union __attribute__((__packed__))
{
struct
{
unsigned rs : 5;
unsigned rt : 5;
unsigned opcode : 6;
unsigned immed : 16;
} i;
struct
{
unsigned first : 8;
unsigned second : 8;
unsigned third : 8;
unsigned fourth : 8;
} bytes;
} i_instruction;
typedef union __attribute__((__packed__))
{
struct
{
unsigned addr : 25;
unsigned opcode : 6;
unsigned isReg : 1;
} j;
struct
{
unsigned first : 8;
unsigned second : 8;
unsigned third : 8;
unsigned fourth : 8;
} bytes;
} j_instruction;
I need to output each instruction binary (like in the example) to a file, where each line is the instruction described in 4 bytes, each byte in Hexa representation, the byte order is little-endian.
so my input is:
;comment
MAIN: add #3, #5, #9
LOOP: ori #9, -5, #2
la val1
jmp Next
Next: move #20, #4
bgt #0, #2, END
la K
sw #0, 4, #10
bne #31, #9 , LOOP
call val1
jmp #4
END: stop
STR: .asciz "aBcd"
LIST: .db 6, -9
.dh 27056
.dw 5
.entry K
K: .dw 31,-12
.extern val1
desired output
(the first line is the above example's Hexadecimal representation).
but when I try to output each byte like so:
r_instruction inst;
inst.r.opcode = 0;
inst.r.rs = 3;
inst.r.rt = 5;
inst.r.rd = 9;
inst.r.funct = 1;
inst.r.unused = 0;
printf("%x %x %x %x", inst.bytes.first,
inst.bytes.second,
inst.bytes.third, inst.bytes.fourth);
>> c0 28 29 0
my main problem is how to convert my existing instruction to the requested presentation

Answer 1

Instead of using packed structs with bitfields, consider using normal structs and do the generation of the raw instruction yourself. For instance, let's take an instruction of type "J":
typedef struct { uint32_t addr; uint32_t opcode; uint32_t isReg; } j_instr;
// this function generates a 32-bit raw instruction (that you can then convert to ASCII hexadecimal or whatever you want)
uint32_t gen_j_instr(j_instr instr) {
uint32_t result = 0;
// let's add the opcode
result += instr.opcode << 26; // 26 is the starting position of opcode
// let's add the isReg
result += instr.isReg << 25; // 25 is the starting position of isReg
// let's add the addr
result += instr.addr; // no shift needed, addr is at position 0
return result;
}
The C11 standard gives implementations a lot of freedom when using structs with bitfields, therefore you can make few assumptions about their exact binary representation. On the other hand, using the previous method, you're completely independent of how your struct will be represented in binary.

Answer 2

put them in a union, together with a plain unsigned int;
typedef struct __attribute__((__packed__))
{
unsigned opcode : 6;
unsigned rs : 5;
unsigned rt : 5;
unsigned rd : 5;
unsigned funct : 5;
unsigned : 6;
} r_instruction;
typedef struct __attribute__((__packed__))
{
unsigned rs : 5;
unsigned rt : 5;
unsigned opcode : 6;
unsigned immed : 16;
} i_instruction;
typedef struct __attribute__((__packed__))
{
unsigned addr : 25;
unsigned opcode : 6;
unsigned isReg : 1;
} j_instruction;
union all_meuk {
r_instruction r_meuk;
i_instruction i_meuk;
j_instruction j_meuk;
unsigned all;
};