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 + + * 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 + + * 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 @@ } /* 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 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 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