Ubuntu – How does the compiler know how to correctly handle bitfields when reading binary data from a file in C?

I’m trying to learn C by writing a postgres clone and struggling to understand how the compiler handles bitfields.

Specifically, my question surrounds the bitfields in postgres’ line pointer struct:

typedef struct ItemIdData {
  unsigned  lp_off:15,   /* offset to tuple (from start of page) */
        lp_flags:2,  /* state of line pointer, see below */
        lp_len:15;   /* byte length of tuple */
} ItemIdData;

In my clone, I’m able to set these fields to correct values and write them to disk, but I don’t understand how the compiler is able know which of the 15 bits are relevant when converting to an integer type. Here’s a full example showing what I’m doing:

#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>

typedef struct ItemIdData {
  unsigned  lp_off:15,   /* offset to tuple (from start of page) */
        lp_flags:2,  /* state of line pointer, see below */
        lp_len:15;   /* byte length of tuple */
} ItemIdData;

int main() {
  ItemIdData* lp = malloc(sizeof(ItemIdData));

  lp->lp_off = 205;
  lp->lp_len = 51;

  int fd = open("line_pointer.data",
                O_RDWR |    // Read/Write mode
                  O_CREAT,  // Create file if it doesn't exist
                S_IWUSR |   // User write permission
                  S_IRUSR   // User read permission
  );

  write(fd, lp, 4);

  close(fd);
  free(lp);

  ItemIdData* lp2 = malloc(sizeof(ItemIdData));

  int fd2 = open("line_pointer.data",
                O_RDWR |    // Read/Write mode
                  O_CREAT,  // Create file if it doesn't exist
                S_IWUSR |   // User write permission
                  S_IRUSR   // User read permission
  );

  read(fd2, lp2, 4);

  printf("lp_off: %dn", lp2->lp_off);
  printf("lp_len: %dn", lp2->lp_len);

  close(fd2);
  free(lp2);

  return EXIT_SUCCESS;
}

Compiling and running the program, I get:

$ gcc -o lp main.c && ./lp
lp_off: 205
lp_len: 51

Using xxd -b, I inspected the binary contents of the data file and see these four bytes:

11001101 00000000 01100110 00000000

lp_off is the first 15 bits: 11001101 0000000, which somehow correctly converts to 205 in decimal

lp_len is the last 15 bits: 1100110 00000000, which somehow correctly converts to 51 in decimal

This is what I’m failing to to understand: how does the compiler know that the trailing 0-bits are not part of the value when converting to an int in the print statements above?

I’m coding this on Ubuntu-20.04 running inside WSL on a Windows 10 machine, if that matters.