gcc/testsuite/gcc.dg/pr18241-1.c

   1 /* { dg-do run } */
   2 /* memset doesn't take unsigned long */
   3 /* { dg-xfail-if "" { "m32c-*-*" } { "*" } { "" } } */
   4 /* { dg-options "-std=gnu99 -Wall -Wextra -O1" } */
   5
   6 extern void *memset (void*, int, unsigned long);
   7 extern void abort (void);
   8
   9 struct radix_tree_root {
  10         unsigned int height;
  11         struct radix_tree_node *rnode;
  12 };
  13
  14 struct radix_tree_node {
  15         unsigned int count;
  16         void *slots[64];
  17         unsigned long tags[2][2];
  18 };
  19
  20 struct radix_tree_path {
  21         struct radix_tree_node *node, **slot;
  22         int offset;
  23 };
  24
  25 static unsigned long height_to_maxindex[7] =
  26 {0, 63, 4095, 262143, 16777215, 1073741823, 4294967295};
  27
  28 static inline void tag_clear(struct radix_tree_node *node, int tag, int offset)
  29 {
  30         int nr;
  31         volatile unsigned long *addr;
  32         int mask;
  33
  34         nr = offset;
  35         addr = &node->tags[tag][0];
  36
  37         addr += nr >> 5;
  38         mask = 1 << (nr & 0x1f);
  39         *addr &= ~mask;
  40 }
  41
  42 void *radix_tree_tag_clear(struct radix_tree_root *root, unsigned long index, int tag)
  43 {
  44         struct radix_tree_path path[7], *pathp = path;
  45         unsigned int height, shift;
  46         void *ret = 0;
  47
  48         height = root->height;
  49         if (index > height_to_maxindex[height])
  50                 goto out;
  51
  52         shift = (height - 1) * 6;
  53         pathp->node = 0;
  54         pathp->slot = &root->rnode;
  55
  56         while (height > 0) {
  57                 int offset;
  58
  59                 if (*pathp->slot == 0)
  60                         goto out;
  61
  62                 offset = (index >> shift) & (64-1);
  63                 pathp[1].offset = offset;
  64                 pathp[1].node = *pathp[0].slot;
  65                 pathp[1].slot = (struct radix_tree_node **)
  66                         (pathp[1].node->slots + offset);
  67                 pathp++;
  68                 shift -= 6;
  69                 height--;
  70         }
  71
  72         ret = *pathp[0].slot;
  73         if (ret == 0)
  74                 goto out;
  75
  76         do {
  77                 int idx;
  78
  79                 tag_clear(pathp[0].node, tag, pathp[0].offset);
  80                 for (idx = 0; idx < 2; idx++) {
  81                         if (pathp[0].node->tags[tag][idx])
  82                                 goto out;
  83                 }
  84                 pathp--;
  85         } while (pathp[0].node);
  86 out:
  87         return ret;
  88 }
  89
  90 int main ()
  91 {
  92         struct radix_tree_root r;
  93         struct radix_tree_node node;
  94         void *p = (void *) 0xdeadbeef;
  95
  96         r.height = 1;
  97         r.rnode = &node;
  98
  99         memset (&node, 0, sizeof (node));
 100
 101         node.count = 1;
 102         node.slots [13] = p;
 103
 104         radix_tree_tag_clear (&r, 13, 1);
 105
 106         if (r.rnode->slots[13] != p)
 107                 abort ();
 108         return 0;
 109 }