Subversion Repositories scarts

/* Test program to test bit field operations on bit fields of large
   integer types.  */
 
/* This file is expected to fail to compile if the type long long int
   is not supported, but in that case it is irrelevant.  */
 
#include <stdlib.h>
#include <string.h>
 
#if !defined(__STDC__) && !defined(__cplusplus)
#define signed  /**/
#endif
 
struct fields
{
  unsigned long long u1 : 15;
  unsigned long long u2 : 33;
  unsigned long long u3 : 16;
  signed long long   s1 : 15;
  signed long long   s2 : 33;
  signed long long   s3 : 16;
} flags;
 
void break1 ()
{
}
 
void break2 ()
{
}
 
void break3 ()
{
}
 
void break4 ()
{
}
 
void break5 ()
{
}
 
void break6 ()
{
}
 
void break7 ()
{
}
 
void break8 ()
{
}
 
void break9 ()
{
}
 
void break10 ()
{
}
 
/* This is used by bitfields.exp to determine if the target understands
   signed bitfields.  */
int i;
 
void tester ()
{
  memset ((char *) &flags, 0, sizeof (flags));
 
  /* For each member, set that member to 1, allow gdb to verify that the
     member (and only that member) is 1, and then reset it back to 0. */
  flags.s1 = 1;
  break1 ();
  flags.s1 = 0;
 
  flags.u1 = 1;
  break1 ();
  flags.u1 = 0;
 
  flags.s2  = 1;
  break1 ();
  flags.s2 = 0;
 
  flags.u2 = 1;
  break1 ();
  flags.u2 = 0;
 
  flags.s3  = 1;
  break1 ();
  flags.s3 = 0;
 
  flags.u3 = 1;
  break1 ();
  flags.u3 = 0;
 
  /* Fill alternating fields with all 1's and verify that none of the bits
     "bleed over" to the other fields. */
 
  flags.u1 = 0x7FFF;
  flags.u3 = 0xFFFF;
  flags.s2 = -1LL;
  break2 ();
  flags.u1 = 0;
  flags.u3 = 0;
  flags.s2 = 0;
 
  flags.u2 = 0x1FFFFFFFFLL;
  flags.s1 = -1;
  flags.s3 = -1;
  break2 ();
 
  flags.u2 = 0;
  flags.s1 = 0;
  flags.s3 = 0;
 
  /* Fill the unsigned fields with the maximum positive value and verify
     that the values are printed correctly. */
 
  flags.u1 = 0x7FFF;
  flags.u2 = 0x1FFFFFFFFLL;
  flags.u3 = 0xFFFF;
  break3 ();
  flags.u1 = 0;
  flags.u2 = 0;
  flags.u3 = 0;
 
  /* Fill the signed fields with the maximum positive value, then the maximally
     negative value, then -1, and verify in each case that the values are
     printed correctly. */
 
  /* Maximum positive values */
  flags.s1 = 0x3FFF;
  flags.s2 = 0xFFFFFFFFLL;
  flags.s3 = 0x7FFF;
  break4 ();
 
  /* Maximally negative values */
  flags.s1 = -0x4000;
  flags.s2 = -0x100000000LL;
  flags.s3 = -0x8000;
 
  /* Extract bitfield value so that bitfield.exp can check if the target
     understands signed bitfields.  */
  i = flags.s3;
  break4 ();
 
  /* -1 */
  flags.s1 = -1;
  flags.s2 = -1;
  flags.s3 = -1;
  break4 ();
 
  flags.s1 = 0;
  flags.s2 = 0;
  flags.s3 = 0;
 
  break5 ();
}
 
int main () 
{
  int i;
#ifdef usestubs
  set_debug_traps();
  breakpoint();
#endif
  for (i = 0; i < 5; i += 1)
    tester ();
  return 0;
}