Ubuntu – Does gcc compiled executable LSB imply "Least Significant Byte" and "Least Significant bit" at the same time?

I want to know how is the bit order of an int32_t is stored in memory, so I write some code to print.

#include <stdio.h>
#include <stdint.h>
#include <assert.h>

void print_i8_as_bits(int8_t num) {
  #pragma pack(1)
  struct Byte {
    unsigned bit_0: 1;
    unsigned bit_1: 1;
    unsigned bit_2: 1;
    unsigned bit_3: 1;
    unsigned bit_4: 1;
    unsigned bit_5: 1;
    unsigned bit_6: 1;
    unsigned bit_7: 1;
  };
  #pragma pack()
  assert(sizeof(struct Byte) == 1); // your compiler didn't not support #pragma pack(), try gcc

  struct Byte *byte = (struct Byte*) &num;
  printf(
    "%u%u%u%u%u%u%u%u",
    byte->bit_0,
    byte->bit_1,
    byte->bit_2,
    byte->bit_3,
    byte->bit_4,
    byte->bit_5,
    byte->bit_6,
    byte->bit_7
  );
}

void print_i32_as_bits(int32_t num) {
  int8_t *bytes = (int8_t*) &num;
  for(size_t i = 0; i < 4; ++i) {
    print_i8_as_bits(bytes[i]);
    printf(" ");
  }
}

int main() {
  int32_t num = 3;
  print_i32_as_bits(num);
  printf("n");

  return 0;
}

$ gcc --version
gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0

$ gcc print_bitfields.c && ./a.out
11000000 00000000 00000000 00000000

$ file ./a.out
./a.out: ELF 64-bit LSB pie executable, x86-64,
version 1 (SYSV), dynamically linked,
interpreter /lib64/ld-linux-x86-64.so.2,
BuildID[sha1]=ec61c8110d755b9b9216325536bcd1bcdc36cf1b,
for GNU/Linux 3.2.0, not stripped

Originally, I wrongly expect the output to be: 00000011 00000000 00000000 00000000
But it’s: 11000000 00000000 00000000 00000000

So I have a search and found this:

With GCC, big endian machines lay out the bits big end first and little endian machines lay out the bits little end first.

But it didn’t have external link.

Can I assume gcc compiled LSB executable imply "Least Significant Byte" and "Least Significant bit" at the same time?

Or it is just a specific behavior of gcc on x86_64 computer?