/* This is a small test to see if bitfields are working.  It is only a
   few structs and a union and a test to see if they have the correct
   size, if values can be read and written and a couple of argument
   passing tests.  No alignment testing is done.  */

#include "defines.h"
#include "macros.h"


/* These five bitfields are taken from the System V ABI, Intel 386
   architecture supplement.  */

/* Word aligned, sizeof is 4.  */
struct RightToLeft
{
  int j:5;
  int k:6;
  int m:7;
};

/* Word aligned, sizeof is 12.  */
struct BoundaryAlignment
{
  short s:9;
  int   j:9;
  char  c;
  short t:9;
  short u:9;
  char  d;
};

/* Halfword aligned, sizeof is 2.  */
struct StorageUnitSharing
{
  char  c;
  short s:8;
};

/* Halfword aligned, sizeof is 2.  */
union Allocation
{
  char  c;
  short s:8;
};

/* Byte aligned, sizeof is 9.  */
struct Unnamed
{
  char  c;
  int    :0;
  char  d;
  short  :9;
  char  e;
  char   :0;
};

/* Extra struct testing bitfields in larger types.
   Doubleword aligned, sizeof is 8.  */
struct LargerTypes
{
  long long l:33;
  int       i:31;
};


void
passing1 (struct RightToLeft str, int j, int k, int m)
{
  assert (str.j == j);
  assert (str.k == k);
  assert (str.m == m);
}

void
passing2 (struct BoundaryAlignment str, short s, int j, char c, short t,
	  short u, char d)
{
  assert (str.s == s);
  assert (str.j == j);
  assert (str.c == c);
  assert (str.t == t);
  assert (str.u == u);
  assert (str.d == d);
}

void
passing3 (struct StorageUnitSharing str, char c, short s)
{
  assert (str.c == c);
  assert (str.s == s);
}

void
passing4 (struct Unnamed str, char c, char d, char e)
{
  assert (str.c == c);
  assert (str.d == d);
  assert (str.e == e);
}

void
passing5 (struct LargerTypes str, long long l, int i)
{
  assert (str.l == l);
  assert (str.i == i);
}


void
passingU (union Allocation u, char c)
{
  assert (u.c == c);
  assert (u.s == c);
}


int
main (void)
{
  struct RightToLeft str1;
  struct BoundaryAlignment str2;
  struct StorageUnitSharing str3;
  struct Unnamed str4;
  struct LargerTypes str5;
  union Allocation u;

  /* Check sizeof's.  */
  check_size(str1, 4);
  check_size(str2, 12);
  check_size(str3, 2);
  check_size(str4, 9);
  check_size(str5, 8);
  check_size(u, 2);

  /* Check alignof's.  */
  check_align_lv(str1, 4);
  check_align_lv(str2, 4);
  check_align_lv(str3, 2);
  check_align_lv(str4, 1);
  check_align_lv(str5, 8);
  check_align_lv(u, 2);

  /* Check passing.  */
  str1.j = str2.s = str3.c = str4.c = str5.l = 4;
  str1.k = str2.j = str3.s = str4.d = str5.i = 5;
  str1.m = str2.c = str4.e = 6;
  str2.t = 7;
  str2.u = 8;
  str2.d = 9;
  passing1 (str1, 4, 5, 6);
  passing2 (str2, 4, 5, 6, 7, 8, 9);
  passing3 (str3, 4, 5);
  passing4 (str4, 4, 5, 6);
  passing5 (str5, 4, 5);

  u.c = 5;
  passingU (u, 5);
  u.s = 6;
  passingU (u, 6);

  return 0;
}