Re: RFA: Patch to constrain maximal number of tries for incomplete dfa descriptions.

[Eric Botcazou <ebotcazou at libertysurf dot fr>]

> Ok, I'll make it when I get an approval for the patch for the main line.

Many thanks!

> > Could you add "PR bootstrap/10835" to the entry?
>
> Sure.

I've attached the testcase.

-- 
Eric Botcazou


2003-06-10  Eric Botcazou  <ebotcazou@libertysurf.fr>

        * gcc.dg/hypersp1.c: New test.

/* PR bootstrap/10835 */
/* { dg-do compile { target sparc*-*-* } } */
/* { dg-options "-O2 -mcpu=hypersparc" } */

/* This used to virtually hang in the scheduler because
   of a combinatory explosion due to an incomplete DFA
   scheduler description for HyperSPARC. */

struct rtx_def;
typedef struct rtx_def *rtx;
struct rtvec_def;
typedef struct rtvec_def *rtvec;
union tree_node;
typedef union tree_node *tree;

enum machine_mode
{
  VOIDmode
};

struct location_s
{
  const char *file;
  int line;
};

typedef struct location_s location_t;

enum tree_code
{
  ERROR_MARK
};

enum built_in_class
{
  NOT_BUILT_IN = 0
};

enum built_in_function
{
  BUILT_IN_ALLOCA
};

struct tree_common
{
  tree chain;
  tree type;

  enum tree_code code : 8;

  unsigned side_effects_flag : 1;
  unsigned constant_flag : 1;
  unsigned addressable_flag : 1;
  unsigned volatile_flag : 1;
  unsigned readonly_flag : 1;
  unsigned unsigned_flag : 1;
  unsigned asm_written_flag: 1;
  unsigned unused_0 : 1;

  unsigned used_flag : 1;
  unsigned nothrow_flag : 1;
  unsigned static_flag : 1;
  unsigned public_flag : 1;
  unsigned private_flag : 1;
  unsigned protected_flag : 1;
  unsigned bounded_flag : 1;
  unsigned deprecated_flag : 1;

  unsigned lang_flag_0 : 1;
  unsigned lang_flag_1 : 1;
  unsigned lang_flag_2 : 1;
  unsigned lang_flag_3 : 1;
  unsigned lang_flag_4 : 1;
  unsigned lang_flag_5 : 1;
  unsigned lang_flag_6 : 1;
  unsigned unused_1 : 1;
};

struct tree_int_cst
{
  struct tree_common common;
  rtx rtl;

  struct tree_int_cst_lowhi {
    unsigned int low;
    int high;
  } int_cst;
};

struct tree_real_cst
{
  struct tree_common common;
  rtx rtl;
  struct real_value * real_cst_ptr;
};

struct tree_string
{
  struct tree_common common;
  rtx rtl;
  int length;
  const char *pointer;
};

struct tree_complex
{
  struct tree_common common;
  rtx rtl;
  tree real;
  tree imag;
};

struct tree_vector
{
  struct tree_common common;
  rtx rtl;
  tree elements;
};

typedef struct ht_identifier ht_identifier;

struct ht_identifier
{
  const unsigned char *str;
  unsigned int len;
  unsigned int hash_value;
};

struct cpp_reader;
typedef struct ht hash_table;
typedef struct ht_identifier *hashnode;

struct ht
{
  hashnode *entries;
  hashnode (*alloc_node) (hash_table *);
  unsigned int nslots;
  unsigned int nelements;
  struct cpp_reader *pfile;
  unsigned int searches;
  unsigned int collisions;
};

struct tree_identifier
{
  struct tree_common common;
  struct ht_identifier id;
};

struct tree_list
{
  struct tree_common common;
  tree purpose;
  tree value;
};

struct tree_vec
{
  struct tree_common common;
  int length;
  tree a[1];
};

struct tree_exp
{
  struct tree_common common;
  int complexity;
  tree operands[1];
};

struct tree_block
{
  struct tree_common common;

  unsigned handler_block_flag : 1;
  unsigned abstract_flag : 1;
  unsigned block_num : 30;

  tree vars;
  tree subblocks;
  tree supercontext;
  tree abstract_origin;
  tree fragment_origin;
  tree fragment_chain;
};

struct die_struct;

struct tree_type
{
  struct tree_common common;
  tree values;
  tree size;
  tree size_unit;
  tree attributes;
  unsigned int uid;

  unsigned int precision : 9;
  enum machine_mode mode : 7;

  unsigned string_flag : 1;
  unsigned no_force_blk_flag : 1;
  unsigned needs_constructing_flag : 1;
  unsigned transparent_union_flag : 1;
  unsigned packed_flag : 1;
  unsigned restrict_flag : 1;
  unsigned pointer_depth : 2;

  unsigned lang_flag_0 : 1;
  unsigned lang_flag_1 : 1;
  unsigned lang_flag_2 : 1;
  unsigned lang_flag_3 : 1;
  unsigned lang_flag_4 : 1;
  unsigned lang_flag_5 : 1;
  unsigned lang_flag_6 : 1;
  unsigned user_align : 1;

  unsigned int align;
  tree pointer_to;
  tree reference_to;
  union tree_type_symtab {
    int address;
    char * pointer;
    struct die_struct * die;
  } symtab;

  tree name;
  tree minval;
  tree maxval;
  tree next_variant;
  tree main_variant;
  tree binfo;
  tree context;
  int alias_set;

  struct lang_type *lang_specific;
};

struct function;

struct tree_decl
{
  struct tree_common common;
  location_t locus;
  unsigned int uid;
  tree size;
  enum machine_mode mode : 8;

  unsigned external_flag : 1;
  unsigned nonlocal_flag : 1;
  unsigned regdecl_flag : 1;
  unsigned inline_flag : 1;
  unsigned bit_field_flag : 1;
  unsigned virtual_flag : 1;
  unsigned ignored_flag : 1;
  unsigned abstract_flag : 1;

  unsigned in_system_header_flag : 1;
  unsigned common_flag : 1;
  unsigned defer_output : 1;
  unsigned transparent_union : 1;
  unsigned static_ctor_flag : 1;
  unsigned static_dtor_flag : 1;
  unsigned artificial_flag : 1;
  unsigned weak_flag : 1;

  unsigned non_addr_const_p : 1;
  unsigned no_instrument_function_entry_exit : 1;
  unsigned comdat_flag : 1;
  unsigned malloc_flag : 1;
  unsigned no_limit_stack : 1;
  enum built_in_class built_in_class : 2;
  unsigned pure_flag : 1;

  unsigned pointer_depth : 2;
  unsigned non_addressable : 1;
  unsigned user_align : 1;
  unsigned uninlinable : 1;
  unsigned thread_local_flag : 1;
  unsigned inlined_function_flag : 1;

  unsigned lang_flag_0 : 1;
  unsigned lang_flag_1 : 1;
  unsigned lang_flag_2 : 1;
  unsigned lang_flag_3 : 1;
  unsigned lang_flag_4 : 1;
  unsigned lang_flag_5 : 1;
  unsigned lang_flag_6 : 1;
  unsigned lang_flag_7 : 1;

  union tree_decl_u1 {
    enum built_in_function f;
    int i;

    struct tree_decl_u1_a {
      unsigned int align : 24;
      unsigned int off_align : 8;
    } a;
  } u1;

  tree size_unit;
  tree name;
  tree context;
  tree arguments;
  tree result;
  tree initial;
  tree abstract_origin;
  tree assembler_name;
  tree section_name;
  tree attributes;
  rtx rtl;
  rtx live_range_rtl;

  union tree_decl_u2 {
    struct function * f;
    rtx r;
    tree t;
    int i;
  } u2;

  tree saved_tree;
  tree inlined_fns;
  tree vindex;
  int pointer_alias_set;

  struct lang_decl *lang_specific;
};

enum tree_node_structure_enum {
  TS_COMMON
};

union tree_node
{
  struct tree_common common;
  struct tree_int_cst int_cst;
  struct tree_real_cst real_cst;
  struct tree_vector vector;
  struct tree_string string;
  struct tree_complex complex;
  struct tree_identifier identifier;
  struct tree_decl decl;
  struct tree_type type;
  struct tree_list list;
  struct tree_vec vec;
  struct tree_exp exp;
  struct tree_block block;
};

enum tree_index
{
  TI_ERROR_MARK
};

enum size_type_kind
{
  SIZETYPE
};

enum c_tree_index
{
  CTI_WCHAR_TYPE
};

struct c_common_identifier
{
  struct tree_common common;
};

struct spelling
{
  int kind;
  union
    {
      int i;
      const char *s;
    } u;
};

static struct spelling *spelling;
static struct spelling *spelling_base;
static tree constructor_type;
static tree constructor_fields;
static tree constructor_index;
static tree constructor_max_index;
static tree constructor_unfilled_fields;
static tree constructor_unfilled_index;
static tree constructor_bit_index;
static tree constructor_elements;
static int constructor_incremental;
static int constructor_constant;
static int constructor_simple;
static int constructor_erroneous;

struct init_node
{
  struct init_node *left, *right;
  struct init_node *parent;
  int balance;
  tree purpose;
  tree value;
};

static struct init_node *constructor_pending_elts;
static int constructor_depth;
static tree constructor_decl;
static int constructor_designated;
static int designator_depth;
static int designator_errorneous;

struct constructor_range_stack;

struct constructor_stack
{
  struct constructor_stack *next;
  tree type;
  tree fields;
  tree index;
  tree max_index;
  tree unfilled_index;
  tree unfilled_fields;
  tree bit_index;
  tree elements;
  struct init_node *pending_elts;
  int offset;
  int depth;
  tree replacement_value;
  struct constructor_range_stack *range_stack;
  char constant;
  char simple;
  char implicit;
  char erroneous;
  char outer;
  char incremental;
  char designated;
};

struct constructor_stack *constructor_stack;

struct constructor_range_stack
{
  struct constructor_range_stack *next, *prev;
  struct constructor_stack *stack;
  tree range_start;
  tree index;
  tree range_end;
  tree fields;
};

struct constructor_range_stack *constructor_range_stack;

struct initializer_stack
{
  struct initializer_stack *next;
  tree decl;
  const char *asmspec;
  struct constructor_stack *constructor_stack;
  struct constructor_range_stack *constructor_range_stack;
  tree elements;
  struct spelling *spelling;
  struct spelling *spelling_base;
  int spelling_size;
  char top_level;
  char require_constant_value;
  char require_constant_elements;
  char deferred;
};

struct initializer_stack *initializer_stack;

void really_start_incremental_init (tree type)
{
  struct constructor_stack *p;

  if (type == 0)
    type = ((constructor_decl)->common.type);

  p->type = constructor_type;
  p->fields = constructor_fields;
  p->index = constructor_index;
  p->max_index = constructor_max_index;
  p->unfilled_index = constructor_unfilled_index;
  p->unfilled_fields = constructor_unfilled_fields;
  p->bit_index = constructor_bit_index;
  p->elements = constructor_elements;
  p->constant = constructor_constant;
  p->simple = constructor_simple;
  p->erroneous = constructor_erroneous;
  p->pending_elts = constructor_pending_elts;
  p->depth = constructor_depth;
  p->replacement_value = 0;
  p->implicit = 0;
  p->range_stack = 0;
  p->outer = 0;
  p->incremental = constructor_incremental;
  p->designated = constructor_designated;
  p->next = 0;
  constructor_stack = p;

  constructor_constant = 1;
  constructor_simple = 1;
  constructor_depth = (spelling - spelling_base);
  constructor_elements = 0;
  constructor_pending_elts = 0;
  constructor_type = type;
  constructor_incremental = 1;
  constructor_designated = 0;
  designator_depth = 0;
  designator_errorneous = 0;
}