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]

[PATCH] Use C90-style function pointer calls in fold-const.c


The following patch updates calls of the form "(*lang_hooks.foo) (...)"
in fold-const.c to use what I believe is the now preferred C90 style,
"lang_hooks.foo (...)".

Regrettably, I'm not 100% confident that this idiom is the GCC preference,
virtually all uses of lang_hooks in GCC currently use the (*lang_hooks)
form, so I thought I'd ask for a second opinion, even though C90 clean-ups
have been pre-approved.  Apologies for showing my ignorance.

The following patch has been tested on i686-pc-linux-gnu with a full
"make bootstrap", all languages except treelang, and regression tested
with a top-level "make -k check" with no new failures.

Ok for mainline?


2004-03-13  Roger Sayle  <roger@eyesopen.com>

	* fold-const.c (negate_expr, operand_equal_for_comparison_p,
	optimize_bit_field_compare, decode_field_reference, all_ones_mask_p,
	make_range, build_range_check, fold_range_test, unextend,
	constant_boolean_node, fold_binary_op_with_conditional_arg,
	fold_truthop, fold_mathfn_compare, fold_inf_compare,
	fold_single_bit_test, fold): Replace calls via (*lang_hooks.foo) ()
	with lang_hooks.foo ().


Index: fold-const.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/fold-const.c,v
retrieving revision 1.344
diff -c -3 -p -r1.344 fold-const.c
*** fold-const.c	11 Mar 2004 17:45:01 -0000	1.344
--- fold-const.c	13 Mar 2004 16:55:42 -0000
*************** negate_expr (tree t)
*** 1087,1094 ****
  		 == TREE_INT_CST_LOW (op1))
  	    {
  	      tree ntype = TREE_UNSIGNED (type)
! 			   ? (*lang_hooks.types.signed_type) (type)
! 			   : (*lang_hooks.types.unsigned_type) (type);
  	      tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
  	      temp = fold (build2 (RSHIFT_EXPR, ntype, temp, op1));
  	      return fold_convert (type, temp);
--- 1087,1094 ----
  		 == TREE_INT_CST_LOW (op1))
  	    {
  	      tree ntype = TREE_UNSIGNED (type)
! 			   ? lang_hooks.types.signed_type (type)
! 			   : lang_hooks.types.unsigned_type (type);
  	      tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
  	      temp = fold (build2 (RSHIFT_EXPR, ntype, temp, op1));
  	      return fold_convert (type, temp);
*************** operand_equal_for_comparison_p (tree arg
*** 2419,2425 ****

        /* Make sure shorter operand is extended the right way
  	 to match the longer operand.  */
!       primarg1 = fold_convert ((*lang_hooks.types.signed_or_unsigned_type)
  			       (unsignedp1, TREE_TYPE (primarg1)), primarg1);

        if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
--- 2419,2425 ----

        /* Make sure shorter operand is extended the right way
  	 to match the longer operand.  */
!       primarg1 = fold_convert (lang_hooks.types.signed_or_unsigned_type
  			       (unsignedp1, TREE_TYPE (primarg1)), primarg1);

        if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
*************** optimize_bit_field_compare (enum tree_co
*** 2900,2907 ****

    /* Set signed and unsigned types of the precision of this mode for the
       shifts below.  */
!   signed_type = (*lang_hooks.types.type_for_mode) (nmode, 0);
!   unsigned_type = (*lang_hooks.types.type_for_mode) (nmode, 1);

    /* Compute the bit position and size for the new reference and our offset
       within it. If the new reference is the same size as the original, we
--- 2900,2907 ----

    /* Set signed and unsigned types of the precision of this mode for the
       shifts below.  */
!   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
!   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);

    /* Compute the bit position and size for the new reference and our offset
       within it. If the new reference is the same size as the original, we
*************** decode_field_reference (tree exp, HOST_W
*** 3074,3080 ****
      *punsignedp = TREE_UNSIGNED (outer_type);

    /* Compute the mask to access the bitfield.  */
!   unsigned_type = (*lang_hooks.types.type_for_size) (*pbitsize, 1);
    precision = TYPE_PRECISION (unsigned_type);

    mask = build_int_2 (~0, ~0);
--- 3074,3080 ----
      *punsignedp = TREE_UNSIGNED (outer_type);

    /* Compute the mask to access the bitfield.  */
!   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
    precision = TYPE_PRECISION (unsigned_type);

    mask = build_int_2 (~0, ~0);
*************** all_ones_mask_p (tree mask, int size)
*** 3104,3110 ****
    tree tmask;

    tmask = build_int_2 (~0, ~0);
!   TREE_TYPE (tmask) = (*lang_hooks.types.signed_type) (type);
    force_fit_type (tmask, 0);
    return
      tree_int_cst_equal (mask,
--- 3104,3110 ----
    tree tmask;

    tmask = build_int_2 (~0, ~0);
!   TREE_TYPE (tmask) = lang_hooks.types.signed_type (type);
    force_fit_type (tmask, 0);
    return
      tree_int_cst_equal (mask,
*************** make_range (tree exp, int *pin_p, tree *
*** 3497,3503 ****
  	     be interpreted as positive.  */
  	  if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
  	    {
! 	      tree equiv_type = (*lang_hooks.types.type_for_mode)
  		(TYPE_MODE (type), 1);
  	      tree high_positive;

--- 3497,3503 ----
  	     be interpreted as positive.  */
  	  if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
  	    {
! 	      tree equiv_type = lang_hooks.types.type_for_mode
  		(TYPE_MODE (type), 1);
  	      tree high_positive;

*************** build_range_check (tree type, tree exp,
*** 3598,3604 ****
      {
        if (! TREE_UNSIGNED (etype))
  	{
! 	  etype = (*lang_hooks.types.unsigned_type) (etype);
  	  high = fold_convert (etype, high);
  	  exp = fold_convert (etype, exp);
  	}
--- 3598,3604 ----
      {
        if (! TREE_UNSIGNED (etype))
  	{
! 	  etype = lang_hooks.types.unsigned_type (etype);
  	  high = fold_convert (etype, high);
  	  exp = fold_convert (etype, exp);
  	}
*************** build_range_check (tree type, tree exp,
*** 3628,3634 ****
  	{
  	  if (TREE_UNSIGNED (etype))
  	    {
! 	      etype = (*lang_hooks.types.signed_type) (etype);
  	      exp = fold_convert (etype, exp);
  	    }
  	  return fold (build (GT_EXPR, type, exp,
--- 3628,3634 ----
  	{
  	  if (TREE_UNSIGNED (etype))
  	    {
! 	      etype = lang_hooks.types.signed_type (etype);
  	      exp = fold_convert (etype, exp);
  	    }
  	  return fold (build (GT_EXPR, type, exp,
*************** fold_range_test (tree exp)
*** 3833,3839 ****
  		      TREE_TYPE (exp), TREE_OPERAND (exp, 0),
  		      TREE_OPERAND (exp, 1));

!       else if ((*lang_hooks.decls.global_bindings_p) () == 0
  	       && ! CONTAINS_PLACEHOLDER_P (lhs))
  	{
  	  tree common = save_expr (lhs);
--- 3833,3839 ----
  		      TREE_TYPE (exp), TREE_OPERAND (exp, 0),
  		      TREE_OPERAND (exp, 1));

!       else if (lang_hooks.decls.global_bindings_p () == 0
  	       && ! CONTAINS_PLACEHOLDER_P (lhs))
  	{
  	  tree common = save_expr (lhs);
*************** unextend (tree c, int p, int unsignedp,
*** 3881,3887 ****
       zero or one, and the conversion to a signed type can never overflow.
       We could get an overflow if this conversion is done anywhere else.  */
    if (TREE_UNSIGNED (type))
!     temp = fold_convert ((*lang_hooks.types.signed_type) (type), temp);

    temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
    temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
--- 3881,3887 ----
       zero or one, and the conversion to a signed type can never overflow.
       We could get an overflow if this conversion is done anywhere else.  */
    if (TREE_UNSIGNED (type))
!     temp = fold_convert (lang_hooks.types.signed_type (type), temp);

    temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
    temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
*************** fold_truthop (enum tree_code code, tree
*** 4127,4133 ****

    /* After this point all optimizations will generate bit-field
       references, which we might not want.  */
!   if (! (*lang_hooks.can_use_bit_fields_p) ())
      return 0;

    /* See if we can find a mode that contains both fields being compared on
--- 4127,4133 ----

    /* After this point all optimizations will generate bit-field
       references, which we might not want.  */
!   if (! lang_hooks.can_use_bit_fields_p ())
      return 0;

    /* See if we can find a mode that contains both fields being compared on
*************** fold_truthop (enum tree_code code, tree
*** 4143,4149 ****

    lnbitsize = GET_MODE_BITSIZE (lnmode);
    lnbitpos = first_bit & ~ (lnbitsize - 1);
!   lntype = (*lang_hooks.types.type_for_size) (lnbitsize, 1);
    xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;

    if (BYTES_BIG_ENDIAN)
--- 4143,4149 ----

    lnbitsize = GET_MODE_BITSIZE (lnmode);
    lnbitpos = first_bit & ~ (lnbitsize - 1);
!   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
    xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;

    if (BYTES_BIG_ENDIAN)
*************** fold_truthop (enum tree_code code, tree
*** 4214,4220 ****

        rnbitsize = GET_MODE_BITSIZE (rnmode);
        rnbitpos = first_bit & ~ (rnbitsize - 1);
!       rntype = (*lang_hooks.types.type_for_size) (rnbitsize, 1);
        xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;

        if (BYTES_BIG_ENDIAN)
--- 4214,4220 ----

        rnbitsize = GET_MODE_BITSIZE (rnmode);
        rnbitpos = first_bit & ~ (rnbitsize - 1);
!       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
        xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;

        if (BYTES_BIG_ENDIAN)
*************** constant_boolean_node (int value, tree t
*** 4787,4794 ****
    if (type == integer_type_node)
      return value ? integer_one_node : integer_zero_node;
    else if (TREE_CODE (type) == BOOLEAN_TYPE)
!     return (*lang_hooks.truthvalue_conversion) (value ? integer_one_node :
! 						integer_zero_node);
    else
      {
        tree t = build_int_2 (value, 0);
--- 4787,4794 ----
    if (type == integer_type_node)
      return value ? integer_one_node : integer_zero_node;
    else if (TREE_CODE (type) == BOOLEAN_TYPE)
!     return lang_hooks.truthvalue_conversion (value ? integer_one_node
! 						   : integer_zero_node);
    else
      {
        tree t = build_int_2 (value, 0);
*************** fold_binary_op_with_conditional_arg (enu
*** 4920,4926 ****
      save = 1;
    else if (lhs == 0 && rhs == 0
  	   && !TREE_CONSTANT (arg)
! 	   && (*lang_hooks.decls.global_bindings_p) () == 0
  	   && ((TREE_CODE (arg) != VAR_DECL && TREE_CODE (arg) != PARM_DECL)
  	       || TREE_SIDE_EFFECTS (arg)))
      {
--- 4920,4926 ----
      save = 1;
    else if (lhs == 0 && rhs == 0
  	   && !TREE_CONSTANT (arg)
! 	   && lang_hooks.decls.global_bindings_p () == 0
  	   && ((TREE_CODE (arg) != VAR_DECL && TREE_CODE (arg) != PARM_DECL)
  	       || TREE_SIDE_EFFECTS (arg)))
      {
*************** fold_mathfn_compare (enum built_in_funct
*** 5095,5101 ****
  				    build_real (TREE_TYPE (arg), dconst0)));

  	      /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
! 	      if ((*lang_hooks.decls.global_bindings_p) () != 0
  		  || CONTAINS_PLACEHOLDER_P (arg))
  		return NULL_TREE;

--- 5095,5101 ----
  				    build_real (TREE_TYPE (arg), dconst0)));

  	      /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
! 	      if (lang_hooks.decls.global_bindings_p () != 0
  		  || CONTAINS_PLACEHOLDER_P (arg))
  		return NULL_TREE;

*************** fold_mathfn_compare (enum built_in_funct
*** 5115,5121 ****
  				build_real (TREE_TYPE (arg), c2)));

  	  /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
! 	  if ((*lang_hooks.decls.global_bindings_p) () == 0
  	      && ! CONTAINS_PLACEHOLDER_P (arg))
  	    {
  	      arg = save_expr (arg);
--- 5115,5121 ----
  				build_real (TREE_TYPE (arg), c2)));

  	  /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
! 	  if (lang_hooks.decls.global_bindings_p () == 0
  	      && ! CONTAINS_PLACEHOLDER_P (arg))
  	    {
  	      arg = save_expr (arg);
*************** fold_inf_compare (enum tree_code code, t
*** 5176,5182 ****
  				 arg0);

        /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
!       if ((*lang_hooks.decls.global_bindings_p) () == 0
  	  && ! CONTAINS_PLACEHOLDER_P (arg0))
  	{
  	  arg0 = save_expr (arg0);
--- 5176,5182 ----
  				 arg0);

        /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
!       if (lang_hooks.decls.global_bindings_p () == 0
  	  && ! CONTAINS_PLACEHOLDER_P (arg0))
  	{
  	  arg0 = save_expr (arg0);
*************** fold_single_bit_test (enum tree_code cod
*** 5257,5263 ****
        arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
        if (arg00 != NULL_TREE)
  	{
! 	  tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
  	  return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, result_type,
  			      fold_convert (stype, arg00),
  			      fold_convert (stype, integer_zero_node)));
--- 5257,5263 ----
        arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
        if (arg00 != NULL_TREE)
  	{
! 	  tree stype = lang_hooks.types.signed_type (TREE_TYPE (arg00));
  	  return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, result_type,
  			      fold_convert (stype, arg00),
  			      fold_convert (stype, integer_zero_node)));
*************** fold_single_bit_test (enum tree_code cod
*** 5293,5300 ****
        ops_unsigned = 1;
  #endif

!       signed_type = (*lang_hooks.types.type_for_mode) (operand_mode, 0);
!       unsigned_type = (*lang_hooks.types.type_for_mode) (operand_mode, 1);
        intermediate_type = ops_unsigned ? unsigned_type : signed_type;
        inner = fold_convert (intermediate_type, inner);

--- 5293,5300 ----
        ops_unsigned = 1;
  #endif

!       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
!       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
        intermediate_type = ops_unsigned ? unsigned_type : signed_type;
        inner = fold_convert (intermediate_type, inner);

*************** fold (tree expr)
*** 5609,5615 ****
  	       && (TREE_CODE (arg0) != COND_EXPR
  		   || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
  	       && (! TREE_SIDE_EFFECTS (arg0)
! 		   || ((*lang_hooks.decls.global_bindings_p) () == 0
  		       && ! CONTAINS_PLACEHOLDER_P (arg0))))
  	return
  	  fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
--- 5609,5615 ----
  	       && (TREE_CODE (arg0) != COND_EXPR
  		   || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
  	       && (! TREE_SIDE_EFFECTS (arg0)
! 		   || (lang_hooks.decls.global_bindings_p () == 0
  		       && ! CONTAINS_PLACEHOLDER_P (arg0))))
  	return
  	  fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
*************** fold (tree expr)
*** 5623,5629 ****
  	       && (TREE_CODE (arg1) != COND_EXPR
  		   || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
  	       && (! TREE_SIDE_EFFECTS (arg1)
! 		   || ((*lang_hooks.decls.global_bindings_p) () == 0
  		       && ! CONTAINS_PLACEHOLDER_P (arg1))))
  	return
  	  fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
--- 5623,5629 ----
  	       && (TREE_CODE (arg1) != COND_EXPR
  		   || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
  	       && (! TREE_SIDE_EFFECTS (arg1)
! 		   || (lang_hooks.decls.global_bindings_p () == 0
  		       && ! CONTAINS_PLACEHOLDER_P (arg1))))
  	return
  	  fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
*************** fold (tree expr)
*** 5784,5790 ****
  		  && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
  		      == ZERO_EXTEND))
  		{
! 		  tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
  		  and0 = fold_convert (uns, and0);
  		  and1 = fold_convert (uns, and1);
  		}
--- 5784,5790 ----
  		  && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
  		      == ZERO_EXTEND))
  		{
! 		  tree uns = lang_hooks.types.unsigned_type (TREE_TYPE (and0));
  		  and0 = fold_convert (uns, and0);
  		  and1 = fold_convert (uns, and1);
  		}
*************** fold (tree expr)
*** 7544,7551 ****
  		if (code == LE_EXPR || code == GT_EXPR)
  		  {
  		    tree st0, st1;
! 		    st0 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg0));
! 		    st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
  		    return fold
  		      (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
  			      type, fold_convert (st0, arg0),
--- 7544,7551 ----
  		if (code == LE_EXPR || code == GT_EXPR)
  		  {
  		    tree st0, st1;
! 		    st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
! 		    st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
  		    return fold
  		      (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
  			      type, fold_convert (st0, arg0),
*************** fold (tree expr)
*** 7668,7674 ****
  	      || TREE_CODE (arg0) == ROUND_MOD_EXPR)
  	  && integer_pow2p (TREE_OPERAND (arg0, 1)))
  	{
! 	  tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
  	  tree newmod = build (TREE_CODE (arg0), newtype,
  			       fold_convert (newtype,
  					     TREE_OPERAND (arg0, 0)),
--- 7668,7674 ----
  	      || TREE_CODE (arg0) == ROUND_MOD_EXPR)
  	  && integer_pow2p (TREE_OPERAND (arg0, 1)))
  	{
! 	  tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
  	  tree newmod = build (TREE_CODE (arg0), newtype,
  			       fold_convert (newtype,
  					     TREE_OPERAND (arg0, 0)),
*************** fold (tree expr)
*** 7895,7901 ****

        /* If this is a comparison of a field, we may be able to simplify it.  */
        if (((TREE_CODE (arg0) == COMPONENT_REF
! 	    && (*lang_hooks.can_use_bit_fields_p) ())
  	   || TREE_CODE (arg0) == BIT_FIELD_REF)
  	  && (code == EQ_EXPR || code == NE_EXPR)
  	  /* Handle the constant case even without -O
--- 7895,7901 ----

        /* If this is a comparison of a field, we may be able to simplify it.  */
        if (((TREE_CODE (arg0) == COMPONENT_REF
! 	    && lang_hooks.can_use_bit_fields_p ())
  	   || TREE_CODE (arg0) == BIT_FIELD_REF)
  	  && (code == EQ_EXPR || code == NE_EXPR)
  	  /* Handle the constant case even without -O
*************** fold (tree expr)
*** 8045,8051 ****

        TREE_TYPE (t1) = type;
        if (TREE_CODE (type) == BOOLEAN_TYPE)
! 	return (*lang_hooks.truthvalue_conversion) (t1);
        return t1;

      case COND_EXPR:
--- 8045,8051 ----

        TREE_TYPE (t1) = type;
        if (TREE_CODE (type) == BOOLEAN_TYPE)
! 	return lang_hooks.truthvalue_conversion (t1);
        return t1;

      case COND_EXPR:
*************** fold (tree expr)
*** 8115,8128 ****
  	      case GE_EXPR:
  	      case GT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
! 		  arg1 = fold_convert ((*lang_hooks.types.signed_type)
  				       (TREE_TYPE (arg1)), arg1);
  		arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
  		return pedantic_non_lvalue (fold_convert (type, arg1));
  	      case LE_EXPR:
  	      case LT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
! 		  arg1 = fold_convert ((lang_hooks.types.signed_type)
  				       (TREE_TYPE (arg1)), arg1);
  		arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
  		arg1 = negate_expr (fold_convert (type, arg1));
--- 8115,8128 ----
  	      case GE_EXPR:
  	      case GT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
! 		  arg1 = fold_convert (lang_hooks.types.signed_type
  				       (TREE_TYPE (arg1)), arg1);
  		arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
  		return pedantic_non_lvalue (fold_convert (type, arg1));
  	      case LE_EXPR:
  	      case LT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
! 		  arg1 = fold_convert (lang_hooks.types.signed_type
  				       (TREE_TYPE (arg1)), arg1);
  		arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
  		arg1 = negate_expr (fold_convert (type, arg1));


Roger
--
Roger Sayle,                         E-mail: roger@eyesopen.com
OpenEye Scientific Software,         WWW: http://www.eyesopen.com/
Suite 1107, 3600 Cerrillos Road,     Tel: (+1) 505-473-7385
Santa Fe, New Mexico, 87507.         Fax: (+1) 505-473-0833


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