rpms/gcc
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

4.3.2-1

Browse Source
This commit is contained in:
Jakub Jelinek 2008-08-29 11:35:32 +00:00
parent b10732a3ee
commit e41a249027
6 changed files with 559 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.cvsignore
View File

@ -1,2 +1,2 @@
gcc-4.3.1-20080825.tar.bz2 gcc-4.3.2-20080829.tar.bz2
fastjar-0.95.tar.gz fastjar-0.95.tar.gz

456
gcc43-fortran-debug10.patch Normal file
View File

@ -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;

73
gcc43-fortran-debug11.patch Normal file
View File

@ -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));

5
gcc43-pr37248.patch
View File

@ -266,7 +266,7 @@
/* Subroutine for fold: determine if VAL is the INTEGER_CONST that /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
represents the sign bit of EXP's type. If EXP represents a sign represents the sign bit of EXP's type. If EXP represents a sign
or zero extension, also test VAL against the unextended type. 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; tree ll_inner, lr_inner, rl_inner, rr_inner;
HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos; HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos; HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
@ -287,6 +287,7 @@
+ HOST_WIDE_INT first_bit, end_bit; + HOST_WIDE_INT first_bit, end_bit;
int volatilep; int volatilep;
tree orig_lhs = lhs, orig_rhs = rhs; tree orig_lhs = lhs, orig_rhs = rhs;
enum tree_code orig_code = code;
@@ -5510,6 +5730,118 @@ fold_truthop (enum tree_code code, tree @@ -5510,6 +5730,118 @@ fold_truthop (enum tree_code code, tree
} }
} }
@ -427,7 +428,7 @@
} }
/* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a /* 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); return omit_one_operand (type, rslt, arg0);
} }

29
gcc43.spec
View File

@ -1,6 +1,6 @@
%define DATE 20080825 %define DATE 20080829
%define gcc_version 4.3.1 %define gcc_version 4.3.2
%define gcc_release 8 %define gcc_release 1
%define _unpackaged_files_terminate_build 0 %define _unpackaged_files_terminate_build 0
%define multilib_64_archs sparc64 ppc64 s390x x86_64 %define multilib_64_archs sparc64 ppc64 s390x x86_64
%define include_gappletviewer 1 %define include_gappletviewer 1
@ -152,6 +152,9 @@ Patch22: gcc43-fortran-debug6.patch
Patch23: gcc43-fortran-debug7.patch Patch23: gcc43-fortran-debug7.patch
Patch24: gcc43-fortran-debug8.patch Patch24: gcc43-fortran-debug8.patch
Patch25: gcc43-fortran-debug9.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 # On ARM EABI systems, we do want -gnueabi to be part of the
# target triple. # target triple.
@ -461,6 +464,9 @@ which are required to run programs compiled with the GNAT.
%patch23 -p0 -b .fortran-debug7~ %patch23 -p0 -b .fortran-debug7~
%patch24 -p0 -b .fortran-debug8~ %patch24 -p0 -b .fortran-debug8~
%patch25 -p0 -b .fortran-debug9~ %patch25 -p0 -b .fortran-debug9~
%patch26 -p0 -b .fortran-debug10~
%patch27 -p0 -b .fortran-debug11~
%patch28 -p0 -b .pr37248~
tar xzf %{SOURCE4} tar xzf %{SOURCE4}
@ -468,7 +474,7 @@ tar xzf %{SOURCE4}
tar xjf %{SOURCE10} tar xjf %{SOURCE10}
%endif %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 echo 'Red Hat %{version}-%{gcc_release}' > gcc/DEV-PHASE
cp -a libstdc++-v3/config/cpu/i{4,3}86/atomicity.h 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/ppc-asm.h
%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/include/altivec.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/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 %endif
%{_prefix}/libexec/gcc/%{gcc_target_platform}/%{gcc_version}/collect2 %{_prefix}/libexec/gcc/%{gcc_target_platform}/%{gcc_version}/collect2
%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/crt*.o %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_version}/crt*.o
@ -1682,6 +1692,17 @@ fi
%doc rpm.doc/changelogs/libmudflap/ChangeLog* %doc rpm.doc/changelogs/libmudflap/ChangeLog*
%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 * Mon Aug 25 2008 Jakub Jelinek <jakub@redhat.com> 4.3.1-8
- update from gcc-4_3-branch - update from gcc-4_3-branch
- PRs debug/37156, libgcj/8995, libstdc++/37100, target/37101 - PRs debug/37156, libgcj/8995, libstdc++/37100, target/37101

2
sources
View File

@ -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 92a70f9e56223b653bce0f58f90cf950 fastjar-0.95.tar.gz