They're bit-fields, an example being that unsigned int addr:9; creates an addr field 9 bits long.

It's commonly used to pack lots of values into an integral type. In your particular case, it defining the structure of a 32-bit microcode instruction for a (possibly) hypothetical CPU (if you add up all the bit-field lengths, they sum to 32).

The union allows you to load in a single 32-bit value and then access the individual fields with code like (minor problems fixed as well, specifically the declarations of code and test):

#include <stdio.h>

struct microFields {
    unsigned int addr:9;
    unsigned int cond:2;
    unsigned int wr:1;
    unsigned int rd:1;
    unsigned int mar:1;
    unsigned int alu:3;
    unsigned int b:5;
    unsigned int a:5;
    unsigned int c:5;
};

union micro {
    unsigned int microCode;
    struct microFields code;
};

int main (void) {
    int myAlu;
    union micro test;
    test.microCode = 0x0001c000;
    myAlu = test.code.alu;
    printf("%d\n",myAlu);
    return 0;
}

This prints out 7, which is the three bits making up the alu bit-field.

In C, arguments are passed by values. For example if you have an integer varaible in main

int main( void )
{
    int x = 10;
    //...

and the following function

void f( int x )
{
    x = 20;
    printf( "x = %d\n", x );
} 

then, if you call the function in main like this

f( x );

then the parameter gets the value of variable x in main. However the parameter itself occupies a different extent in memory than the argument. So any changes of the parameter in the function do not influence to the original variable in main because these changes occur in a different memory extent.

So how to change the varible in main in the function?

You need to pass a reference to the variable using pointers.

In this case the function declaration will look like

void f( int *px );

and the function definition will be

void f( int *px )
{
    *px = 20;
    printf( "*px = %d\n", *px );
} 

In this case, the memory extent occupied by the original variable x is changed because, within the function, we get access to this extent using the pointer

    *px = 20;

Naturally the function must be called in main like this

f( &x );

Take into account that the parameter itself that is the pointer px is a local variable of the function. That is, the function creates this variable and initializes it with the address of variable x.

Now let's assume that in main you declared a pointer for example the following way

int main( void )
{
   int *px = malloc( sizeof( int ) );
   //..

And the function is defined like

void f( int *px )
{
    px = malloc( sizeof( int ) );

    printf( "px = %p\n", px );
}

As parameter px is a local variable, assigning to it any value does not influence the original pointer. The function changes a different extent of memory than the extent occupied by the original pointer px in main.

How to change the original pointer in the function? Just pass it by reference!

For example

f( &px );
//...

void f( int **px )
{
    *px = malloc( sizeof( int ) );

    printf( "*px = %p\n", *px );
}

In this case, the value stored in the original pointer will be changed within the function because the function is using dereferencing, accessing the same memory extent where the original pointer was defined.

* and & as type modifiers

• int i declares an int.
• int* p declares a pointer to an int.
• int& r = i declares a reference to an int, and initializes it to refer to i.
  C++ only. Note that references must be assigned at initialization, therefore int& r; is not possible.

Similarly:

• void foo(int i) declares a function taking an int (by value, i.e. as a copy).
• void foo(int* p) declares a function taking a pointer to an int.
• void foo(int& r) declares a function taking an int by reference. (C++ only)

* and & as operators

• foo(i) calls foo(int). The parameter is passed as a copy.
• foo(*p) dereferences the int pointer p and calls foo(int) with the int pointed to by p.
• foo(&i) takes the address of the int i and calls foo(int*) with that address.

(tl;dr) So in conclusion, depending on the context:

• * can be either the dereference operator or part of the pointer declaration syntax.

• & can be either the address-of operator or (in C++) part of the reference declaration syntax.

  Note that * may also be the multiplication operator, and & may also be the bitwise AND operator.