[rpms/gcc] rhel-f41-base: 4.3.2-1

[Jakub Jelinek <jakub@fedoraproject.org>]

A new commit has been pushed.

Repo   : rpms/gcc
Branch : rhel-f41-base
Commit : e41a24902722794559542b86372111c4c6757d5e
Author : Jakub Jelinek <jakub@fedoraproject.org>
Date   : 2008-08-29T11:35:32+00:00
Stats  : +559/-8 in 6 file(s)
URL    : https://src.fedoraproject.org/rpms/gcc/c/e41a24902722794559542b86372111c4c6757d5e?branch=rhel-f41-base

Log:
4.3.2-1

---
diff --git a/.cvsignore b/.cvsignore
index 2196ff1..0435ab0 100644
--- a/.cvsignore
+++ b/.cvsignore
@@ -1,2 +1,2 @@
-gcc-4.3.1-20080825.tar.bz2
+gcc-4.3.2-20080829.tar.bz2
 fastjar-0.95.tar.gz

diff --git a/gcc43-fortran-debug10.patch b/gcc43-fortran-debug10.patch
new file mode 100644
index 0000000..d446519
--- /dev/null
+++ b/gcc43-fortran-debug10.patch
@@ -0,0 +1,456 @@
+2008-08-26  Jakub Jelinek  <jakub@redhat.com>
+
+	* dwarf2out.c (gen_const_die): New function.
+	(size_of_die, value_format, output_die): Output larger
+	dw_val_class_vec using DW_FORM_block2 or DW_FORM_block4.
+	(native_encode_initializer): New function.
+	(tree_add_const_value_attribute): Call it.
+	(gen_decl_die, dwarf2out_decl): Handle CONST_DECLs if is_fortran ().
+
+	* trans-decl.c (check_constant_initializer,
+	gfc_emit_parameter_debug_info): New functions.
+	(gfc_generate_module_vars, gfc_generate_function_code): Emit
+	PARAMETERs and unreferenced variables with initializers into
+	debug info.
+
+--- gcc/fortran/trans-decl.c.jj	2008-08-26 21:43:36.000000000 +0200
++++ gcc/fortran/trans-decl.c	2008-08-26 22:54:24.000000000 +0200
+@@ -3232,6 +3232,135 @@ gfc_trans_use_stmts (gfc_namespace * ns)
+ }
+ 
+ 
++/* Return true if expr is a constant initializer that gfc_conv_initializer
++   will handle.  */
++
++static bool
++check_constant_initializer (gfc_expr *expr, gfc_typespec *ts, bool array,
++			    bool pointer)
++{
++  gfc_constructor *c;
++  gfc_component *cm;
++
++  if (pointer)
++    return true;
++  else if (array)
++    {
++      if (expr->expr_type == EXPR_CONSTANT || expr->expr_type == EXPR_NULL)
++	return true;
++      else if (expr->expr_type == EXPR_STRUCTURE)
++	return check_constant_initializer (expr, ts, false, false);
++      else if (expr->expr_type != EXPR_ARRAY)
++	return false;
++      for (c = expr->value.constructor; c; c = c->next)
++	{
++	  if (c->iterator)
++	    return false;
++	  if (c->expr->expr_type == EXPR_STRUCTURE)
++	    {
++	      if (!check_constant_initializer (c->expr, ts, false, false))
++		return false;
++	    }
++	  else if (c->expr->expr_type != EXPR_CONSTANT)
++	    return false;
++	}
++      return true;
++    }
++  else switch (ts->type)
++    {
++    case BT_DERIVED:
++      if (expr->expr_type != EXPR_STRUCTURE)
++	return false;
++      cm = expr->ts.derived->components;
++      for (c = expr->value.constructor; c; c = c->next, cm = cm->next)
++	{
++	  if (!c->expr || cm->allocatable)
++	    continue;
++	  if (!check_constant_initializer (c->expr, &cm->ts,
++					   cm->dimension,
++					   cm->pointer))
++	    return false;
++	}
++      return true;
++    default:
++      return expr->expr_type == EXPR_CONSTANT;
++    }
++}
++
++/* Emit debug info for parameters and unreferenced variables with
++   initializers.  */
++
++static void
++gfc_emit_parameter_debug_info (gfc_symbol *sym)
++{
++  tree decl;
++
++  if (sym->attr.flavor != FL_PARAMETER
++      && (sym->attr.flavor != FL_VARIABLE || sym->attr.referenced))
++    return;
++
++  if (sym->backend_decl != NULL
++      || sym->value == NULL
++      || sym->attr.use_assoc
++      || sym->attr.dummy
++      || sym->attr.result
++      || sym->attr.function
++      || sym->attr.intrinsic
++      || sym->attr.pointer
++      || sym->attr.allocatable
++      || sym->attr.cray_pointee
++      || sym->attr.threadprivate
++      || sym->attr.is_bind_c
++      || sym->attr.subref_array_pointer
++      || sym->attr.assign)
++    return;
++
++  if (sym->ts.type == BT_CHARACTER)
++    {
++      gfc_conv_const_charlen (sym->ts.cl);
++      if (sym->ts.cl->backend_decl == NULL
++	  || TREE_CODE (sym->ts.cl->backend_decl) != INTEGER_CST)
++	return;
++    }
++  else if (sym->ts.type == BT_DERIVED && sym->ts.derived->attr.alloc_comp)
++    return;
++
++  if (sym->as)
++    {
++      int n;
++
++      if (sym->as->type != AS_EXPLICIT)
++	return;
++      for (n = 0; n < sym->as->rank; n++)
++	if (sym->as->lower[n]->expr_type != EXPR_CONSTANT
++	    || sym->as->upper[n] == NULL
++	    || sym->as->upper[n]->expr_type != EXPR_CONSTANT)
++	  return;
++    }
++
++  if (!check_constant_initializer (sym->value, &sym->ts,
++				   sym->attr.dimension, false))
++    return;
++
++  /* Create the decl for the variable or constant.  */
++  decl = build_decl (sym->attr.flavor == FL_PARAMETER ? CONST_DECL : VAR_DECL,
++		     gfc_sym_identifier (sym), gfc_sym_type (sym));
++  if (sym->attr.flavor == FL_PARAMETER)
++    TREE_READONLY (decl) = 1;
++  gfc_set_decl_location (decl, &sym->declared_at);
++  if (sym->attr.dimension)
++    GFC_DECL_PACKED_ARRAY (decl) = 1;
++  DECL_CONTEXT (decl) = sym->ns->proc_name->backend_decl;
++  TREE_STATIC (decl) = 1;
++  TREE_USED (decl) = 1;
++  if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
++    TREE_PUBLIC (decl) = 1;
++  DECL_INITIAL (decl)
++    = gfc_conv_initializer (sym->value, &sym->ts, TREE_TYPE (decl),
++			    sym->attr.dimension, 0);
++  debug_hooks->global_decl (decl);
++}
++
+ /* Generate all the required code for module variables.  */
+ 
+ void
+@@ -3252,6 +3381,7 @@ gfc_generate_module_vars (gfc_namespace 
+   cur_module = NULL;
+ 
+   gfc_trans_use_stmts (ns);
++  gfc_traverse_ns (ns, gfc_emit_parameter_debug_info);
+ }
+ 
+ 
+@@ -3787,6 +3917,7 @@ gfc_generate_function_code (gfc_namespac
+     }
+ 
+   gfc_trans_use_stmts (ns);
++  gfc_traverse_ns (ns, gfc_emit_parameter_debug_info);
+ }
+ 
+ void
+--- gcc/dwarf2out.c.jj	2008-08-26 21:43:31.000000000 +0200
++++ gcc/dwarf2out.c	2008-08-26 21:43:42.000000000 +0200
+@@ -5093,6 +5093,7 @@ static void gen_unspecified_parameters_d
+ static void gen_formal_types_die (tree, dw_die_ref);
+ static void gen_subprogram_die (tree, dw_die_ref);
+ static void gen_variable_die (tree, dw_die_ref);
++static void gen_const_die (tree, dw_die_ref);
+ static void gen_label_die (tree, dw_die_ref);
+ static void gen_lexical_block_die (tree, dw_die_ref, int);
+ static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
+@@ -7564,8 +7565,10 @@ size_of_die (dw_die_ref die)
+ 	  size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
+ 	  break;
+ 	case dw_val_class_vec:
+-	  size += 1 + (a->dw_attr_val.v.val_vec.length
+-		       * a->dw_attr_val.v.val_vec.elt_size); /* block */
++	  size += constant_size (a->dw_attr_val.v.val_vec.length
++				 * a->dw_attr_val.v.val_vec.elt_size)
++		  + a->dw_attr_val.v.val_vec.length
++		    * a->dw_attr_val.v.val_vec.elt_size; /* block */
+ 	  break;
+ 	case dw_val_class_flag:
+ 	  size += 1;
+@@ -7764,7 +7767,18 @@ value_format (dw_attr_ref a)
+     case dw_val_class_long_long:
+       return DW_FORM_block1;
+     case dw_val_class_vec:
+-      return DW_FORM_block1;
++      switch (constant_size (a->dw_attr_val.v.val_vec.length
++			     * a->dw_attr_val.v.val_vec.elt_size))
++	{
++	case 1:
++	  return DW_FORM_block1;
++	case 2:
++	  return DW_FORM_block2;
++	case 4:
++	  return DW_FORM_block4;
++	default:
++	  gcc_unreachable ();
++	}
+     case dw_val_class_flag:
+       return DW_FORM_flag;
+     case dw_val_class_die_ref:
+@@ -8056,7 +8070,8 @@ output_die (dw_die_ref die)
+ 	    unsigned int i;
+ 	    unsigned char *p;
+ 
+-	    dw2_asm_output_data (1, len * elt_size, "%s", name);
++	    dw2_asm_output_data (constant_size (len * elt_size),
++				 len * elt_size, "%s", name);
+ 	    if (elt_size > sizeof (HOST_WIDE_INT))
+ 	      {
+ 		elt_size /= 2;
+@@ -11762,6 +11777,150 @@ add_location_or_const_value_attribute (d
+   tree_add_const_value_attribute (die, decl);
+ }
+ 
++/* Helper function for tree_add_const_value_attribute.  Natively encode
++   initializer INIT into an array.  Return true if successful.  */
++
++static bool
++native_encode_initializer (tree init, unsigned char *array, int size)
++{
++  tree type;
++
++  if (init == NULL_TREE)
++    return false;
++
++  STRIP_NOPS (init);
++  switch (TREE_CODE (init))
++    {
++    case STRING_CST:
++      type = TREE_TYPE (init);
++      if (TREE_CODE (type) == ARRAY_TYPE)
++	{
++	  tree enttype = TREE_TYPE (type);
++	  enum machine_mode mode = TYPE_MODE (enttype);
++
++	  if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
++	    return false;
++	  if (int_size_in_bytes (type) != size)
++	    return false;
++	  if (size > TREE_STRING_LENGTH (init))
++	    {
++	      memcpy (array, TREE_STRING_POINTER (init),
++		      TREE_STRING_LENGTH (init));
++	      memset (array + TREE_STRING_LENGTH (init),
++		      '\0', size - TREE_STRING_LENGTH (init));
++	    }
++	  else
++	    memcpy (array, TREE_STRING_POINTER (init), size);
++	  return true;
++	}
++      return false;
++    case CONSTRUCTOR:
++      type = TREE_TYPE (init);
++      if (int_size_in_bytes (type) != size)
++	return false;
++      if (TREE_CODE (type) == ARRAY_TYPE)
++	{
++	  HOST_WIDE_INT min_index;
++	  unsigned HOST_WIDE_INT cnt;
++	  int curpos = 0, fieldsize;
++	  constructor_elt *ce;
++
++	  if (TYPE_DOMAIN (type) == NULL_TREE
++	      || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
++	    return false;
++
++	  fieldsize = int_size_in_bytes (TREE_TYPE (type));
++	  if (fieldsize <= 0)
++	    return false;
++
++	  min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
++	  memset (array, '\0', size);
++	  for (cnt = 0;
++	       VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
++	       cnt++)
++	    {
++	      tree val = ce->value;
++	      tree index = ce->index;
++	      int pos = curpos;
++	      if (index && TREE_CODE (index) == RANGE_EXPR)
++		pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
++		      * fieldsize;
++	      else if (index)
++		pos = tree_low_cst (index, 0) * fieldsize;
++
++	      if (val)
++		{
++		  STRIP_NOPS (val);
++		  if (!native_encode_initializer (val, array + pos, fieldsize))
++		    return false;
++		}
++	      curpos = pos + fieldsize;
++	      if (index && TREE_CODE (index) == RANGE_EXPR)
++		{
++		  int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
++			      - tree_low_cst (TREE_OPERAND (index, 0), 0);
++		  while (count > 0)
++		    {
++		      if (val)
++			memcpy (array + curpos, array + pos, fieldsize);
++		      curpos += fieldsize;
++		    }
++		}
++	      gcc_assert (curpos <= size);
++	    }
++	  return true;
++	}
++      else if (TREE_CODE (type) == RECORD_TYPE
++	       || TREE_CODE (type) == UNION_TYPE)
++	{
++	  tree field = NULL_TREE;
++	  unsigned HOST_WIDE_INT cnt;
++	  constructor_elt *ce;
++
++	  if (int_size_in_bytes (type) != size)
++	    return false;
++
++	  if (TREE_CODE (type) == RECORD_TYPE)
++	    field = TYPE_FIELDS (type);
++
++	  for (cnt = 0;
++	       VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
++	       cnt++, field = field ? TREE_CHAIN (field) : 0)
++	    {
++	      tree val = ce->value;
++	      int pos, fieldsize;
++
++	      if (ce->index != 0)
++		field = ce->index;
++
++	      if (val)
++		STRIP_NOPS (val);
++
++	      if (field == NULL_TREE || DECL_BIT_FIELD (field))
++		return false;
++
++	      if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
++		  && TYPE_DOMAIN (TREE_TYPE (field))
++		  && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
++		return false;
++	      else if (DECL_SIZE_UNIT (field) == NULL_TREE
++		       || !host_integerp (DECL_SIZE_UNIT (field), 0))
++		return false;
++	      fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
++	      pos = int_byte_position (field);
++	      gcc_assert (pos + fieldsize <= size);
++	      if (val
++		  && !native_encode_initializer (val, array + pos, fieldsize))
++		return false;
++	    }
++	  return true;
++	}
++      return false;
++    default:
++      return native_encode_expr (init, array, size) == size;
++    }
++}
++
+ /* If we don't have a copy of this variable in memory for some reason (such
+    as a C++ member constant that doesn't have an out-of-line definition),
+    we should tell the debugger about the constant value.  */
+@@ -11781,6 +11940,18 @@ tree_add_const_value_attribute (dw_die_r
+   rtl = rtl_for_decl_init (init, type);
+   if (rtl)
+     add_const_value_attribute (var_die, rtl);
++  /* If the host and target are sane, try harder.  */
++  else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8)
++    {
++      HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
++      if (size > 0 && (int) size == size)
++	{
++	  unsigned char *array = GGC_CNEWVEC (unsigned char, size);
++
++	  if (native_encode_initializer (init, array, size))
++	    add_AT_vec (var_die, DW_AT_const_value, size, 1, array);
++	}
++    }
+ }
+ 
+ /* Convert the CFI instructions for the current function into a
+@@ -13743,6 +13914,24 @@ gen_variable_die (tree decl, dw_die_ref 
+     tree_add_const_value_attribute (var_die, decl);
+ }
+ 
++/* Generate a DIE to represent a named constant.  */
++
++static void
++gen_const_die (tree decl, dw_die_ref context_die)
++{
++  dw_die_ref const_die;
++  tree type = TREE_TYPE (decl);
++
++  const_die = new_die (DW_TAG_constant, context_die, decl);
++  add_name_and_src_coords_attributes (const_die, decl);
++  add_type_attribute (const_die, type, 1, 0, context_die);
++  if (TREE_PUBLIC (decl))
++    add_AT_flag (const_die, DW_AT_external, 1);
++  if (DECL_ARTIFICIAL (decl))
++    add_AT_flag (const_die, DW_AT_artificial, 1);
++  tree_add_const_value_attribute (const_die, decl);
++}
++
+ /* Generate a DIE to represent a label identifier.  */
+ 
+ static void
+@@ -14883,8 +15072,20 @@ gen_decl_die (tree decl, dw_die_ref cont
+       break;
+ 
+     case CONST_DECL:
+-      /* The individual enumerators of an enum type get output when we output
+-	 the Dwarf representation of the relevant enum type itself.  */
++      if (!is_fortran ())
++	{
++	  /* The individual enumerators of an enum type get output when we output
++	     the Dwarf representation of the relevant enum type itself.  */
++	  break;
++	}
++
++      /* Emit its type.  */
++      gen_type_die (TREE_TYPE (decl), context_die);
++
++      /* And its containing namespace.  */
++      context_die = declare_in_namespace (decl, context_die);
++
++      gen_const_die (decl, context_die);
+       break;
+ 
+     case FUNCTION_DECL:
+@@ -15229,6 +15430,15 @@ dwarf2out_decl (tree decl)
+ 	return;
+       break;
+ 
++    case CONST_DECL:
++      if (debug_info_level <= DINFO_LEVEL_TERSE)
++	return;
++      if (!is_fortran ())
++	return;
++      if (TREE_STATIC (decl) && decl_function_context (decl))
++	context_die = lookup_decl_die (DECL_CONTEXT (decl));
++      break;
++
+     case NAMESPACE_DECL:
+       if (debug_info_level <= DINFO_LEVEL_TERSE)
+ 	return;

diff --git a/gcc43-fortran-debug11.patch b/gcc43-fortran-debug11.patch
new file mode 100644
index 0000000..73ec57b
--- /dev/null
+++ b/gcc43-fortran-debug11.patch
@@ -0,0 +1,73 @@
+2008-08-28  Jakub Jelinek  <jakub@redhat.com>
+
+	* dwarf2out.c (descr_info_loc): Handle VAR_DECL.
+
+	* trans.h (struct lang_type): Add span.
+	(GFC_TYPE_ARRAY_SPAN): Define.
+	* trans-decl.c (gfc_get_symbol_decl): For subref array pointers,
+	copy TREE_STATIC from decl to span instead of setting it
+	unconditionally, set DECL_ARTIFICIAL, fix type of initializer
+	and set GFC_TYPE_ARRAY_SPAN on decl's type.
+	* trans-types.c (gfc_get_array_descr_info): If
+	GFC_TYPE_ARRAY_SPAN is non-NULL, use it as element size.
+
+--- gcc/fortran/trans.h.jj	2008-08-26 21:43:04.000000000 +0200
++++ gcc/fortran/trans.h	2008-08-28 09:58:01.000000000 +0200
+@@ -605,6 +605,7 @@ struct lang_type		GTY(())
+   tree offset;
+   tree dtype;
+   tree dataptr_type;
++  tree span;
+ };
+ 
+ struct lang_decl		GTY(())
+@@ -657,6 +658,7 @@ struct lang_decl		GTY(())
+ #define GFC_TYPE_ARRAY_DTYPE(node) (TYPE_LANG_SPECIFIC(node)->dtype)
+ #define GFC_TYPE_ARRAY_DATAPTR_TYPE(node) \
+   (TYPE_LANG_SPECIFIC(node)->dataptr_type)
++#define GFC_TYPE_ARRAY_SPAN(node) (TYPE_LANG_SPECIFIC(node)->span)
+ 
+ /* Build an expression with void type.  */
+ #define build1_v(code, arg) build1(code, void_type_node, arg)
+--- gcc/fortran/trans-decl.c.jj	2008-08-26 22:54:24.000000000 +0200
++++ gcc/fortran/trans-decl.c	2008-08-28 10:54:28.000000000 +0200
+@@ -1105,10 +1105,12 @@ gfc_get_symbol_decl (gfc_symbol * sym)
+       span = build_decl (VAR_DECL, create_tmp_var_name ("span"),
+ 			 gfc_array_index_type);
+       gfc_finish_var_decl (span, sym);
+-      TREE_STATIC (span) = 1;
+-      DECL_INITIAL (span) = build_int_cst (NULL_TREE, 0);
++      TREE_STATIC (span) = TREE_STATIC (decl);
++      DECL_ARTIFICIAL (span) = 1;
++      DECL_INITIAL (span) = build_int_cst (gfc_array_index_type, 0);
+ 
+       GFC_DECL_SPAN (decl) = span;
++      GFC_TYPE_ARRAY_SPAN (TREE_TYPE (decl)) = span;
+     }
+ 
+   sym->backend_decl = decl;
+--- gcc/fortran/trans-types.c.jj	2008-08-26 21:43:04.000000000 +0200
++++ gcc/fortran/trans-types.c	2008-08-28 10:23:39.000000000 +0200
+@@ -2289,7 +2289,10 @@ gfc_get_array_descr_info (const_tree typ
+   else
+     info->base_decl = base_decl = build_decl (VAR_DECL, NULL_TREE, ptype);
+ 
+-  elem_size = fold_convert (gfc_array_index_type, TYPE_SIZE_UNIT (etype));
++  if (GFC_TYPE_ARRAY_SPAN (type))
++    elem_size = GFC_TYPE_ARRAY_SPAN (type);
++  else
++    elem_size = fold_convert (gfc_array_index_type, TYPE_SIZE_UNIT (etype));
+   field = TYPE_FIELDS (TYPE_MAIN_VARIANT (type));
+   data_off = byte_position (field);
+   field = TREE_CHAIN (field);
+--- gcc/dwarf2out.c.jj	2008-08-26 21:43:42.000000000 +0200
++++ gcc/dwarf2out.c	2008-08-28 10:35:38.000000000 +0200
+@@ -12232,6 +12232,8 @@ descr_info_loc (tree val, tree base_decl
+     case NOP_EXPR:
+     case CONVERT_EXPR:
+       return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
++    case VAR_DECL:
++      return loc_descriptor_from_tree_1 (val, 0);
+     case INTEGER_CST:
+       if (host_integerp (val, 0))
+ 	return int_loc_descriptor (tree_low_cst (val, 0));

diff --git a/gcc43-pr37248.patch b/gcc43-pr37248.patch
index 9b2cf39..310da34 100644
--- a/gcc43-pr37248.patch
+++ b/gcc43-pr37248.patch
@@ -266,7 +266,7 @@
  /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
     represents the sign bit of EXP's type.  If EXP represents a sign
     or zero extension, also test VAL against the unextended type.
-@@ -5264,15 +5484,15 @@ fold_truthop (enum tree_code code, tree 
+@@ -5264,16 +5484,16 @@ fold_truthop (enum tree_code code, tree 
    tree ll_inner, lr_inner, rl_inner, rr_inner;
    HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
    HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
@@ -287,6 +287,7 @@
 +  HOST_WIDE_INT first_bit, end_bit;
    int volatilep;
    tree orig_lhs = lhs, orig_rhs = rhs;
+   enum tree_code orig_code = code;
 @@ -5510,6 +5730,118 @@ fold_truthop (enum tree_code code, tree 
  	}
      }
@@ -427,7 +428,7 @@
  }
  \f
  /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
-@@ -11914,6 +12258,18 @@ fold_binary (enum tree_code code, tree t
+@@ -11912,6 +12256,18 @@ fold_binary (enum tree_code code, tree t
  	    return omit_one_operand (type, rslt, arg0);
  	}
  

diff --git a/gcc43.spec b/gcc43.spec
index 8c99a85..8adc2ed 100644
--- a/gcc43.spec
+++ b/gcc43.spec
@@ -1,6 +1,6 @@
-%define DATE 20080825
-%define gcc_version 4.3.1
-%define gcc_release 8
+%define DATE 20080829
+%define gcc_version 4.3.2
+%define gcc_release 1
 %define _unpackaged_files_terminate_build 0
 %define multilib_64_archs sparc64 ppc64 s390x x86_64
 %define include_gappletviewer 1
@@ -152,6 +152,9 @@ Patch22: gcc43-fortran-debug6.patch
 Patch23: gcc43-fortran-debug7.patch
 Patch24: gcc43-fortran-debug8.patch
 Patch25: gcc43-fortran-debug9.patch
+Patch26: gcc43-fortran-debug10.patch
+Patch27: gcc43-fortran-debug11.patch
+Patch28: gcc43-pr37248.patch
 
 # On ARM EABI systems, we do want -gnueabi to be part of the
 # target triple.
@@ -461,6 +464,9 @@ which are required to run programs compiled with the GNAT.
 %patch23 -p0 -b .fortran-debug7~
 %patch24 -p0 -b .fortran-debug8~
 %patch25 -p0 -b .fortran-debug9~
+%patch26 -p0 -b .fortran-debug10~
+%patch27 -p0 -b .fortran-debug11~
+%patch28 -p0 -b .pr37248~
 
 tar xzf %{SOURCE4}
 
@@ -468,7 +474,7 @@ tar xzf %{SOURCE4}
 tar xjf %{SOURCE10}
 %endif
 
-sed -i -e 's/4\.3\.2/4.3.1/' gcc/BASE-VER
+sed -i -e 's/4\.3\.3/4.3.2/' gcc/BASE-VER
 echo 'Red Hat %{version}-%{gcc_release}' > gcc/DEV-PHASE
 
 cp -a libstdc++-v3/config/cpu/i{4,3}86/atomicity.h
@@ -1272,6 +1278,10 @@ fi
 %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/ppc-asm.h
 %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/altivec.h
 %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/spe.h
+%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/paired.h
+%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/ppu_intrinsics.h
+%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/si2vmx.h
+%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/spu2vmx.h
 %endif
 %{_prefix}/libexec/gcc/%{gcc_target_platform}/%{gcc_version}/collect2
 %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/crt*.o
@@ -1682,6 +1692,17 @@ fi
 %doc rpm.doc/changelogs/libmudflap/ChangeLog*
 
 %changelog
+* Fri Aug 29 2008 Jakub Jelinek <jakub@redhat.com> 4.3.2-1
+- update from gcc-4_3-branch
+  - 4.3.2 release
+  - PRs c++/36741, middle-end/36548, middle-end/36817, middle-end/37125,
+	target/37184, target/37191, target/37197
+- backport further Fortran debuginfo improvements (#460378, #459375)
+- revert removal of adjacent bitfield comparison
+  optimization (PR middle-end/37248)
+- on ppc/ppc64 add paired.h, ppu_instrinsics.h, si2vmx.h and spu2vmx.h
+  headers (#460497)
+
 * Mon Aug 25 2008 Jakub Jelinek <jakub@redhat.com> 4.3.1-8
 - update from gcc-4_3-branch
   - PRs debug/37156, libgcj/8995, libstdc++/37100, target/37101

diff --git a/sources b/sources
index 7ff1b3f..bcc8a35 100644
--- a/sources
+++ b/sources
@@ -1,2 +1,2 @@
-13550eec00d2563c42d1879e1f8f3407  gcc-4.3.1-20080825.tar.bz2
+69f70d92142466361146326f840a6185  gcc-4.3.2-20080829.tar.bz2
 92a70f9e56223b653bce0f58f90cf950  fastjar-0.95.tar.gz