/* { dg-do compile } */

/* { dg-options "-O2 -fdump-rtl-expand-details" } */

typedef long unsigned int size_t;
union tree_node;
typedef union tree_node *tree;
union gimple_statement_d;
typedef union gimple_statement_d *gimple;
typedef const union tree_node *const_tree;
typedef const union gimple_statement_d *const_gimple;
struct gimple_seq_d;
typedef struct gimple_seq_d *gimple_seq;
struct edge_def;
typedef struct edge_def *edge;
struct basic_block_def;
typedef struct basic_block_def *basic_block;
typedef const struct basic_block_def *const_basic_block;
struct tree_exp
{
  tree operands[1];
};
typedef struct ssa_use_operand_d
{
  tree *use;
} ssa_use_operand_t;
struct phi_arg_d
{
  struct ssa_use_operand_d imm_use;
};
union tree_node
{
  struct tree_exp exp;
};
struct function
{
};
extern struct function *cfun;
struct edge_def
{
  unsigned int dest_idx;
};
static __inline__ void
VEC_edge_must_be_pointer_type (void)
{
  (void) ((edge) 1 == (void *) 1);
} typedef struct VEC_edge_base

{
  unsigned num;
  unsigned alloc;
  edge vec[1];
} VEC_edge_base;
typedef struct VEC_edge_none
{
  VEC_edge_base base;
} VEC_edge_none;

static __inline__ edge
VEC_edge_base_index (const VEC_edge_base * vec_, unsigned ix_,
		     const char *file_, unsigned line_, const char *function_)
{
  return vec_->vec[ix_];
}

typedef struct VEC_edge_gc
{
  VEC_edge_base base;
} VEC_edge_gc;
struct basic_block_def
{
  VEC_edge_gc *succs;
};
static __inline__ edge
single_succ_edge (const_basic_block bb)
{
  return (VEC_edge_base_index
	  ((((bb)->succs) ? &((bb)->succs)->base : 0), (0),
	   "/home/gcc/virgin-gcc/gcc/basic-block.h", 563, __FUNCTION__));
}

edge find_edge (basic_block, basic_block);
typedef tree *def_operand_p;
typedef ssa_use_operand_t *use_operand_p;
struct gimple_seq_node_d;
typedef struct gimple_seq_node_d *gimple_seq_node;
struct gimple_seq_node_d
{
  gimple stmt;
};
typedef struct
{
  gimple_seq_node ptr;
  gimple_seq seq;
  basic_block bb;
} gimple_stmt_iterator;
struct gimple_statement_phi
{
  struct phi_arg_d args[1];
};
union gimple_statement_d
{
  struct gimple_statement_phi gimple_phi;
};
extern size_t const gimple_ops_offset_[];
int gimple_statement_structure (gimple);
static __inline__ tree *
gimple_ops (gimple gs)
{
  size_t off;
  off = gimple_ops_offset_[gimple_statement_structure (gs)];
  return (tree *) ((char *) gs + off);
}

static __inline__ tree
gimple_op (const_gimple gs, unsigned i)
{
  return gimple_ops ((((union
			{
			const union gimple_statement_d * _q;
			union gimple_statement_d * _nq;}) (((gs))))._nq))[i];
}

static __inline__ struct phi_arg_d *
gimple_phi_arg (gimple gs, unsigned index)
{
  return &(gs->gimple_phi.args[index]);
}

static __inline__ tree
gimple_switch_label (const_gimple gs, unsigned index)
{
  return gimple_op (gs, index + 1);
}

gimple_stmt_iterator gsi_start_phis (basic_block);
extern basic_block label_to_block_fn (struct function *, tree);

static __inline__ tree
get_use_from_ptr (use_operand_p use)
{
  return *(use->use);
}

static __inline__ use_operand_p
gimple_phi_arg_imm_use_ptr (gimple gs, int i)
{
  return &gimple_phi_arg (gs, i)->imm_use;
}

struct switch_conv_info
{
  basic_block final_bb;
  basic_block switch_bb;
  const char *reason;
  tree *default_values;
};
static struct switch_conv_info info;
void gsi_next (gimple_stmt_iterator *);
int gsi_gsi_start_phis (basic_block);

static void
gather_default_values (tree default_case)
{
  gimple_stmt_iterator gsi;
  basic_block bb =
    (label_to_block_fn ((cfun + 0), default_case->exp.operands[2]));
  edge e;
  int i = 0;
  if (bb == info.final_bb)
    e = find_edge (info.switch_bb, bb);
  else
    e = single_succ_edge (bb);
  for (gsi = gsi_start_phis (info.final_bb);
       gsi_gsi_start_phis (info.final_bb); gsi_next (&gsi))
    {
      gimple phi = gsi.ptr->stmt;
      tree val = get_use_from_ptr (gimple_phi_arg_imm_use_ptr
				   ((((phi))), (((e)->dest_idx))));
      info.default_values[i++] = val;
    }
}

unsigned int gimple_switch_num_labels (gimple);

unsigned char
process_switch (gimple swtch)
{
  unsigned int i, branch_num = gimple_switch_num_labels (swtch);
  tree index_type;
  info.reason = "switch has no labels\n";
  gather_default_values (gimple_switch_label (swtch, 0));
}

/* Verify that out-of-ssa coalescing did its job by verifying there are not
   any partition copies inserted.  */

/* { dg-final { scan-rtl-dump-not "partition copy" "expand"} } */
/* { dg-final { cleanup-rtl-dump "expand" } } */

