modernc.org/ccgo/v3@v3.16.14/lib/testdata/gcc-9.1.0/gcc/testsuite/gcc.c-torture/execute/20001203-2.c (about)

     1  struct obstack
     2  {
     3    long chunk_size;
     4    struct _obstack_chunk *chunk;
     5    char *object_base;
     6    char *next_free;
     7    char *chunk_limit;
     8    int alignment_mask;
     9    unsigned maybe_empty_object;
    10  };
    11  
    12  struct objfile
    13    {
    14      struct objfile *next;
    15      struct obstack type_obstack;
    16    };
    17  
    18  struct type
    19    {
    20      unsigned length;
    21      struct objfile *objfile;
    22      short nfields;
    23      struct field
    24        {
    25          union field_location
    26            {
    27              int bitpos;
    28              unsigned long physaddr;
    29              char *physname;
    30            }
    31          loc;
    32          int bitsize;
    33          struct type *type;
    34          char *name;
    35        }
    36       *fields;
    37    };
    38  
    39  struct type *alloc_type (void);
    40  void * xmalloc (unsigned int z);
    41  void _obstack_newchunk (struct obstack *o, int i);
    42  void get_discrete_bounds (long long *lowp, long long *highp);
    43  
    44  extern void *memset(void *, int, __SIZE_TYPE__);
    45  
    46  struct type *
    47  create_array_type (struct type *result_type, struct type *element_type)
    48  {
    49    long long low_bound, high_bound;
    50    if (result_type == ((void *)0))
    51      {
    52        result_type = alloc_type ();
    53      }
    54    get_discrete_bounds (&low_bound, &high_bound);
    55    (result_type)->length =
    56      (element_type)->length * (high_bound - low_bound + 1);
    57    (result_type)->nfields = 1;
    58    (result_type)->fields =
    59      (struct field *) ((result_type)->objfile != ((void *)0) 
    60  		      ? (
    61  		      {
    62  			struct obstack *__h = 
    63  			  (&(result_type)->objfile -> type_obstack);
    64  			{
    65  			  struct obstack *__o = (__h);
    66  			  int __len = ((sizeof (struct field)));
    67  			  if (__o->chunk_limit - __o->next_free < __len)
    68  			    _obstack_newchunk (__o, __len); 
    69  			  __o->next_free += __len; (void) 0;
    70  			};
    71  			({
    72  			  struct obstack *__o1 = (__h); 
    73  			  void *value; 
    74  			  value = (void *) __o1->object_base;
    75  			  if (__o1->next_free == value)
    76  			    __o1->maybe_empty_object = 1;
    77  			  __o1->next_free = (((((__o1->next_free) - (char *) 0)
    78  					       +__o1->alignment_mask) 
    79  					      & ~ (__o1->alignment_mask)) 
    80  					     + (char *) 0);
    81  			  if (__o1->next_free - (char *)__o1->chunk 
    82  			      > __o1->chunk_limit - (char *)__o1->chunk)
    83  			    __o1->next_free = __o1->chunk_limit;
    84  			  __o1->object_base = __o1->next_free; 
    85  			  value;
    86  			});
    87  		      }) : xmalloc (sizeof (struct field)));
    88    return (result_type);
    89  }
    90  
    91  struct type *
    92  alloc_type (void)
    93  {
    94    abort ();
    95  }
    96  void * xmalloc (unsigned int z)
    97  {
    98    return 0;
    99  }
   100  void _obstack_newchunk (struct obstack *o, int i)
   101  {
   102    abort ();
   103  }
   104  void
   105  get_discrete_bounds (long long *lowp, long long *highp)
   106  {
   107    *lowp = 0;
   108    *highp = 2;
   109  }
   110  
   111  int main(void)
   112  {
   113    struct type element_type;
   114    struct type result_type;
   115    
   116    memset (&element_type, 0, sizeof (struct type));
   117    memset (&result_type, 0, sizeof (struct type));
   118    element_type.length = 4;
   119    create_array_type (&result_type, &element_type);
   120    if (result_type.length != 12)
   121      abort ();
   122    exit (0);
   123  }