This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: assertify alpha


Richard Henderson wrote:

CONST0_RTX of TFmode is not CONST_INT. It's CONST_DOUBLE.
doh!

I think this kind of transformation is much less readable.
I deeply dislike nested switch statements.
ok, I redid that bit.

I've installed the attached, thanks for the review

nathan

--
Nathan Sidwell    ::   http://www.codesourcery.com   ::     CodeSourcery LLC
nathan@codesourcery.com    ::     http://www.planetfall.pwp.blueyonder.co.uk

2005-05-08  Nathan Sidwell  <nathan@codesourcery.com>
	    Falk Hueffner  <falk@debian.org>

	* config/alpha/alpha.c (tls_symbolic_operand_1): Use gcc_assert
	and gcc_unreachable as appropriate.
	(get_aligned_mem, get_unaligned_address,
	alpha_emit_set_long_const, alpha_emit_conditional_branch,
	alpha_emit_setcc, alpha_emit_conditional_move,
	alpha_lookup_xfloating_lib_func, alpha_compute_xfloating_mode_arg,
	alpha_emit_xfloating_libcall, alpha_split_tfmode_pair,
	alpha_expand_unaligned_load, alpha_expand_block_move,
	alpha_expand_zap_mask, get_trap_mode_suffix,
	get_round_mode_suffix, get_some_local_dynamic_name,
	print_operand_address, function_arg, alpha_return_in_memory,
	function_value, alpha_expand_builtin,
	alpha_initial_elimination_offset, alpha_expand_epilogue,
	summarize_insn, alpha_handle_trap_shadows, alphaev5_insn_pipe,
	alphaev5_next_group, alpha_align_insns,
	unicosmk_initial_elimination_offset, unicosmk_unique_section,
	unicosmk_ssib_name): Likewise.
	* config/alpha/alpha.h (ASM_OUTPUT_ADDR_VEC_ELT): Likewise.
	* config/alpha/unicosmk.h (TRAMPOLINE_TEMPLATE,
	ASM_OUTPUT_ADDR_DIFF_ELT, ASM_OUTPUT_ADDR_DIFF_VEC): Likewise.
	* config/alpha/vms.h (INITIAL_ELIMINATION_OFFSET,
	ASM_OUTPUT_ADDR_DIFF_ELT): Likewise.
	* config/alpha/alpha.md (*divmodsi_internal_er,
	*divmoddi_internal_er, ashldi3, *insxl, sibcall, call_osf,
	call_nt, call_umk, call_vms, call_value, sibcall_value,
	call_value_osf, call_value_nt, call_value_vms, call_value_umk,
	*call_vms_1, *movmemdi_1, *clrmemdi_1, *call_value_vms_1): Likewise.
	* config/alpha/predicates.md (input_operand): Likewise.

Index: config/alpha/alpha.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/alpha/alpha.c,v
retrieving revision 1.420
diff -c -3 -p -r1.420 alpha.c
*** config/alpha/alpha.c	23 Apr 2005 21:28:11 -0000	1.420
--- config/alpha/alpha.c	8 May 2005 09:44:35 -0000
*************** tls_symbolic_operand_1 (rtx op, int size
*** 596,602 ****
      case TLS_MODEL_LOCAL_EXEC:
        return unspec == UNSPEC_TPREL;
      default:
!       abort ();
      }
  }
  
--- 596,602 ----
      case TLS_MODEL_LOCAL_EXEC:
        return unspec == UNSPEC_TPREL;
      default:
!       gcc_unreachable ();
      }
  }
  
*************** get_aligned_mem (rtx ref, rtx *paligned_
*** 1531,1551 ****
    rtx base;
    HOST_WIDE_INT offset = 0;
  
!   if (GET_CODE (ref) != MEM)
!     abort ();
  
    if (reload_in_progress
        && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
      {
        base = find_replacement (&XEXP (ref, 0));
  
!       if (! memory_address_p (GET_MODE (ref), base))
! 	abort ();
      }
    else
!     {
!       base = XEXP (ref, 0);
!     }
  
    if (GET_CODE (base) == PLUS)
      offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
--- 1531,1547 ----
    rtx base;
    HOST_WIDE_INT offset = 0;
  
!   gcc_assert (GET_CODE (ref) == MEM);
  
    if (reload_in_progress
        && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
      {
        base = find_replacement (&XEXP (ref, 0));
  
!       gcc_assert (memory_address_p (GET_MODE (ref), base));
      }
    else
!     base = XEXP (ref, 0);
  
    if (GET_CODE (base) == PLUS)
      offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
*************** get_unaligned_address (rtx ref, int extr
*** 1569,1589 ****
    rtx base;
    HOST_WIDE_INT offset = 0;
  
!   if (GET_CODE (ref) != MEM)
!     abort ();
  
    if (reload_in_progress
        && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
      {
        base = find_replacement (&XEXP (ref, 0));
  
!       if (! memory_address_p (GET_MODE (ref), base))
! 	abort ();
      }
    else
!     {
!       base = XEXP (ref, 0);
!     }
  
    if (GET_CODE (base) == PLUS)
      offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
--- 1565,1581 ----
    rtx base;
    HOST_WIDE_INT offset = 0;
  
!   gcc_assert (GET_CODE (ref) == MEM);
  
    if (reload_in_progress
        && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
      {
        base = find_replacement (&XEXP (ref, 0));
  
!       gcc_assert (memory_address_p (GET_MODE (ref), base));
      }
    else
!     base = XEXP (ref, 0);
  
    if (GET_CODE (base) == PLUS)
      offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
*************** alpha_emit_set_long_const (rtx target, H
*** 2053,2060 ****
  
    /* Decompose the entire word */
  #if HOST_BITS_PER_WIDE_INT >= 64
!   if (c2 != -(c1 < 0))
!     abort ();
    d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
    c1 -= d1;
    d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
--- 2045,2051 ----
  
    /* Decompose the entire word */
  #if HOST_BITS_PER_WIDE_INT >= 64
!   gcc_assert (c2 == -(c1 < 0));
    d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
    c1 -= d1;
    d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
*************** alpha_emit_set_long_const (rtx target, H
*** 2062,2081 ****
    d3 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
    c1 -= d3;
    d4 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
!   if (c1 != d4)
!     abort ();
  #else
    d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
    c1 -= d1;
    d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
!   if (c1 != d2)
!     abort ();
    c2 += (d2 < 0);
    d3 = ((c2 & 0xffff) ^ 0x8000) - 0x8000;
    c2 -= d3;
    d4 = ((c2 & 0xffffffff) ^ 0x80000000) - 0x80000000;
!   if (c2 != d4)
!     abort ();
  #endif
  
    /* Construct the high word */
--- 2053,2069 ----
    d3 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
    c1 -= d3;
    d4 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
!   gcc_assert (c1 == d4);
  #else
    d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
    c1 -= d1;
    d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
!   gcc_assert (c1 == d2);
    c2 += (d2 < 0);
    d3 = ((c2 & 0xffff) ^ 0x8000) - 0x8000;
    c2 -= d3;
    d4 = ((c2 & 0xffffffff) ^ 0x80000000) - 0x80000000;
!   gcc_assert (c2 == d4);
  #endif
  
    /* Construct the high word */
*************** alpha_emit_conditional_branch (enum rtx_
*** 2513,2520 ****
  
    if (alpha_compare.fp_p && GET_MODE (op0) == TFmode)
      {
!       if (! TARGET_HAS_XFLOATING_LIBS)
! 	abort ();
  
        /* X_floating library comparison functions return
  	   -1  unordered
--- 2501,2507 ----
  
    if (alpha_compare.fp_p && GET_MODE (op0) == TFmode)
      {
!       gcc_assert (TARGET_HAS_XFLOATING_LIBS);
  
        /* X_floating library comparison functions return
  	   -1  unordered
*************** alpha_emit_conditional_branch (enum rtx_
*** 2579,2585 ****
        break;
  
      default:
!       abort ();
      }
  
    if (alpha_compare.fp_p)
--- 2566,2572 ----
        break;
  
      default:
!       gcc_unreachable ();
      }
  
    if (alpha_compare.fp_p)
*************** alpha_emit_setcc (enum rtx_code code)
*** 2678,2685 ****
  
    if (fp_p && GET_MODE (op0) == TFmode)
      {
!       if (! TARGET_HAS_XFLOATING_LIBS)
! 	abort ();
  
        /* X_floating library comparison functions return
  	   -1  unordered
--- 2665,2671 ----
  
    if (fp_p && GET_MODE (op0) == TFmode)
      {
!       gcc_assert (TARGET_HAS_XFLOATING_LIBS);
  
        /* X_floating library comparison functions return
  	   -1  unordered
*************** alpha_emit_setcc (enum rtx_code code)
*** 2742,2748 ****
        break;
  
      default:
!       abort ();
      }
  
    if (!fp_p)
--- 2728,2734 ----
        break;
  
      default:
!       gcc_unreachable ();
      }
  
    if (!fp_p)
*************** alpha_emit_conditional_move (rtx cmp, en
*** 2834,2840 ****
  	  break;
  
  	default:
! 	  abort ();
  	}
  
        tem = gen_reg_rtx (cmp_op_mode);
--- 2820,2826 ----
  	  break;
  
  	default:
! 	  gcc_unreachable ();
  	}
  
        tem = gen_reg_rtx (cmp_op_mode);
*************** alpha_emit_conditional_move (rtx cmp, en
*** 2886,2892 ****
        break;
  
      default:
!       abort ();
      }
  
    if (!fp_p)
--- 2872,2878 ----
        break;
  
      default:
!       gcc_unreachable ();
      }
  
    if (!fp_p)
*************** alpha_lookup_xfloating_lib_func (enum rt
*** 3059,3065 ****
          return func;
        }
  
!   abort();
  }
  
  /* Most X_floating operations take the rounding mode as an argument.
--- 3045,3051 ----
          return func;
        }
  
!   gcc_unreachable ();
  }
  
  /* Most X_floating operations take the rounding mode as an argument.
*************** alpha_compute_xfloating_mode_arg (enum r
*** 3086,3092 ****
        mode = 4;
        break;
      default:
!       abort ();
  
      /* XXX For reference, round to +inf is mode = 3.  */
      }
--- 3072,3078 ----
        mode = 4;
        break;
      default:
!       gcc_unreachable ();
  
      /* XXX For reference, round to +inf is mode = 3.  */
      }
*************** alpha_emit_xfloating_libcall (rtx func, 
*** 3134,3141 ****
  	  break;
  
  	case VOIDmode:
! 	  if (GET_CODE (operands[i]) != CONST_INT)
! 	    abort ();
  	  /* FALLTHRU */
  	case DImode:
  	  reg = gen_rtx_REG (DImode, regno);
--- 3120,3126 ----
  	  break;
  
  	case VOIDmode:
! 	  gcc_assert (GET_CODE (operands[i]) == CONST_INT);
  	  /* FALLTHRU */
  	case DImode:
  	  reg = gen_rtx_REG (DImode, regno);
*************** alpha_emit_xfloating_libcall (rtx func, 
*** 3143,3149 ****
  	  break;
  
  	default:
! 	  abort ();
  	}
  
        emit_move_insn (reg, operands[i]);
--- 3128,3134 ----
  	  break;
  
  	default:
! 	  gcc_unreachable ();
  	}
  
        emit_move_insn (reg, operands[i]);
*************** alpha_emit_xfloating_libcall (rtx func, 
*** 3162,3168 ****
        reg = gen_rtx_REG (DImode, 0);
        break;
      default:
!       abort ();
      }
  
    tmp = gen_rtx_MEM (QImode, func);
--- 3147,3153 ----
        reg = gen_rtx_REG (DImode, 0);
        break;
      default:
!       gcc_unreachable ();
      }
  
    tmp = gen_rtx_MEM (QImode, func);
*************** alpha_emit_xfloating_cvt (enum rtx_code 
*** 3265,3297 ****
  void
  alpha_split_tfmode_pair (rtx operands[4])
  {
!   if (GET_CODE (operands[1]) == REG)
      {
        operands[3] = gen_rtx_REG (DImode, REGNO (operands[1]) + 1);
        operands[2] = gen_rtx_REG (DImode, REGNO (operands[1]));
!     }
!   else if (GET_CODE (operands[1]) == MEM)
!     {
        operands[3] = adjust_address (operands[1], DImode, 8);
        operands[2] = adjust_address (operands[1], DImode, 0);
      }
-   else if (operands[1] == CONST0_RTX (TFmode))
-     operands[2] = operands[3] = const0_rtx;
-   else
-     abort ();
  
!   if (GET_CODE (operands[0]) == REG)
      {
        operands[1] = gen_rtx_REG (DImode, REGNO (operands[0]) + 1);
        operands[0] = gen_rtx_REG (DImode, REGNO (operands[0]));
!     }
!   else if (GET_CODE (operands[0]) == MEM)
!     {
        operands[1] = adjust_address (operands[0], DImode, 8);
        operands[0] = adjust_address (operands[0], DImode, 0);
      }
-   else
-     abort ();
  }
  
  /* Implement negtf2 or abstf2.  Op0 is destination, op1 is source,
--- 3250,3291 ----
  void
  alpha_split_tfmode_pair (rtx operands[4])
  {
!   switch (GET_CODE (operands[1]))
      {
+     case REG:
        operands[3] = gen_rtx_REG (DImode, REGNO (operands[1]) + 1);
        operands[2] = gen_rtx_REG (DImode, REGNO (operands[1]));
!       break;
! 
!     case MEM:
        operands[3] = adjust_address (operands[1], DImode, 8);
        operands[2] = adjust_address (operands[1], DImode, 0);
+       break;
+ 
+     case CONST_FLOAT:
+       gcc_assert (operands[1] == CONST0_RTX (TFmode));
+       operands[2] = operands[3] = const0_rtx;
+       break;
+ 
+     default:
+       gcc_unreachable ();
      }
  
!   switch (GET_CODE (operands[0]))
      {
+     case REG:
        operands[1] = gen_rtx_REG (DImode, REGNO (operands[0]) + 1);
        operands[0] = gen_rtx_REG (DImode, REGNO (operands[0]));
!       break;
! 
!     case MEM:
        operands[1] = adjust_address (operands[0], DImode, 8);
        operands[0] = adjust_address (operands[0], DImode, 0);
+       break;
+ 
+     default:
+       gcc_unreachable ();
      }
  }
  
  /* Implement negtf2 or abstf2.  Op0 is destination, op1 is source,
*************** alpha_expand_unaligned_load (rtx tgt, rt
*** 3477,3483 ****
  	      break;
  
  	    default:
! 	      abort ();
  	    }
  	  emit_insn (gen_extxl_be (exth, memh, GEN_INT (size*8), addr));
  	}
--- 3471,3477 ----
  	      break;
  
  	    default:
! 	      gcc_unreachable ();
  	    }
  	  emit_insn (gen_extxl_be (exth, memh, GEN_INT (size*8), addr));
  	}
*************** alpha_expand_unaligned_load (rtx tgt, rt
*** 3503,3509 ****
  	      break;
  
  	    default:
! 	      abort();
  	    }
  	}
  
--- 3497,3503 ----
  	      break;
  
  	    default:
! 	      gcc_unreachable ();
  	    }
  	}
  
*************** alpha_expand_block_move (rtx operands[])
*** 4029,4036 ****
        ofs += 1;
      }
  
!   if (nregs > ARRAY_SIZE (data_regs))
!     abort ();
  
    /* Now save it back out again.  */
  
--- 4023,4029 ----
        ofs += 1;
      }
  
!   gcc_assert (nregs <= ARRAY_SIZE (data_regs));
  
    /* Now save it back out again.  */
  
*************** alpha_expand_block_move (rtx operands[])
*** 4117,4132 ****
  	ofs += 2;
        }
  
!   while (i < nregs && GET_MODE (data_regs[i]) == QImode)
      {
        emit_move_insn (adjust_address (orig_dst, QImode, ofs), data_regs[i]);
        i++;
        ofs += 1;
      }
  
-   if (i != nregs)
-     abort ();
- 
    return 1;
  }
  
--- 4110,4124 ----
  	ofs += 2;
        }
  
!   /* The remainder must be byte copies.  */
!   while (i < nregs)
      {
+       gcc_assert (GET_MODE (data_regs[i]) == QImode);
        emit_move_insn (adjust_address (orig_dst, QImode, ofs), data_regs[i]);
        i++;
        ofs += 1;
      }
  
    return 1;
  }
  
*************** alpha_expand_zap_mask (HOST_WIDE_INT val
*** 4424,4433 ****
  
        result = gen_int_mode (mask, DImode);
      }
!   else if (HOST_BITS_PER_WIDE_INT == 32)
      {
        HOST_WIDE_INT mask_lo = 0, mask_hi = 0;
  
        for (i = 7; i >= 4; --i)
  	{
  	  mask_hi <<= 8;
--- 4416,4427 ----
  
        result = gen_int_mode (mask, DImode);
      }
!   else
      {
        HOST_WIDE_INT mask_lo = 0, mask_hi = 0;
  
+       gcc_assert (HOST_BITS_PER_WIDE_INT == 32);
+       
        for (i = 7; i >= 4; --i)
  	{
  	  mask_hi <<= 8;
*************** alpha_expand_zap_mask (HOST_WIDE_INT val
*** 4444,4451 ****
  
        result = immed_double_const (mask_lo, mask_hi, DImode);
      }
-   else
-     abort ();
  
    return result;
  }
--- 4438,4443 ----
*************** get_trap_mode_suffix (void)
*** 4699,4706 ****
  	case ALPHA_FPTM_SU:
  	case ALPHA_FPTM_SUI:
  	  return "sv";
  	}
-       break;
  
      case TRAP_SUFFIX_V_SV_SVI:
        switch (alpha_fptm)
--- 4691,4699 ----
  	case ALPHA_FPTM_SU:
  	case ALPHA_FPTM_SUI:
  	  return "sv";
+ 	default:
+ 	  gcc_unreachable ();
  	}
  
      case TRAP_SUFFIX_V_SV_SVI:
        switch (alpha_fptm)
*************** get_trap_mode_suffix (void)
*** 4713,4718 ****
--- 4706,4713 ----
  	  return "sv";
  	case ALPHA_FPTM_SUI:
  	  return "svi";
+ 	default:
+ 	  gcc_unreachable ();
  	}
        break;
  
*************** get_trap_mode_suffix (void)
*** 4727,4736 ****
  	  return "su";
  	case ALPHA_FPTM_SUI:
  	  return "sui";
  	}
        break;
      }
!   abort ();
  }
  
  /* Return the rounding mode suffix applicable to the current
--- 4722,4736 ----
  	  return "su";
  	case ALPHA_FPTM_SUI:
  	  return "sui";
+ 	default:
+ 	  gcc_unreachable ();
  	}
        break;
+       
+     default:
+       gcc_unreachable ();
      }
!   gcc_unreachable ();
  }
  
  /* Return the rounding mode suffix applicable to the current
*************** get_round_mode_suffix (void)
*** 4756,4768 ****
  	  return "c";
  	case ALPHA_FPRM_DYN:
  	  return "d";
  	}
        break;
  
      case ROUND_SUFFIX_C:
        return "c";
      }
!   abort ();
  }
  
  /* Locate some local-dynamic symbol still in use by this function
--- 4756,4773 ----
  	  return "c";
  	case ALPHA_FPRM_DYN:
  	  return "d";
+ 	default:
+ 	  gcc_unreachable ();
  	}
        break;
  
      case ROUND_SUFFIX_C:
        return "c";
+       
+     default:
+       gcc_unreachable ();
      }
!   gcc_unreachable ();
  }
  
  /* Locate some local-dynamic symbol still in use by this function
*************** get_some_local_dynamic_name (void)
*** 4796,4802 ****
  	&& for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
        return cfun->machine->some_ld_name;
  
!   abort ();
  }
  
  /* Print an operand.  Recognize special options, documented below.  */
--- 4801,4807 ----
  	&& for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
        return cfun->machine->some_ld_name;
  
!   gcc_unreachable ();
  }
  
  /* Print an operand.  Recognize special options, documented below.  */
*************** print_operand_address (FILE *file, rtx a
*** 5205,5250 ****
  	fprintf (file, "+" HOST_WIDE_INT_PRINT_DEC, offset);
  
        addr = XEXP (addr, 0);
!       if (GET_CODE (addr) == REG)
! 	basereg = REGNO (addr);
!       else if (GET_CODE (addr) == SUBREG
! 	       && GET_CODE (SUBREG_REG (addr)) == REG)
! 	basereg = subreg_regno (addr);
!       else
! 	abort ();
  
        fprintf (file, "($%d)\t\t!%s", basereg,
  	       (basereg == 29 ? reloc16 : reloclo));
        return;
      }
  
!   if (GET_CODE (addr) == REG)
!     basereg = REGNO (addr);
!   else if (GET_CODE (addr) == SUBREG
! 	   && GET_CODE (SUBREG_REG (addr)) == REG)
!     basereg = subreg_regno (addr);
!   else if (GET_CODE (addr) == CONST_INT)
!     offset = INTVAL (addr);
  
  #if TARGET_ABI_OPEN_VMS
!   else if (GET_CODE (addr) == SYMBOL_REF)
!     {
        fprintf (file, "%s", XSTR (addr, 0));
        return;
!     }
!   else if (GET_CODE (addr) == CONST
! 	   && GET_CODE (XEXP (addr, 0)) == PLUS
! 	   && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF)
!     {
        fprintf (file, "%s+" HOST_WIDE_INT_PRINT_DEC,
  	       XSTR (XEXP (XEXP (addr, 0), 0), 0),
  	       INTVAL (XEXP (XEXP (addr, 0), 1)));
        return;
!     }
  #endif
! 
!   else
!     abort ();
  
    fprintf (file, HOST_WIDE_INT_PRINT_DEC "($%d)", offset, basereg);
  }
--- 5210,5265 ----
  	fprintf (file, "+" HOST_WIDE_INT_PRINT_DEC, offset);
  
        addr = XEXP (addr, 0);
!       switch (GET_CODE (addr))
! 	{
! 	case REG:
! 	  basereg = REGNO (addr);
! 	  break;
! 
! 	case SUBREG:
! 	  basereg = subreg_regno (addr);
! 	  break;
! 
! 	default:
! 	  gcc_unreachable ();
! 	}
  
        fprintf (file, "($%d)\t\t!%s", basereg,
  	       (basereg == 29 ? reloc16 : reloclo));
        return;
      }
  
!   switch (GET_CODE (addr))
!     {
!     case REG:
!       basereg = REGNO (addr);
!       break;
! 
!     case SUBREG:
!       basereg = subreg_regno (addr);
!       break;
! 
!     case CONST_INT:
!       offset = INTVAL (addr);
!       break;
  
  #if TARGET_ABI_OPEN_VMS
!     case SYMBOL_REF:
        fprintf (file, "%s", XSTR (addr, 0));
        return;
! 
!     case CONST:
!       gcc_assert (GET_CODE (XEXP (addr, 0)) == PLUS
! 		  && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF);
        fprintf (file, "%s+" HOST_WIDE_INT_PRINT_DEC,
  	       XSTR (XEXP (XEXP (addr, 0), 0), 0),
  	       INTVAL (XEXP (XEXP (addr, 0), 1)));
        return;
!     
  #endif
!     default:
!       gcc_unreachable ();
!     }
  
    fprintf (file, HOST_WIDE_INT_PRINT_DEC "($%d)", offset, basereg);
  }
*************** function_arg (CUMULATIVE_ARGS cum, enum 
*** 5343,5350 ****
  #ifdef ENABLE_CHECKING
        /* With alpha_split_complex_arg, we shouldn't see any raw complex
  	 values here.  */
!       if (COMPLEX_MODE_P (mode))
! 	abort ();
  #endif
  
        /* Set up defaults for FP operands passed in FP registers, and
--- 5358,5364 ----
  #ifdef ENABLE_CHECKING
        /* With alpha_split_complex_arg, we shouldn't see any raw complex
  	 values here.  */
!       gcc_assert (!COMPLEX_MODE_P (mode));
  #endif
  
        /* Set up defaults for FP operands passed in FP registers, and
*************** alpha_return_in_memory (tree type, tree 
*** 5514,5521 ****
  
      default:
        /* ??? We get called on all sorts of random stuff from
! 	 aggregate_value_p.  We can't abort, but it's not clear
! 	 what's safe to return.  Pretend it's a struct I guess.  */
        return true;
      }
  
--- 5528,5536 ----
  
      default:
        /* ??? We get called on all sorts of random stuff from
! 	 aggregate_value_p.  We must return something, but it's not
! 	 clear what's safe to return.  Pretend it's a struct I
! 	 guess.  */
        return true;
      }
  
*************** function_value (tree valtype, tree func 
*** 5549,5558 ****
    unsigned int regnum, dummy;
    enum mode_class class;
  
! #ifdef ENABLE_CHECKING
!   if (valtype && alpha_return_in_memory (valtype, func))
!     abort ();
! #endif
  
    if (valtype)
      mode = TYPE_MODE (valtype);
--- 5564,5570 ----
    unsigned int regnum, dummy;
    enum mode_class class;
  
!   gcc_assert (!valtype || !alpha_return_in_memory (valtype, func));
  
    if (valtype)
      mode = TYPE_MODE (valtype);
*************** function_value (tree valtype, tree func 
*** 5587,5593 ****
        }
  
      default:
!       abort ();
      }
  
    return gen_rtx_REG (mode, regnum);
--- 5599,5605 ----
        }
  
      default:
!       gcc_unreachable ();
      }
  
    return gen_rtx_REG (mode, regnum);
*************** alpha_expand_builtin (tree exp, rtx targ
*** 6368,6374 ****
        pat = GEN_FCN (icode) (target, op[0], op[1]);
        break;
      default:
!       abort ();
      }
    if (!pat)
      return NULL_RTX;
--- 6380,6386 ----
        pat = GEN_FCN (icode) (target, op[0], op[1]);
        break;
      default:
!       gcc_unreachable ();
      }
    if (!pat)
      return NULL_RTX;
*************** alpha_initial_elimination_offset (unsign
*** 7052,7065 ****
    ret = alpha_sa_size ();
    ret += ALPHA_ROUND (current_function_outgoing_args_size);
  
!   if (from == FRAME_POINTER_REGNUM)
!     ;
!   else if (from == ARG_POINTER_REGNUM)
!     ret += (ALPHA_ROUND (get_frame_size ()
! 			 + current_function_pretend_args_size)
! 	    - current_function_pretend_args_size);
!   else
!     abort ();
  
    return ret;
  }
--- 7064,7083 ----
    ret = alpha_sa_size ();
    ret += ALPHA_ROUND (current_function_outgoing_args_size);
  
!   switch (from)
!     {
!     case FRAME_POINTER_REGNUM:
!       break;
! 
!     case ARG_POINTER_REGNUM:
!       ret += (ALPHA_ROUND (get_frame_size ()
! 			   + current_function_pretend_args_size)
! 	      - current_function_pretend_args_size);
!       break;
! 
!     default:
!       gcc_unreachable ();
!     }
  
    return ret;
  }
*************** alpha_expand_epilogue (void)
*** 7957,7964 ****
  		 so build it up by pieces.  */
  	      FRP (sp_adj2 = alpha_emit_set_long_const (tmp, frame_size,
  							-(frame_size < 0)));
! 	      if (!sp_adj2)
! 		abort ();
  	    }
  	}
  
--- 7975,7981 ----
  		 so build it up by pieces.  */
  	      FRP (sp_adj2 = alpha_emit_set_long_const (tmp, frame_size,
  							-(frame_size < 0)));
! 	      gcc_assert (sp_adj2);
  	    }
  	}
  
*************** summarize_insn (rtx x, struct shadow_sum
*** 8334,8340 ****
  	    break;
  
  	  default:
! 	    abort ();
  	  }
      }
  }
--- 8351,8357 ----
  	    break;
  
  	  default:
! 	    gcc_unreachable ();
  	  }
      }
  }
*************** alpha_handle_trap_shadows (void)
*** 8432,8438 ****
  		  switch (GET_CODE (i))
  		    {
  		    case INSN:
! 		      /* Annoyingly, get_attr_trap will abort on these.  */
  		      if (GET_CODE (PATTERN (i)) == USE
  			  || GET_CODE (PATTERN (i)) == CLOBBER)
  			break;
--- 8449,8455 ----
  		  switch (GET_CODE (i))
  		    {
  		    case INSN:
! 		      /* Annoyingly, get_attr_trap will die on these.  */
  		      if (GET_CODE (PATTERN (i)) == USE
  			  || GET_CODE (PATTERN (i)) == CLOBBER)
  			break;
*************** alpha_handle_trap_shadows (void)
*** 8459,8468 ****
  			  || (sum.defd.mem & shadow.used.mem))
  			{
  			  /* (a) would be violated (also takes care of (b))  */
! 			  if (get_attr_trap (i) == TRAP_YES
! 			      && ((sum.defd.i & sum.used.i)
! 				  || (sum.defd.fp & sum.used.fp)))
! 			    abort ();
  
  			  goto close_shadow;
  			}
--- 8476,8484 ----
  			  || (sum.defd.mem & shadow.used.mem))
  			{
  			  /* (a) would be violated (also takes care of (b))  */
! 			  gcc_assert (get_attr_trap (i) != TRAP_YES
! 				      || (!(sum.defd.i & sum.used.i)
! 					  && !(sum.defd.fp & sum.used.fp)));
  
  			  goto close_shadow;
  			}
*************** alpha_handle_trap_shadows (void)
*** 8474,8480 ****
  		      goto close_shadow;
  
  		    default:
! 		      abort ();
  		    }
  		}
  	      else
--- 8490,8496 ----
  		      goto close_shadow;
  
  		    default:
! 		      gcc_unreachable ();
  		    }
  		}
  	      else
*************** alphaev4_insn_pipe (rtx insn)
*** 8567,8573 ****
        return EV4_IB1;
  
      default:
!       abort ();
      }
  }
  
--- 8583,8589 ----
        return EV4_IB1;
  
      default:
!       gcc_unreachable ();
      }
  }
  
*************** alphaev5_insn_pipe (rtx insn)
*** 8619,8625 ****
        return EV5_FM;
  
      default:
!       abort();
      }
  }
  
--- 8635,8641 ----
        return EV5_FM;
  
      default:
!       gcc_unreachable ();
      }
  }
  
*************** alphaev4_next_group (rtx insn, int *pin_
*** 8690,8696 ****
  	  break;
  
  	default:
! 	  abort();
  	}
        len += 4;
  
--- 8706,8712 ----
  	  break;
  
  	default:
! 	  gcc_unreachable ();
  	}
        len += 4;
  
*************** alphaev5_next_group (rtx insn, int *pin_
*** 8760,8770 ****
  	    len = get_attr_length (insn);
  	  goto next_and_done;
  
! 	/* ??? Most of the places below, we would like to abort, as
! 	   it would indicate an error either in Haifa, or in the
! 	   scheduling description.  Unfortunately, Haifa never
! 	   schedules the last instruction of the BB, so we don't
! 	   have an accurate TI bit to go off.  */
  	case EV5_E01:
  	  if (in_use & EV5_E0)
  	    {
--- 8776,8786 ----
  	    len = get_attr_length (insn);
  	  goto next_and_done;
  
! 	/* ??? Most of the places below, we would like to assert never
! 	   happen, as it would indicate an error either in Haifa, or
! 	   in the scheduling description.  Unfortunately, Haifa never
! 	   schedules the last instruction of the BB, so we don't have
! 	   an accurate TI bit to go off.  */
  	case EV5_E01:
  	  if (in_use & EV5_E0)
  	    {
*************** alphaev5_next_group (rtx insn, int *pin_
*** 8819,8825 ****
  	  break;
  
  	default:
! 	  abort();
  	}
        len += 4;
  
--- 8835,8841 ----
  	  break;
  
  	default:
! 	  gcc_unreachable ();
  	}
        len += 4;
  
*************** alpha_align_insns (unsigned int max_alig
*** 8954,8961 ****
  
  	  else if (ofs & (new_align-1))
  	    ofs = (ofs | (new_align-1)) + 1;
! 	  if (len != 0)
! 	    abort();
  	}
  
        /* Handle complex instructions special.  */
--- 8970,8976 ----
  
  	  else if (ofs & (new_align-1))
  	    ofs = (ofs | (new_align-1)) + 1;
! 	  gcc_assert (!len);
  	}
  
        /* Handle complex instructions special.  */
*************** unicosmk_initial_elimination_offset (int
*** 9542,9548 ****
  	    + ALPHA_ROUND (get_frame_size()
  			   + current_function_outgoing_args_size));
    else
!     abort ();
  }
  
  /* Output the module name for .ident and .end directives. We have to strip
--- 9557,9563 ----
  	    + ALPHA_ROUND (get_frame_size()
  			   + current_function_outgoing_args_size));
    else
!     gcc_unreachable ();
  }
  
  /* Output the module name for .ident and .end directives. We have to strip
*************** unicosmk_unique_section (tree decl, int 
*** 9626,9633 ****
    const char *name;
    int len;
  
!   if (!decl)
!     abort ();
  
    name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
    name = default_strip_name_encoding (name);
--- 9641,9647 ----
    const char *name;
    int len;
  
!   gcc_assert (decl);
  
    name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
    name = default_strip_name_encoding (name);
*************** unicosmk_ssib_name (void)
*** 9777,9787 ****
    int len;
  
    x = DECL_RTL (cfun->decl);
!   if (GET_CODE (x) != MEM)
!     abort ();
    x = XEXP (x, 0);
!   if (GET_CODE (x) != SYMBOL_REF)
!     abort ();
    fnname = XSTR (x, 0);
  
    len = strlen (fnname);
--- 9791,9799 ----
    int len;
  
    x = DECL_RTL (cfun->decl);
!   gcc_assert (GET_CODE (x) == MEM);
    x = XEXP (x, 0);
!   gcc_assert (GET_CODE (x) == SYMBOL_REF);
    fnname = XSTR (x, 0);
  
    len = strlen (fnname);
Index: config/alpha/alpha.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/alpha/alpha.h,v
retrieving revision 1.240
diff -c -3 -p -r1.240 alpha.h
*** config/alpha/alpha.h	27 Apr 2005 09:11:56 -0000	1.240
--- config/alpha/alpha.h	8 May 2005 09:44:39 -0000
*************** do {						\
*** 1369,1375 ****
  /* This is how to output an element of a case-vector that is absolute.
     (Alpha does not use such vectors, but we must define this macro anyway.)  */
  
! #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) abort ()
  
  /* This is how to output an element of a case-vector that is relative.  */
  
--- 1369,1375 ----
  /* This is how to output an element of a case-vector that is absolute.
     (Alpha does not use such vectors, but we must define this macro anyway.)  */
  
! #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) gcc_unreachable ()
  
  /* This is how to output an element of a case-vector that is relative.  */
  
Index: config/alpha/alpha.md
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/alpha/alpha.md,v
retrieving revision 1.238
diff -c -3 -p -r1.238 alpha.md
*** config/alpha/alpha.md	18 Apr 2005 16:12:58 -0000	1.238
--- config/alpha/alpha.md	8 May 2005 09:44:59 -0000
***************
*** 1003,1009 ****
        str = "__remlu";
        break;
      default:
!       abort ();
      }
    operands[4] = GEN_INT (alpha_next_sequence_number++);
    emit_insn (gen_movdi_er_high_g (operands[0], pic_offset_table_rtx,
--- 1003,1009 ----
        str = "__remlu";
        break;
      default:
!       gcc_unreachable ();
      }
    operands[4] = GEN_INT (alpha_next_sequence_number++);
    emit_insn (gen_movdi_er_high_g (operands[0], pic_offset_table_rtx,
***************
*** 1071,1077 ****
        str = "__remqu";
        break;
      default:
!       abort ();
      }
    operands[4] = GEN_INT (alpha_next_sequence_number++);
    emit_insn (gen_movdi_er_high_g (operands[0], pic_offset_table_rtx,
--- 1071,1077 ----
        str = "__remqu";
        break;
      default:
!       gcc_unreachable ();
      }
    operands[4] = GEN_INT (alpha_next_sequence_number++);
    emit_insn (gen_movdi_er_high_g (operands[0], pic_offset_table_rtx,
***************
*** 1452,1458 ****
      case 1:
        return "sll %r1,%2,%0";
      default:
!       abort();
      }
  }
    [(set_attr "type" "iadd,shift")])
--- 1452,1458 ----
      case 1:
        return "sll %r1,%2,%0";
      default:
!       gcc_unreachable ();
      }
  }
    [(set_attr "type" "iadd,shift")])
***************
*** 2124,2130 ****
        == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
      return "insll %1,%s2,%0";
  #endif
!   abort();
  }
    [(set_attr "type" "shift")])
  
--- 2124,2130 ----
        == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
      return "insll %1,%s2,%0";
  #endif
!   gcc_unreachable ();
  }
    [(set_attr "type" "shift")])
  
***************
*** 4497,4504 ****
  	      (unspec [(reg:DI 29)] UNSPEC_SIBCALL)])]
    "TARGET_ABI_OSF"
  {
!   if (GET_CODE (operands[0]) != MEM)
!     abort ();
    operands[0] = XEXP (operands[0], 0);
  })
  
--- 4497,4503 ----
  	      (unspec [(reg:DI 29)] UNSPEC_SIBCALL)])]
    "TARGET_ABI_OSF"
  {
!   gcc_assert (GET_CODE (operands[0]) == MEM);
    operands[0] = XEXP (operands[0], 0);
  })
  
***************
*** 4509,4516 ****
  	      (clobber (reg:DI 26))])]
    ""
  {
!   if (GET_CODE (operands[0]) != MEM)
!     abort ();
  
    operands[0] = XEXP (operands[0], 0);
    if (! call_operand (operands[0], Pmode))
--- 4508,4514 ----
  	      (clobber (reg:DI 26))])]
    ""
  {
!   gcc_assert (GET_CODE (operands[0]) == MEM);
  
    operands[0] = XEXP (operands[0], 0);
    if (! call_operand (operands[0], Pmode))
***************
*** 4523,4530 ****
  	      (clobber (reg:DI 26))])]
    ""
  {
!   if (GET_CODE (operands[0]) != MEM)
!     abort ();
  
    operands[0] = XEXP (operands[0], 0);
    if (GET_CODE (operands[0]) != SYMBOL_REF && GET_CODE (operands[0]) != REG)
--- 4521,4527 ----
  	      (clobber (reg:DI 26))])]
    ""
  {
!   gcc_assert (GET_CODE (operands[0]) == MEM);
  
    operands[0] = XEXP (operands[0], 0);
    if (GET_CODE (operands[0]) != SYMBOL_REF && GET_CODE (operands[0]) != REG)
***************
*** 4542,4549 ****
  	       (clobber (reg:DI 26))])]
     ""
  {
!   if (GET_CODE (operands[0]) != MEM)
!     abort ();
  
    /* Always load the address of the called function into a register;
       load the CIW in $25.  */
--- 4539,4545 ----
  	       (clobber (reg:DI 26))])]
     ""
  {
!   gcc_assert (GET_CODE (operands[0]) == MEM);
  
    /* Always load the address of the called function into a register;
       load the CIW in $25.  */
***************
*** 4569,4576 ****
  	      (clobber (reg:DI 27))])]
    ""
  {
!   if (GET_CODE (operands[0]) != MEM)
!     abort ();
  
    operands[0] = XEXP (operands[0], 0);
  
--- 4565,4571 ----
  	      (clobber (reg:DI 27))])]
    ""
  {
!   gcc_assert (GET_CODE (operands[0]) == MEM);
  
    operands[0] = XEXP (operands[0], 0);
  
***************
*** 4623,4630 ****
  	      (unspec [(reg:DI 29)] UNSPEC_SIBCALL)])]
    "TARGET_ABI_OSF"
  {
!   if (GET_CODE (operands[1]) != MEM)
!     abort ();
    operands[1] = XEXP (operands[1], 0);
  })
  
--- 4618,4624 ----
  	      (unspec [(reg:DI 29)] UNSPEC_SIBCALL)])]
    "TARGET_ABI_OSF"
  {
!   gcc_assert (GET_CODE (operands[1]) == MEM);
    operands[1] = XEXP (operands[1], 0);
  })
  
***************
*** 4636,4643 ****
  	      (clobber (reg:DI 26))])]
    ""
  {
!   if (GET_CODE (operands[1]) != MEM)
!     abort ();
  
    operands[1] = XEXP (operands[1], 0);
    if (! call_operand (operands[1], Pmode))
--- 4630,4636 ----
  	      (clobber (reg:DI 26))])]
    ""
  {
!   gcc_assert (GET_CODE (operands[1]) == MEM);
  
    operands[1] = XEXP (operands[1], 0);
    if (! call_operand (operands[1], Pmode))
***************
*** 4651,4658 ****
  	      (clobber (reg:DI 26))])]
    ""
  {
!   if (GET_CODE (operands[1]) != MEM)
!     abort ();
  
    operands[1] = XEXP (operands[1], 0);
    if (GET_CODE (operands[1]) != SYMBOL_REF && GET_CODE (operands[1]) != REG)
--- 4644,4650 ----
  	      (clobber (reg:DI 26))])]
    ""
  {
!   gcc_assert (GET_CODE (operands[1]) == MEM);
  
    operands[1] = XEXP (operands[1], 0);
    if (GET_CODE (operands[1]) != SYMBOL_REF && GET_CODE (operands[1]) != REG)
***************
*** 4669,4676 ****
  	      (clobber (reg:DI 27))])]
    ""
  {
!   if (GET_CODE (operands[1]) != MEM)
!     abort ();
  
    operands[1] = XEXP (operands[1], 0);
  
--- 4661,4667 ----
  	      (clobber (reg:DI 27))])]
    ""
  {
!   gcc_assert (GET_CODE (operands[1]) == MEM);
  
    operands[1] = XEXP (operands[1], 0);
  
***************
*** 4701,4708 ****
  	      (clobber (reg:DI 26))])]
    ""
  {
!   if (GET_CODE (operands[1]) != MEM)
!     abort ();
  
    operands[1] = XEXP (operands[1], 0);
    if (GET_CODE (operands[1]) != REG)
--- 4692,4698 ----
  	      (clobber (reg:DI 26))])]
    ""
  {
!   gcc_assert (GET_CODE (operands[1]) == MEM);
  
    operands[1] = XEXP (operands[1], 0);
    if (GET_CODE (operands[1]) != REG)
***************
*** 4902,4908 ****
  	operands [3] = alpha_use_linkage (operands [0], cfun->decl, 0, 0);
     	return "ldq $26,%3\;ldq $27,%2\;jsr $26,%0\;ldq $27,0($29)";
      default:
!       abort();
      }
  }
    [(set_attr "type" "jsr")
--- 4892,4898 ----
  	operands [3] = alpha_use_linkage (operands [0], cfun->decl, 0, 0);
     	return "ldq $26,%3\;ldq $27,%2\;jsr $26,%0\;ldq $27,0($29)";
      default:
!       gcc_unreachable ();
      }
  }
    [(set_attr "type" "jsr")
***************
*** 5639,5645 ****
  
  ;; VMS needs to set up "vms_base_regno" for unwinding.  This move
  ;; often appears dead to the life analysis code, at which point we
! ;; abort for emitting dead prologue instructions.  Force this live.
  
  (define_insn "force_movdi"
    [(set (match_operand:DI 0 "register_operand" "=r")
--- 5629,5635 ----
  
  ;; VMS needs to set up "vms_base_regno" for unwinding.  This move
  ;; often appears dead to the life analysis code, at which point we
! ;; die for emitting dead prologue instructions.  Force this live.
  
  (define_insn "force_movdi"
    [(set (match_operand:DI 0 "register_operand" "=r")
***************
*** 6556,6562 ****
      case 1:
  	return "lda $16,%0\;lda $17,%2($31)\;lda $18,%1\;ldq $26,%5\;lda $25,3($31)\;jsr $26,%4\;ldq $27,0($29)";
      default:
!       abort();
      }
  }
    [(set_attr "type" "multi")
--- 6546,6552 ----
      case 1:
  	return "lda $16,%0\;lda $17,%2($31)\;lda $18,%1\;ldq $26,%5\;lda $25,3($31)\;jsr $26,%4\;ldq $27,0($29)";
      default:
!       gcc_unreachable ();
      }
  }
    [(set_attr "type" "multi")
***************
*** 6613,6619 ****
      case 1:
  	return "lda $16,%0\;lda $17,%1($31)\;ldq $26,%4\;lda $25,2($31)\;jsr $26,%3\;ldq $27,0($29)";
      default:
!       abort();
      }
  }
    [(set_attr "type" "multi")
--- 6603,6609 ----
      case 1:
  	return "lda $16,%0\;lda $17,%1($31)\;ldq $26,%4\;lda $25,2($31)\;jsr $26,%3\;ldq $27,0($29)";
      default:
!       gcc_unreachable ();
      }
  }
    [(set_attr "type" "multi")
***************
*** 8036,8042 ****
  	operands [4] = alpha_use_linkage (operands [1], cfun->decl, 0, 0);
     	return "ldq $26,%4\;ldq $27,%3\;jsr $26,%1\;ldq $27,0($29)";
      default:
!       abort();
      }
  }
    [(set_attr "type" "jsr")
--- 8026,8032 ----
  	operands [4] = alpha_use_linkage (operands [1], cfun->decl, 0, 0);
     	return "ldq $26,%4\;ldq $27,%3\;jsr $26,%1\;ldq $27,0($29)";
      default:
!       gcc_unreachable ();
      }
  }
    [(set_attr "type" "jsr")
Index: config/alpha/predicates.md
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/alpha/predicates.md,v
retrieving revision 1.4
diff -c -3 -p -r1.4 predicates.md
*** config/alpha/predicates.md	22 Jan 2005 12:53:24 -0000	1.4
--- config/alpha/predicates.md	8 May 2005 09:44:59 -0000
***************
*** 231,237 ****
        return add_operand (op, mode);
  
      default:
!       abort ();
      }
    return 0;
  })
--- 231,237 ----
        return add_operand (op, mode);
  
      default:
!       gcc_unreachable ();
      }
    return 0;
  })
***************
*** 506,512 ****
  
  ;; Returns 1 if OP is not an eliminable register.
  ;;
! ;; This exists to cure a pathological abort in the s8addq (et al) patterns,
  ;;
  ;;	long foo () { long t; bar(); return (long) &t * 26107; }
  ;;
--- 506,512 ----
  
  ;; Returns 1 if OP is not an eliminable register.
  ;;
! ;; This exists to cure a pathological failure in the s8addq (et al) patterns,
  ;;
  ;;	long foo () { long t; bar(); return (long) &t * 26107; }
  ;;
Index: config/alpha/unicosmk.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/alpha/unicosmk.h,v
retrieving revision 1.35
diff -c -3 -p -r1.35 unicosmk.h
*** config/alpha/unicosmk.h	30 Dec 2004 03:07:39 -0000	1.35
--- config/alpha/unicosmk.h	8 May 2005 09:45:01 -0000
*************** do { fprintf (FILE, "\tbr $1,0\n");			\
*** 230,236 ****
  /* We don't support nested functions (yet).  */
  
  #undef TRAMPOLINE_TEMPLATE
! #define TRAMPOLINE_TEMPLATE(FILE) abort ()
  
  /* Specify the machine mode that this machine uses for the index in the
     tablejump instruction. On Unicos/Mk, we don't support relative case
--- 230,236 ----
  /* We don't support nested functions (yet).  */
  
  #undef TRAMPOLINE_TEMPLATE
! #define TRAMPOLINE_TEMPLATE(FILE) gcc_unreachable ()
  
  /* Specify the machine mode that this machine uses for the index in the
     tablejump instruction. On Unicos/Mk, we don't support relative case
*************** ssib_section (void)		\
*** 374,380 ****
     (Unicos/Mk does not use such vectors yet).  */
  
  #undef ASM_OUTPUT_ADDR_DIFF_ELT
! #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) abort ()
  
  /* We can't output case vectors in the same section as the function code
     because CAM doesn't allow data definitions in code sections. Thus, we
--- 374,380 ----
     (Unicos/Mk does not use such vectors yet).  */
  
  #undef ASM_OUTPUT_ADDR_DIFF_ELT
! #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) gcc_unreachable ()
  
  /* We can't output case vectors in the same section as the function code
     because CAM doesn't allow data definitions in code sections. Thus, we
*************** ssib_section (void)		\
*** 384,390 ****
  #define ASM_OUTPUT_ADDR_VEC(LAB,VEC) \
    unicosmk_defer_case_vector ((LAB),(VEC))
  
! #define ASM_OUTPUT_ADDR_DIFF_VEC(LAB,VEC) abort ()
  
  /* This is how to output an assembler line that says to advance the location
     counter to a multiple of 2**LOG bytes. Annoyingly, CAM always uses zeroes
--- 384,390 ----
  #define ASM_OUTPUT_ADDR_VEC(LAB,VEC) \
    unicosmk_defer_case_vector ((LAB),(VEC))
  
! #define ASM_OUTPUT_ADDR_DIFF_VEC(LAB,VEC) gcc_unreachable ()
  
  /* This is how to output an assembler line that says to advance the location
     counter to a multiple of 2**LOG bytes. Annoyingly, CAM always uses zeroes
Index: config/alpha/vms.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/alpha/vms.h,v
retrieving revision 1.86
diff -c -3 -p -r1.86 vms.h
*** config/alpha/vms.h	18 Mar 2005 15:24:23 -0000	1.86
--- config/alpha/vms.h	8 May 2005 09:45:01 -0000
*************** Boston, MA 02111-1307, USA.  */
*** 136,150 ****
  
  #undef INITIAL_ELIMINATION_OFFSET
  #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)			\
! { if ((FROM) == FRAME_POINTER_REGNUM)					\
!     (OFFSET) = alpha_sa_size () + alpha_pv_save_size ();		\
!   else if ((FROM) == ARG_POINTER_REGNUM)				\
!     (OFFSET) = (ALPHA_ROUND (alpha_sa_size () + alpha_pv_save_size ()	\
! 			     + get_frame_size ()			\
! 			     + current_function_pretend_args_size)	\
! 		- current_function_pretend_args_size);			\
!   else									\
!     abort();								\
    if ((TO) == STACK_POINTER_REGNUM)					\
      (OFFSET) += ALPHA_ROUND (current_function_outgoing_args_size);	\
  }
--- 136,155 ----
  
  #undef INITIAL_ELIMINATION_OFFSET
  #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)			\
! { switch (FROM)								\
!     {									\
!     case FRAME_POINTER_REGNUM:						\
!       (OFFSET) = alpha_sa_size () + alpha_pv_save_size ();		\
!       break;								\
!     case ARG_POINTER_REGNUM:						\
!       (OFFSET) = (ALPHA_ROUND (alpha_sa_size () + alpha_pv_save_size ()	\
! 			       + get_frame_size ()			\
! 			       + current_function_pretend_args_size)	\
! 		  - current_function_pretend_args_size);		\
!       break;								\
!     default:								\
!       gcc_unreachable ();						\
!     }									\
    if ((TO) == STACK_POINTER_REGNUM)					\
      (OFFSET) += ALPHA_ROUND (current_function_outgoing_args_size);	\
  }
*************** extern void link_section (void);
*** 227,233 ****
  extern void literals_section (void);
  
  #undef ASM_OUTPUT_ADDR_DIFF_ELT
! #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) abort ()
  
  #undef ASM_OUTPUT_ADDR_VEC_ELT
  #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
--- 232,238 ----
  extern void literals_section (void);
  
  #undef ASM_OUTPUT_ADDR_DIFF_ELT
! #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) gcc_unreachable ()
  
  #undef ASM_OUTPUT_ADDR_VEC_ELT
  #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]