gcc/testsuite/gcc.dg/tree-ssa/foldconst-3.c

   1 /* { dg-do compile } */
   2 /* { dg-options "-O2 -fdump-tree-optimized -fno-short-enums" } */
   3 typedef const union tree_node *const_tree;
   4 typedef struct
   5 {
   6 }
   7 double_int;
   8 double_int double_int_zext (double_int, unsigned);
   9 enum tree_code
  10 { ERROR_MARK, IDENTIFIER_NODE, TREE_LIST, BLOCK, ENUMERAL_TYPE, BOOLEAN_TYPE,
  11     INTEGER_TYPE, ARRAY_TYPE, INTEGER_CST, VAR_DECL, PARM_DECL, RESULT_DECL,
  12   };
  13 enum tree_code_class
  14 { tcc_exceptional, tcc_constant, tcc_type, tcc_declaration, tcc_reference, };
  15 struct tree_base
  16 {
  17   __extension__ enum tree_code code:16;
  18   unsigned unsigned_flag:1;
  19 };
  20 struct tree_type
  21 {
  22   unsigned int precision:10;
  23   union tree_type_symtab
  24   {
  25   } symtab;
  26 };
  27 union tree_node
  28 {
  29   struct tree_base base;
  30   struct tree_type type;
  31 };
  32 const enum tree_code_class tree_code_type[] =
  33 { tcc_exceptional, 1, 0, 0, 0, 0, 2, };
  34
  35 int_fits_type_p (const_tree c, const_tree type)
  36 {
  37   double_int dc, dd;
  38   {
  39     if (((enum tree_code) (type)->base.code) == INTEGER_TYPE && ((
  40                                                                    {
  41                                                                    __typeof
  42                                                                    (type) __t
  43                                                                    = (type);
  44                                                                    if
  45                                                                    (tree_code_type
  46                                                                     [(int)
  47                                                                      (((enum
  48                                                                         tree_code)
  49                                                                        (__t)->
  50                                                                        base.
  51                                                                        code))]
  52                                                                     !=
  53                                                                     (tcc_type))
  54                                                                    tree_class_check_failed
  55                                                                    (__t,
  56                                                                     __FUNCTION__);
  57                                                                    __t;})->
  58                                                                  base.
  59                                                                  unsigned_flag))
  60       dd = double_int_zext (dd, ((
  61                                    {
  62                                    __typeof (type) __t = (type);
  63                                    if (tree_code_type
  64                                        [(int)
  65                                         (((enum tree_code) (__t)->base.
  66                                           code))] !=
  67                                        (tcc_type))
  68                                    tree_class_check_failed (__t,
  69                                                             __FUNCTION__);
  70                                    __t;}
  71                                  )->type.precision));
  72 }
  73 }
  74 /* The switch should be switch converted and later constant propagated.  */
  75 /* { dg-final { scan-tree-dump-not "tree_code_type" "optimized"} } */
  76 /* { dg-final { cleanup-tree-dump "optimized" } } */