init_alias_analysis ();
cse_main (f, nregs, after_loop, file)     rtx f;     int nregs;     int after_loop;     FILE *file;{  struct cse_basic_block_data val;  register rtx insn = f;  register int i;  cse_jumps_altered = 0;  recorded_label_ref = 0;  constant_pool_entries_cost = 0;  val.path_size = 0;  init_recog ();  max_reg = nregs;  all_minus_one = (int *) alloca (nregs * sizeof (int));  consec_ints = (int *) alloca (nregs * sizeof (int));  for (i = 0; i < nregs; i++)    {      all_minus_one[i] = -1;      consec_ints[i] = i;    }  reg_next_eqv = (int *) alloca (nregs * sizeof (int));  reg_prev_eqv = (int *) alloca (nregs * sizeof (int));  reg_qty = (int *) alloca (nregs * sizeof (int));  reg_in_table = (int *) alloca (nregs * sizeof (int));  reg_tick = (int *) alloca (nregs * sizeof (int));#ifdef LOAD_EXTEND_OP  /* Allocate scratch rtl here.  cse_insn will fill in the memory reference     and change the code and mode as appropriate.  */  memory_extend_rtx = gen_rtx (ZERO_EXTEND, VOIDmode, 0);#endif  /* Discard all the free elements of the previous function     since they are allocated in the temporarily obstack.  */  bzero ((char *) table, sizeof table);  free_element_chain = 0;  n_elements_made = 0;  /* Find the largest uid.  */  max_uid = get_max_uid ();  uid_cuid = (int *) alloca ((max_uid + 1) * sizeof (int));  bzero ((char *) uid_cuid, (max_uid + 1) * sizeof (int));  /* Compute the mapping from uids to cuids.     CUIDs are numbers assigned to insns, like uids,     except that cuids increase monotonically through the code.     Don't assign cuids to line-number NOTEs, so that the distance in cuids     between two insns is not affected by -g.  */  for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))    {      if (GET_CODE (insn) != NOTE	  || NOTE_LINE_NUMBER (insn) < 0)	INSN_CUID (insn) = ++i;      else	/* Give a line number note the same cuid as preceding insn.  */	INSN_CUID (insn) = i;    }  /* Initialize which registers are clobbered by calls.  */  CLEAR_HARD_REG_SET (regs_invalidated_by_call);  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)    if ((call_used_regs[i]	 /* Used to check !fixed_regs[i] here, but that isn't safe;	    fixed regs are still call-clobbered, and sched can get	    confused if they can "live across calls".	    The frame pointer is always preserved across calls.  The arg	    pointer is if it is fixed.  The stack pointer usually is, unless	    RETURN_POPS_ARGS, in which case an explicit CLOBBER	    will be present.  If we are generating PIC code, the PIC offset	    table register is preserved across calls.  */	 && i != STACK_POINTER_REGNUM	 && i != FRAME_POINTER_REGNUM#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM	 && i != HARD_FRAME_POINTER_REGNUM#endif#if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM	 && ! (i == ARG_POINTER_REGNUM && fixed_regs[i])#endif#if defined (PIC_OFFSET_TABLE_REGNUM) && !defined (PIC_OFFSET_TABLE_REG_CALL_CLOBBERED)	 && ! (i == PIC_OFFSET_TABLE_REGNUM && flag_pic)#endif	 )	|| global_regs[i])      SET_HARD_REG_BIT (regs_invalidated_by_call, i);  /* Loop over basic blocks.     Compute the maximum number of qty's needed for each basic block     (which is 2 for each SET).  */  insn = f;  while (insn)    {      cse_end_of_basic_block (insn, &val, flag_cse_follow_jumps, after_loop,			      flag_cse_skip_blocks);      /* If this basic block was already processed or has no sets, skip it.  */      if (val.nsets == 0 || GET_MODE (insn) == QImode)	{	  PUT_MODE (insn, VOIDmode);	  insn = (val.last ? NEXT_INSN (val.last) : 0);	  val.path_size = 0;	  continue;	}      cse_basic_block_start = val.low_cuid;      cse_basic_block_end = val.high_cuid;      max_qty = val.nsets * 2;            if (file)	fprintf (file, ";; Processing block from %d to %d, %d sets.\n",		 INSN_UID (insn), val.last ? INSN_UID (val.last) : 0,		 val.nsets);      /* Make MAX_QTY bigger to give us room to optimize	 past the end of this basic block, if that should prove useful.  */      if (max_qty < 500)	max_qty = 500;      max_qty += max_reg;      /* If this basic block is being extended by following certain jumps,         (see `cse_end_of_basic_block'), we reprocess the code from the start.         Otherwise, we start after this basic block.  */      if (val.path_size > 0)        cse_basic_block (insn, val.last, val.path, 0);      else	{	  int old_cse_jumps_altered = cse_jumps_altered;	  rtx temp;	  /* When cse changes a conditional jump to an unconditional	     jump, we want to reprocess the block, since it will give	     us a new branch path to investigate.  */	  cse_jumps_altered = 0;	  temp = cse_basic_block (insn, val.last, val.path, ! after_loop);	  if (cse_jumps_altered == 0	      || (flag_cse_follow_jumps == 0 && flag_cse_skip_blocks == 0))	    insn = temp;	  cse_jumps_altered |= old_cse_jumps_altered;	}#ifdef USE_C_ALLOCA      alloca (0);#endif    }  /* Tell refers_to_mem_p that qty_const info is not available.  */  qty_const = 0;  if (max_elements_made < n_elements_made)    max_elements_made = n_elements_made;  return cse_jumps_altered || recorded_label_ref;}