Changeset ca9d9fb5 for patches

Timestamp:

Jun 5, 2009, 8:56:57 PM (15 years ago)

Author:

Jim Gifford <clfs@…>

Branches:

clfs-1.2, clfs-2.1, clfs-3.0.0-systemd, clfs-3.0.0-sysvinit, master, systemd, sysvinit

Children:

b057cfe

Parents:

d8bd081

Message:

Updated GCC Branch Update Patch to -2

File:

• patches/gcc-4.4.0-branch_update-2.patch (moved) (moved from patches/gcc-4.4.0-branch_update-1.patch ) (60 diffs)

patches/gcc-4.4.0-branch_update-2.patch

@@ -1 +1 @@
 Submitted By: Jim Gifford (jim at cross-lfs dot org)
-Date: 04-29-2009
+Date: 06-05-2009
 Initial Package Version: 4.4.0
 Origin: Upstream
@@ -62 +62 @@
  # Allow host libstdc++ to be specified for static linking with PPL.
  AC_ARG_WITH(host-libstdcxx, [  --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
-diff -Naur gcc-4.4.0.orig/contrib/ChangeLog gcc-4.4.0/contrib/ChangeLog
---- gcc-4.4.0.orig/contrib/ChangeLog    2009-04-21 01:47:54.000000000 -0700
-+++ gcc-4.4.0/contrib/ChangeLog 2009-04-27 12:13:16.000000000 -0700
-@@ -1,3 +1,12 @@
-+2009-04-27  Jakub Jelinek  <jakub@redhat.com>
-+
-+       PR testsuite/39807
-+       * dg-extract-results.sh: Close open files and use >> instead of >
-+       to decrease number of concurrently open files from awk.  Avoid
-+       = at the beginning of a regexp and redirect to a file determined
-+       by curfile variable rather than concatenated strings to workaround
-+       Solaris nawk bug.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
 diff -Naur gcc-4.4.0.orig/contrib/dg-extract-results.sh gcc-4.4.0/contrib/dg-extract-results.sh
 --- gcc-4.4.0.orig/contrib/dg-extract-results.sh        2008-10-24 02:00:54.000000000 -0700
@@ -290 +274 @@
    if (! base_alias_check (x_addr, mem_addr, GET_MODE (x), mem_mode))
      return 0;
-diff -Naur gcc-4.4.0.orig/gcc/ChangeLog gcc-4.4.0/gcc/ChangeLog
---- gcc-4.4.0.orig/gcc/ChangeLog        2009-04-21 01:44:59.000000000 -0700
-+++ gcc-4.4.0/gcc/ChangeLog     2009-04-28 21:57:17.000000000 -0700
-@@ -1,3 +1,143 @@
-+2009-04-29  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
-+
-+       * toplev.c (print_version): Update GMP version string calculation.
-+
-+2009-04-28  H.J. Lu  <hongjiu.lu@intel.com>
-+
-+       Backport from mainline:
-+       2009-04-27  H.J. Lu  <hongjiu.lu@intel.com>
-+
-+       PR target/39903
-+       * config/i386/i386.c (construct_container): Don't call
-+       gen_reg_or_parallel with BLKmode on X86_64_SSE_CLASS,
-+       X86_64_SSESF_CLASS and X86_64_SSEDF_CLASS.
-+
-+2009-04-27  Jakub Jelinek  <jakub@redhat.com>
-+
-+       PR rtl-optimization/39794
-+       * alias.c (canon_true_dependence): Add x_addr argument.
-+       * rtl.h (canon_true_dependence): Adjust prototype.
-+       * cse.c (check_dependence): Adjust canon_true_dependence callers.
-+       * cselib.c (cselib_invalidate_mem): Likewise.
-+       * gcse.c (compute_transp): Likewise.
-+       * dse.c (scan_reads_nospill): Likewise.
-+       (record_store, check_mem_read_rtx): Likewise.  For non-const-or-frame
-+       addresses pass base->val_rtx as mem_addr, for const-or-frame addresses
-+       canon_base_addr of the group, plus optional offset.
-+       (struct group_info): Rename canon_base_mem to
-+       canon_base_addr.
-+       (get_group_info): Set canon_base_addr to canon_rtx of base, not
-+       canon_rtx of base_mem.
-+
-+2009-04-26  Jakub Jelinek  <jakub@redhat.com>
-+
-+       PR inline-asm/39543
-+       * fwprop.c (forward_propagate_asm): New function.
-+       (forward_propagate_and_simplify): Propagate also into __asm, if it
-+       doesn't increase the number of referenced registers.
-+
-+       PR c/39889
-+       * stmt.c (warn_if_unused_value): Look through NON_LVALUE_EXPR.
-+
-+2009-04-24  Andreas Krebbel  <krebbel1@de.ibm.com>
-+
-+       * config/s390/constraints.md ('I', 'J'): Fix condition.
-+
-+2009-04-24  Paolo Bonzini  <bonzini@gnu.org>
-+
-+       PR middle-end/39867
-+       * fold-const.c (fold_cond_expr_with_comparison): When folding
-+       > and >= to MAX, make sure the MAX uses the same type as the
-+       comparison's operands.
-+
-+2009-04-23  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       * config/spu/spu-builtins.h: Delete file.
-+
-+       * config/spu/spu.h (enum spu_builtin_type): Move here from
-+       spu-builtins.h.
-+       (struct spu_builtin_description): Likewise.  Add GTY marker.
-+       Do not use enum spu_function_code or enum insn_code.
-+       (spu_builtins): Add extern declaration.
-+
-+       * config/spu/spu.c: Do not include "spu-builtins.h".
-+       (enum spu_function_code, enum spu_builtin_type_index,
-+       V16QI_type_node, V8HI_type_node, V4SI_type_node, V2DI_type_node,
-+       V4SF_type_node, V2DF_type_node, unsigned_V16QI_type_node,
-+       unsigned_V8HI_type_node, unsigned_V4SI_type_node,
-+       unsigned_V2DI_type_node): Move here from spu-builtins.h.
-+       (spu_builtin_types): Make static.  Add GTY marker.
-+       (spu_builtins): Add extern declaration with GTY marker.
-+       Include "gt-spu.h".
-+
-+       * config/spu/spu-c.c: Do not include "spu-builtins.h".
-+       (spu_resolve_overloaded_builtin): Do not use spu_function_code.
-+       Check programmatically whether all parameters are scalar.
-+
-+       * config/spu/t-spu-elf (spu.o, spu-c.o): Update dependencies.
-+
-+2009-04-22  Jing Yu  <jingyu@google.com>
-+
-+       PR testsuite/39781
-+       * config/arm/arm.h: Define HANDLE_PRAGMA_PACK_PUSH_POP.
-+
-+2009-04-22  Eric Botcazou  <ebotcazou@adacore.com>
-+
-+       Backport from mainline:
-+       2009-04-17  Eric Botcazou  <ebotcazou@adacore.com>
-+       * dbxout.c (dbxout_block): Reinstate test on TREE_USED.
-+       * tree-ssa-live.c (remove_unused_scope_block_p): Update TREE_USED bit.
-+
-+2009-04-22  Jakub Jelinek  <jakub@redhat.com>
-+
-+       * alias.c (find_base_term): Move around LO_SUM case, so that
-+       CONST falls through into PLUS/MINUS handling.
-+
-+       PR c/39855
-+       * fold-const.c (fold_binary) <case LSHIFT_EXPR>: When optimizing
-+       into 0, use omit_one_operand.
-+
-+2009-04-22  Vladimir Makarov  <vmakarov@redhat.com>
-+
-+       PR rtl-optimization/39762
-+       * ira-int.h (ira_register_move_cost, ira_may_move_in_cost,
-+       ira_may_move_out_cost): Add comments about way of their usage.
-+       (ira_get_register_move_cost, ira_get_may_move_cost): New functions.
-+
-+       * ira-conflicts.c (process_regs_for_copy): Use function
-+       ira_get_register_move_cost instead of global
-+       ira_register_move_cost.
-+
-+       * ira-color.c (update_copy_costs, calculate_allocno_spill_cost,
-+       color_pass, move_spill_restore, update_curr_costs): Ditto.
-+
-+       * ira-lives.c (process_single_reg_class_operands): Ditto.
-+
-+       * ira-emit.c (emit_move_list): Ditto.
-+
-+       * ira-costs.c (copy_cost): Don't call ira_init_register_move_cost.
-+       (record_reg_classes): Ditto.  Use functions
-+       ira_get_register_move_cost and ira_get_may_move_cost instead of
-+       global vars ira_register_move_cost, ira_may_move_out_cost and
-+       ira_may_move_in_cost.
-+       (record_address_regs): Don't call ira_init_register_move_cost.
-+       Use function ira_get_may_move_cost instead of global
-+       ira_may_move_in_cost.
-+       (process_bb_node_for_hard_reg_moves): Use function
-+       ira_get_register_move_cost instead of global ira_register_move_cost.
-+       (ira_costs): Don't call ira_init_register_move_cost.
-+
-+2009-04-22  Richard Guenther  <rguenther@suse.de>
-+
-+       PR tree-optimization/39824
-+       * tree-ssa-ccp.c (fold_const_aggregate_ref): For INDIRECT_REFs
-+       make sure the types are compatible.
-+
-+2009-04-21  Jakub Jelinek  <jakub@redhat.com>
-+
-+       * BASE-VER: Set to 4.4.1.
-+       * DEV-PHASE: Set to prerelease.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
+diff -Naur gcc-4.4.0.orig/gcc/builtins.c gcc-4.4.0/gcc/builtins.c
+--- gcc-4.4.0.orig/gcc/builtins.c       2009-03-30 10:42:27.000000000 -0700
++++ gcc-4.4.0/gcc/builtins.c    2009-05-29 08:47:31.000000000 -0700
+@@ -4176,7 +4176,7 @@
+ 
+     arg1_rtx = get_memory_rtx (arg1, len);
+     arg2_rtx = get_memory_rtx (arg2, len);
+-    arg3_rtx = expand_normal (len);
++    arg3_rtx = expand_normal (fold_convert (sizetype, len));
+ 
+     /* Set MEM_SIZE as appropriate.  */
+     if (GET_CODE (arg3_rtx) == CONST_INT)
+diff -Naur gcc-4.4.0.orig/gcc/cfgrtl.c gcc-4.4.0/gcc/cfgrtl.c
+--- gcc-4.4.0.orig/gcc/cfgrtl.c 2008-12-12 13:16:09.000000000 -0800
++++ gcc-4.4.0/gcc/cfgrtl.c      2009-05-21 16:17:37.000000000 -0700
+@@ -53,6 +53,7 @@
+ #include "toplev.h"
+ #include "tm_p.h"
+ #include "obstack.h"
++#include "insn-attr.h"
+ #include "insn-config.h"
+ #include "cfglayout.h"
+ #include "expr.h"
+@@ -427,13 +428,27 @@
+   return 0;
+ }
+ 
++static unsigned int
++rest_of_pass_free_cfg (void)
++{
++#ifdef DELAY_SLOTS
++  /* The resource.c machinery uses DF but the CFG isn't guaranteed to be
++     valid at that point so it would be too late to call df_analyze.  */
++  if (optimize > 0 && flag_delayed_branch)
++    df_analyze ();
++#endif
++
++  free_bb_for_insn ();
++  return 0;
++}
++
+ struct rtl_opt_pass pass_free_cfg =
+ {
+  {
+   RTL_PASS,
+   NULL,                                 /* name */
+   NULL,                                 /* gate */
+-  free_bb_for_insn,                     /* execute */
++  rest_of_pass_free_cfg,                /* execute */
+   NULL,                                 /* sub */
+   NULL,                                 /* next */
+   0,                                    /* static_pass_number */
+diff -Naur gcc-4.4.0.orig/gcc/config/arm/arm.c gcc-4.4.0/gcc/config/arm/arm.c
+--- gcc-4.4.0.orig/gcc/config/arm/arm.c 2009-02-24 23:18:01.000000000 -0800
++++ gcc-4.4.0/gcc/config/arm/arm.c      2009-06-02 00:18:16.000000000 -0700
+@@ -16883,7 +16883,7 @@
+ 
+   if (push && pushed_words && dwarf2out_do_frame ())
+     {
+-      char *l = dwarf2out_cfi_label ();
++      char *l = dwarf2out_cfi_label (false);
+       int pushed_mask = real_regs;
+ 
+       *cfa_offset += pushed_words * 4;
+@@ -17781,7 +17781,7 @@
+         the stack pointer.  */
+       if (dwarf2out_do_frame ())
+        {
+-         char *l = dwarf2out_cfi_label ();
++         char *l = dwarf2out_cfi_label (false);
+ 
+          cfa_offset = cfa_offset + crtl->args.pretend_args_size;
+          dwarf2out_def_cfa (l, SP_REGNUM, cfa_offset);
+@@ -17830,7 +17830,7 @@
+ 
+       if (dwarf2out_do_frame ())
+        {
+-         char *l = dwarf2out_cfi_label ();
++         char *l = dwarf2out_cfi_label (false);
+ 
+          cfa_offset = cfa_offset + 16;
+          dwarf2out_def_cfa (l, SP_REGNUM, cfa_offset);
 diff -Naur gcc-4.4.0.orig/gcc/config/arm/arm.h gcc-4.4.0/gcc/config/arm/arm.h
 --- gcc-4.4.0.orig/gcc/config/arm/arm.h 2009-03-17 13:18:21.000000000 -0700
@@ -452 +371 @@
  /* Specify the machine mode that this machine uses
     for the index in the tablejump instruction.  */
+diff -Naur gcc-4.4.0.orig/gcc/config/arm/arm.md gcc-4.4.0/gcc/config/arm/arm.md
+--- gcc-4.4.0.orig/gcc/config/arm/arm.md        2009-04-04 05:25:06.000000000 -0700
++++ gcc-4.4.0/gcc/config/arm/arm.md     2009-05-16 06:28:27.000000000 -0700
+@@ -8214,7 +8214,7 @@
+ 
+ (define_insn "cstoresi_nltu_thumb1"
+   [(set (match_operand:SI 0 "s_register_operand" "=l,l")
+-        (neg:SI (gtu:SI (match_operand:SI 1 "s_register_operand" "l,*h")
++        (neg:SI (ltu:SI (match_operand:SI 1 "s_register_operand" "l,*h")
+                        (match_operand:SI 2 "thumb1_cmp_operand" "lI*h,*r"))))]
+   "TARGET_THUMB1"
+   "cmp\\t%1, %2\;sbc\\t%0, %0, %0"
+diff -Naur gcc-4.4.0.orig/gcc/config/i386/driver-i386.c gcc-4.4.0/gcc/config/i386/driver-i386.c
+--- gcc-4.4.0.orig/gcc/config/i386/driver-i386.c        2008-11-04 05:29:43.000000000 -0800
++++ gcc-4.4.0/gcc/config/i386/driver-i386.c     2009-05-27 07:54:00.000000000 -0700
+@@ -336,7 +336,11 @@
+ enum vendor_signatures
+ {
+   SIG_INTEL =  0x756e6547 /* Genu */,
+-  SIG_AMD =    0x68747541 /* Auth */,
++  SIG_AMD =    0x68747541 /* Auth */
++};
++
++enum processor_signatures
++{
+   SIG_GEODE =  0x646f6547 /* Geod */
+ };
+ 
+@@ -374,6 +378,9 @@
+   /* Extended features */
+   unsigned int has_lahf_lm = 0, has_sse4a = 0;
+   unsigned int has_longmode = 0, has_3dnowp = 0, has_3dnow = 0;
++  unsigned int has_sse4_1 = 0, has_sse4_2 = 0;
++  unsigned int has_popcnt = 0, has_aes = 0, has_avx = 0;
++  unsigned int has_pclmul = 0;
+ 
+   bool arch;
+ 
+@@ -397,7 +404,13 @@
+ 
+   has_sse3 = ecx & bit_SSE3;
+   has_ssse3 = ecx & bit_SSSE3;
++  has_sse4_1 = ecx & bit_SSE4_1;
++  has_sse4_2 = ecx & bit_SSE4_2;
++  has_avx = ecx & bit_AVX;
+   has_cmpxchg16b = ecx & bit_CMPXCHG16B;
++  has_popcnt = ecx & bit_POPCNT;
++  has_aes = ecx & bit_AES;
++  has_pclmul = ecx & bit_PCLMUL;
+ 
+   has_cmpxchg8b = edx & bit_CMPXCHG8B;
+   has_cmov = edx & bit_CMOV;
+@@ -433,19 +446,27 @@
+ 
+   if (vendor == SIG_AMD)
+     {
+-      processor = PROCESSOR_PENTIUM;
++      unsigned int name;
+ 
+-      if (has_mmx)
+-       processor = PROCESSOR_K6;
+-      if (has_3dnowp)
+-       processor = PROCESSOR_ATHLON;
+-      if (has_sse2 || has_longmode)
+-       processor = PROCESSOR_K8;
+-      if (has_sse4a)
++      /* Detect geode processor by its processor signature.  */
++      if (ext_level > 0x80000001)
++       __cpuid (0x80000002, name, ebx, ecx, edx);
++      else
++       name = 0;
++
++      if (name == SIG_GEODE)
++       processor = PROCESSOR_GEODE;
++      else if (has_sse4a)
+        processor = PROCESSOR_AMDFAM10;
++      else if (has_sse2 || has_longmode)
++       processor = PROCESSOR_K8;
++      else if (has_3dnowp)
++       processor = PROCESSOR_ATHLON;
++      else if (has_mmx)
++       processor = PROCESSOR_K6;
++      else
++       processor = PROCESSOR_PENTIUM;
+     }
+-  else if (vendor == SIG_GEODE)
+-    processor = PROCESSOR_GEODE;
+   else
+     {
+       switch (family)
+@@ -576,6 +597,18 @@
+        options = concat (options, "-mcx16 ", NULL);
+       if (has_lahf_lm)
+        options = concat (options, "-msahf ", NULL);
++      if (has_aes)
++       options = concat (options, "-maes ", NULL);
++      if (has_pclmul)
++       options = concat (options, "-mpclmul ", NULL);
++      if (has_popcnt)
++       options = concat (options, "-mpopcnt ", NULL);
++      if (has_avx)
++       options = concat (options, "-mavx ", NULL);
++      else if (has_sse4_2)
++       options = concat (options, "-msse4.2 ", NULL);
++      else if (has_sse4_1)
++       options = concat (options, "-msse4.1 ", NULL);
+     }
+ 
+ done:
 diff -Naur gcc-4.4.0.orig/gcc/config/i386/i386.c gcc-4.4.0/gcc/config/i386/i386.c
 --- gcc-4.4.0.orig/gcc/config/i386/i386.c       2009-04-14 13:27:30.000000000 -0700
-+++ gcc-4.4.0/gcc/config/i386/i386.c    2009-04-28 07:35:12.000000000 -0700
++++ gcc-4.4.0/gcc/config/i386/i386.c    2009-05-25 05:13:38.000000000 -0700
 @@ -5357,7 +5357,10 @@
        case X86_64_SSE_CLASS:
@@ -467 +495 @@
        case X86_64_COMPLEX_X87_CLASS:
         return gen_rtx_REG (mode, FIRST_STACK_REG);
+@@ -7301,10 +7304,12 @@
+   cfun->machine->accesses_prev_frame = 1;
+ }
+ 
+
+-#if (defined(HAVE_GAS_HIDDEN) && (SUPPORTS_ONE_ONLY - 0)) || TARGET_MACHO
+-# define USE_HIDDEN_LINKONCE 1
+-#else
+-# define USE_HIDDEN_LINKONCE 0
++#ifndef USE_HIDDEN_LINKONCE
++# if (defined(HAVE_GAS_HIDDEN) && (SUPPORTS_ONE_ONLY - 0)) || TARGET_MACHO
++#  define USE_HIDDEN_LINKONCE 1
++# else
++#  define USE_HIDDEN_LINKONCE 0
++# endif
+ #endif
+ 
+ static int pic_labels_used;
+diff -Naur gcc-4.4.0.orig/gcc/config/i386/linux.h gcc-4.4.0/gcc/config/i386/linux.h
+--- gcc-4.4.0.orig/gcc/config/i386/linux.h      2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/config/i386/linux.h   2009-05-21 06:21:30.000000000 -0700
+@@ -153,7 +153,9 @@
+        fprintf ((FILE), "\t.p2align %d,,%d\n", (LOG), (MAX_SKIP));     \
+        /* Make sure that we have at least 8 byte alignment if > 8 byte \
+           alignment is preferred.  */                                  \
+-       if ((LOG) > 3 && (1 << (LOG)) > ((MAX_SKIP) + 1))               \
++       if ((LOG) > 3                                                   \
++           && (1 << (LOG)) > ((MAX_SKIP) + 1)                          \
++           && (MAX_SKIP) >= 7)                                         \
+          fprintf ((FILE), "\t.p2align 3\n");                           \
+       }                                                                        \
+     }                                                                  \
+diff -Naur gcc-4.4.0.orig/gcc/config/i386/sol2.h gcc-4.4.0/gcc/config/i386/sol2.h
+--- gcc-4.4.0.orig/gcc/config/i386/sol2.h       2008-09-09 09:17:37.000000000 -0700
++++ gcc-4.4.0/gcc/config/i386/sol2.h    2009-05-25 05:13:38.000000000 -0700
+@@ -1,6 +1,6 @@
+ /* Target definitions for GCC for Intel 80386 running Solaris 2
+    Copyright (C) 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
+-   2004, 2007, 2008 Free Software Foundation, Inc.
++   2004, 2007, 2008, 2009 Free Software Foundation, Inc.
+    Contributed by Fred Fish (fnf@cygnus.com).
+ 
+ This file is part of GCC.
+@@ -112,3 +112,9 @@
+ /* We do not need NT_VERSION notes.  */
+ #undef X86_FILE_START_VERSION_DIRECTIVE
+ #define X86_FILE_START_VERSION_DIRECTIVE false
++
++/* Only recent versions of Solaris 11 ld properly support hidden .gnu.linkonce
++   sections, so don't use them.  */
++#ifndef TARGET_GNU_LD
++#define USE_HIDDEN_LINKONCE 0
++#endif
+diff -Naur gcc-4.4.0.orig/gcc/config/i386/sse.md gcc-4.4.0/gcc/config/i386/sse.md
+--- gcc-4.4.0.orig/gcc/config/i386/sse.md       2009-03-12 10:43:14.000000000 -0700
++++ gcc-4.4.0/gcc/config/i386/sse.md    2009-05-06 06:20:41.000000000 -0700
+@@ -978,7 +978,7 @@
+          (match_operand:AVXMODEF2P 2 "nonimmediate_operand" "xm")))]
+   "AVX_VEC_FLOAT_MODE_P (<MODE>mode) && flag_finite_math_only
+    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
+-  "v<maxminfprefix>p<ssemodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
++  "v<maxminfprefix>p<avxmodesuffixf2c>\t{%2, %1, %0|%0, %1, %2}"
+   [(set_attr "type" "sseadd")
+    (set_attr "prefix" "vex")
+    (set_attr "mode" "<MODE>")])
+diff -Naur gcc-4.4.0.orig/gcc/config/i386/x86-64.h gcc-4.4.0/gcc/config/i386/x86-64.h
+--- gcc-4.4.0.orig/gcc/config/i386/x86-64.h     2009-04-09 16:23:07.000000000 -0700
++++ gcc-4.4.0/gcc/config/i386/x86-64.h  2009-05-21 06:21:30.000000000 -0700
+@@ -74,7 +74,9 @@
+        fprintf ((FILE), "\t.p2align %d,,%d\n", (LOG), (MAX_SKIP));     \
+        /* Make sure that we have at least 8 byte alignment if > 8 byte \
+           alignment is preferred.  */                                  \
+-       if ((LOG) > 3 && (1 << (LOG)) > ((MAX_SKIP) + 1))               \
++       if ((LOG) > 3                                                   \
++           && (1 << (LOG)) > ((MAX_SKIP) + 1)                          \
++           && (MAX_SKIP) >= 7)                                         \
+          fprintf ((FILE), "\t.p2align 3\n");                           \
+       }                                                                        \
+     }                                                                  \
+diff -Naur gcc-4.4.0.orig/gcc/config/m32c/m32c.c gcc-4.4.0/gcc/config/m32c/m32c.c
+--- gcc-4.4.0.orig/gcc/config/m32c/m32c.c       2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/config/m32c/m32c.c    2009-05-04 16:53:28.000000000 -0700
+@@ -417,6 +417,9 @@
+     }
+   else
+     target_memregs = 16;
++
++  if (TARGET_A24)
++    flag_ivopts = 0;
+ }
+ 
+ /* Defining data structures for per-function information */
+@@ -2043,6 +2046,31 @@
+       return 1;
+     }
+ 
++  /* If we see an RTX like (subreg:PSI (reg:SI ...)) we need to reload
++     the subreg.  We need to check for PLUS and non-PLUS cases.  */
++
++  if (GET_CODE (*x) == SUBREG
++      && GET_MODE (XEXP (*x, 0)) == SImode)
++    {
++      if (type == RELOAD_OTHER)
++       type = RELOAD_FOR_OTHER_ADDRESS;
++      push_reload (*x, NULL_RTX, x, NULL,
++                  A_REGS, Pmode, VOIDmode, 0, 0, opnum,
++                  type);
++      return 1;
++    }
++  if (GET_CODE (*x) == PLUS
++      && GET_CODE (XEXP (*x, 0)) == SUBREG
++      && GET_MODE (XEXP (XEXP (*x, 0), 0)) == SImode)
++    {
++      if (type == RELOAD_OTHER)
++       type = RELOAD_FOR_OTHER_ADDRESS;
++      push_reload (XEXP (*x, 0), NULL_RTX, &(XEXP (*x, 0)), NULL,
++                  A_REGS, Pmode, VOIDmode, 0, 0, opnum,
++                  type);
++      return 1;
++    }
++
+   return 0;
+ }
+ 
+diff -Naur gcc-4.4.0.orig/gcc/config/rs6000/rs6000-c.c gcc-4.4.0/gcc/config/rs6000/rs6000-c.c
+--- gcc-4.4.0.orig/gcc/config/rs6000/rs6000-c.c 2009-03-28 10:29:57.000000000 -0700
++++ gcc-4.4.0/gcc/config/rs6000/rs6000-c.c      2009-05-29 00:14:20.000000000 -0700
+@@ -91,6 +91,7 @@
+ static GTY(()) tree pixel_keyword;
+ static GTY(()) tree __bool_keyword;
+ static GTY(()) tree bool_keyword;
++static GTY(()) tree _Bool_keyword;
+ 
+ /* Preserved across calls.  */
+ static tree expand_bool_pixel;
+@@ -111,6 +112,9 @@
+       if (ident == C_CPP_HASHNODE (bool_keyword))
+        return C_CPP_HASHNODE (__bool_keyword);
+ 
++      if (ident == C_CPP_HASHNODE (_Bool_keyword))
++       return C_CPP_HASHNODE (__bool_keyword);
++
+       return ident;
+     }
+ 
+@@ -141,6 +145,9 @@
+ 
+   bool_keyword = get_identifier ("bool");
+   C_CPP_HASHNODE (bool_keyword)->flags |= NODE_CONDITIONAL;
++
++  _Bool_keyword = get_identifier ("_Bool");
++  C_CPP_HASHNODE (_Bool_keyword)->flags |= NODE_CONDITIONAL;
+ }
+ 
+ /* Called to decide whether a conditional macro should be expanded.
+@@ -295,6 +302,7 @@
+          builtin_define ("vector=vector");
+          builtin_define ("pixel=pixel");
+          builtin_define ("bool=bool");
++         builtin_define ("_Bool=_Bool");
+          init_vector_keywords ();
+ 
+          /* Enable context-sensitive macros.  */
 diff -Naur gcc-4.4.0.orig/gcc/config/s390/constraints.md gcc-4.4.0/gcc/config/s390/constraints.md
 --- gcc-4.4.0.orig/gcc/config/s390/constraints.md       2008-05-28 07:11:19.000000000 -0700
@@ -486 +677 @@
  
  (define_constraint "K"
+diff -Naur gcc-4.4.0.orig/gcc/config/sh/sh.c gcc-4.4.0/gcc/config/sh/sh.c
+--- gcc-4.4.0.orig/gcc/config/sh/sh.c   2009-03-25 15:23:27.000000000 -0700
++++ gcc-4.4.0/gcc/config/sh/sh.c        2009-05-24 15:18:47.000000000 -0700
+@@ -6908,6 +6908,8 @@
+ 
+   tmp = gen_frame_mem (Pmode, tmp);
+   emit_insn (GEN_MOV (tmp, ra));
++  /* Tell this store isn't dead.  */
++  emit_use (tmp);
+ }
+ 
+ /* Clear variables at function end.  */
+diff -Naur gcc-4.4.0.orig/gcc/config/sh/sh.md gcc-4.4.0/gcc/config/sh/sh.md
+--- gcc-4.4.0.orig/gcc/config/sh/sh.md  2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/config/sh/sh.md       2009-06-02 17:10:00.000000000 -0700
+@@ -3999,6 +3999,34 @@
+   [(set_attr "length" "4")
+    (set_attr "type" "arith")])
+ 
++;; Expander for DImode shift left with SImode operations.
++
++(define_expand "ashldi3_std"
++  [(set (match_operand:DI 0 "arith_reg_dest" "=r")
++       (ashift:DI (match_operand:DI 1 "arith_reg_operand" "r")
++                   (match_operand:DI 2 "const_int_operand" "n")))]
++  "TARGET_SH1 && INTVAL (operands[2]) < 32"
++  "
++{
++  int low_word = (TARGET_LITTLE_ENDIAN ? 0 : 1);
++  int high_word = (TARGET_LITTLE_ENDIAN ? 1 : 0);
++  rtx low_src = operand_subword (operands[1], low_word, 0, DImode);
++  rtx high_src = operand_subword (operands[1], high_word, 0, DImode);
++  rtx dst = gen_reg_rtx (DImode);
++  rtx low_dst = operand_subword (dst, low_word, 1, DImode);
++  rtx high_dst = operand_subword (dst, high_word, 1, DImode);
++  rtx tmp0, tmp1;
++
++  tmp0 = gen_reg_rtx (SImode);
++  tmp1 = gen_reg_rtx (SImode);
++  emit_insn (gen_lshrsi3 (tmp0, low_src, GEN_INT (32 - INTVAL (operands[2]))));
++  emit_insn (gen_ashlsi3 (low_dst, low_src, operands[2]));  
++  emit_insn (gen_ashlsi3 (tmp1, high_src, operands[2]));  
++  emit_insn (gen_iorsi3 (high_dst, tmp0, tmp1));
++  emit_move_insn (operands[0], dst);
++  DONE;
++}")
++
+ (define_insn "ashldi3_media"
+   [(set (match_operand:DI 0 "arith_reg_dest" "=r,r")
+        (ashift:DI (match_operand:DI 1 "arith_reg_operand" "r,r")
+@@ -4031,8 +4059,19 @@
+       emit_insn (gen_ashldi3_media (operands[0], operands[1], operands[2]));
+       DONE;
+     }
+-  if (GET_CODE (operands[2]) != CONST_INT
+-      || INTVAL (operands[2]) != 1)
++  if (GET_CODE (operands[2]) == CONST_INT
++      && INTVAL (operands[2]) == 1)
++    {
++      emit_insn (gen_ashldi3_k (operands[0], operands[1]));
++      DONE;
++    }
++  else if (GET_CODE (operands[2]) == CONST_INT
++      && INTVAL (operands[2]) < 32)
++    {
++      emit_insn (gen_ashldi3_std (operands[0], operands[1], operands[2]));
++      DONE;
++    }
++  else
+     FAIL;
+ }")
+ 
 diff -Naur gcc-4.4.0.orig/gcc/config/spu/spu-builtins.h gcc-4.4.0/gcc/config/spu/spu-builtins.h
 --- gcc-4.4.0.orig/gcc/config/spu/spu-builtins.h        2007-08-02 03:49:31.000000000 -0700
@@ -832 +1095 @@
      $(TM_P_H) c-pragma.h errors.h coretypes.h $(TM_H) insn-codes.h
         $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(srcdir)/config/spu/spu-c.c
+diff -Naur gcc-4.4.0.orig/gcc/config/vax/vax.c gcc-4.4.0/gcc/config/vax/vax.c
+--- gcc-4.4.0.orig/gcc/config/vax/vax.c 2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/config/vax/vax.c      2009-06-02 00:18:16.000000000 -0700
+@@ -122,7 +122,7 @@
+ 
+   if (dwarf2out_do_frame ())
+     {
+-      const char *label = dwarf2out_cfi_label ();
++      const char *label = dwarf2out_cfi_label (false);
+       int offset = 0;
+ 
+       for (regno = FIRST_PSEUDO_REGISTER-1; regno >= 0; --regno)
 diff -Naur gcc-4.4.0.orig/gcc/cp/call.c gcc-4.4.0/gcc/cp/call.c
 --- gcc-4.4.0.orig/gcc/cp/call.c        2009-04-13 13:56:45.000000000 -0700
-+++ gcc-4.4.0/gcc/cp/call.c     2009-04-23 04:13:57.000000000 -0700
-@@ -4069,8 +4069,20 @@
++++ gcc-4.4.0/gcc/cp/call.c     2009-06-03 11:11:53.000000000 -0700
+@@ -1384,9 +1384,37 @@
+   if (conv)
+     return conv;
+ 
+-  if (is_std_init_list (to) && expr
+-      && BRACE_ENCLOSED_INITIALIZER_P (expr))
+-    return build_list_conv (to, expr, flags);
++  if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
++    {
++      if (is_std_init_list (to))
++       return build_list_conv (to, expr, flags);
++
++      /* Allow conversion from an initializer-list with one element to a
++        scalar type.  */
++      if (SCALAR_TYPE_P (to))
++       {
++         int nelts = CONSTRUCTOR_NELTS (expr);
++         tree elt;
++
++         if (nelts == 0)
++           elt = integer_zero_node;
++         else if (nelts == 1)
++           elt = CONSTRUCTOR_ELT (expr, 0)->value;
++         else
++           elt = error_mark_node;
++
++         conv = implicit_conversion (to, TREE_TYPE (elt), elt,
++                                     c_cast_p, flags);
++         if (conv)
++           {
++             conv->check_narrowing = true;
++             if (BRACE_ENCLOSED_INITIALIZER_P (elt))
++               /* Too many levels of braces, i.e. '{{1}}'.  */
++               conv->bad_p = true;
++             return conv;
++           }
++       }
++    }
+ 
+   if (expr != NULL_TREE
+       && (MAYBE_CLASS_TYPE_P (from)
+@@ -4069,8 +4097,20 @@
         default:
           if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
@@ -858 +1174 @@
           result = error_mark_node;
           break;
-diff -Naur gcc-4.4.0.orig/gcc/cp/ChangeLog gcc-4.4.0/gcc/cp/ChangeLog
---- gcc-4.4.0.orig/gcc/cp/ChangeLog     2009-04-21 01:44:51.000000000 -0700
-+++ gcc-4.4.0/gcc/cp/ChangeLog  2009-04-23 04:13:57.000000000 -0700
-@@ -1,3 +1,22 @@
-+2009-04-23  Dodji Seketeli  <dodji@redhat.com>
-+
-+       PR c++/38228
-+       * pt.c (unify): Do not allow the result of a template argument
-+       deduction to be a METHOD_TYPE.
-+       * cvt.c (cp_convert): Report a meaningful error for non-valid use
-+       of pointer to member functions during conversions.
-+       * call.c (build_new_op): Report a meaningful error for non-valid
-+       use of pointer to member functions in binary expressions.
-+       * typeck.c (invalid_nonstatic_memfn_p): Do not crash when EXPR is
-+       NULL;
-+
-+2009-04-22  Dodji Seketeli  <dodji@redhat.com>
-+
-+       PR c++/39639
-+       * parser.c (cp_parser_template_argument_list): Display an error
-+       when an ellipsis is not preceded by a parameter pack. Also, warn
-+       about variadic templates usage without -std=c++0x.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
+@@ -4517,12 +4557,21 @@
+ 
+   if (convs->bad_p
+       && convs->kind != ck_user
++      && convs->kind != ck_list
+       && convs->kind != ck_ambig
+       && convs->kind != ck_ref_bind
+       && convs->kind != ck_rvalue
+       && convs->kind != ck_base)
+     {
+       conversion *t = convs;
++
++      /* Give a helpful error if this is bad because of excess braces.  */
++      if (BRACE_ENCLOSED_INITIALIZER_P (expr)
++         && SCALAR_TYPE_P (totype)
++         && CONSTRUCTOR_NELTS (expr) > 0
++         && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
++       permerror (input_location, "too many braces around initializer for %qT", totype);
++
+       for (; t; t = convs->u.next)
+        {
+          if (t->kind == ck_user || !t->bad_p)
+@@ -4596,6 +4645,17 @@
+        return expr;
+       }
+     case ck_identity:
++      if (BRACE_ENCLOSED_INITIALIZER_P (expr))
++       {
++         int nelts = CONSTRUCTOR_NELTS (expr);
++         if (nelts == 0)
++           expr = integer_zero_node;
++         else if (nelts == 1)
++           expr = CONSTRUCTOR_ELT (expr, 0)->value;
++         else
++           gcc_unreachable ();
++       }
++
+       if (type_unknown_p (expr))
+        expr = instantiate_type (totype, expr, complain);
+       /* Convert a constant to its underlying value, unless we are
 diff -Naur gcc-4.4.0.orig/gcc/cp/cvt.c gcc-4.4.0/gcc/cp/cvt.c
 --- gcc-4.4.0.orig/gcc/cp/cvt.c 2008-08-18 04:17:52.000000000 -0700
@@ -905 +1235 @@
  }
  
+diff -Naur gcc-4.4.0.orig/gcc/cp/decl.c gcc-4.4.0/gcc/cp/decl.c
+--- gcc-4.4.0.orig/gcc/cp/decl.c        2009-04-06 21:38:10.000000000 -0700
++++ gcc-4.4.0/gcc/cp/decl.c     2009-06-03 11:11:53.000000000 -0700
+@@ -5533,7 +5533,9 @@
+          TREE_TYPE (decl) = error_mark_node;
+          return;
+        }
+-      else if (describable_type (init))
++      if (TREE_CODE (init) == TREE_LIST)
++       init = build_x_compound_expr_from_list (init, "initializer");
++      if (describable_type (init))
+        {
+          type = TREE_TYPE (decl) = do_auto_deduction (type, init, auto_node);
+          if (type == error_mark_node)
 diff -Naur gcc-4.4.0.orig/gcc/cp/parser.c gcc-4.4.0/gcc/cp/parser.c
 --- gcc-4.4.0.orig/gcc/cp/parser.c      2009-04-10 12:01:16.000000000 -0700
@@ -923 +1267 @@
 diff -Naur gcc-4.4.0.orig/gcc/cp/pt.c gcc-4.4.0/gcc/cp/pt.c
 --- gcc-4.4.0.orig/gcc/cp/pt.c  2009-04-13 12:27:20.000000000 -0700
-+++ gcc-4.4.0/gcc/cp/pt.c       2009-04-23 04:13:57.000000000 -0700
-@@ -13532,6 +13532,13 @@
++++ gcc-4.4.0/gcc/cp/pt.c       2009-05-06 13:43:41.000000000 -0700
+@@ -9144,6 +9144,14 @@
+ 
+        max = tsubst_expr (omax, args, complain, in_decl,
+                           /*integral_constant_expression_p=*/false);
++
++       /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
++          needed.  */
++       if (TREE_CODE (max) == NOP_EXPR
++           && TREE_SIDE_EFFECTS (omax)
++           && !TREE_TYPE (max))
++         TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
++
+        max = fold_decl_constant_value (max);
+ 
+        /* If we're in a partial instantiation, preserve the magic NOP_EXPR
+@@ -9974,11 +9982,15 @@
+ 
+       if (r == NULL)
+        {
++         tree c;
+          /* This can happen for a parameter name used later in a function
+             declaration (such as in a late-specified return type).  Just
+             make a dummy decl, since it's only used for its type.  */
+          gcc_assert (skip_evaluation);   
+-         r = tsubst_decl (t, args, complain);
++         /* We copy T because want to tsubst the PARM_DECL only,
++            not the following PARM_DECLs that are chained to T.  */
++         c = copy_node (t);
++         r = tsubst_decl (c, args, complain);
+          /* Give it the template pattern as its context; its true context
+             hasn't been instantiated yet and this is good enough for
+             mangling.  */
+@@ -13532,6 +13544,13 @@
           && !template_parameter_pack_p (parm))
         return 1;
@@ -938 +1314 @@
        return 0;
  
+diff -Naur gcc-4.4.0.orig/gcc/cp/semantics.c gcc-4.4.0/gcc/cp/semantics.c
+--- gcc-4.4.0.orig/gcc/cp/semantics.c   2009-04-06 12:41:02.000000000 -0700
++++ gcc-4.4.0/gcc/cp/semantics.c        2009-05-17 13:34:30.000000000 -0700
+@@ -2838,16 +2838,16 @@
+                                                     done, address_p,
+                                                     template_p,
+                                                     template_arg_p);
+-                 else if (dependent_scope_p (scope))
+-                   decl = build_qualified_name (/*type=*/NULL_TREE,
+-                                                scope,
+-                                                id_expression,
+-                                                template_p);
+-                 else if (DECL_P (decl))
+-                   decl = build_qualified_name (TREE_TYPE (decl),
+-                                                scope,
+-                                                id_expression,
+-                                                template_p);
++                 else
++                   {
++                     tree type = NULL_TREE;
++                     if (DECL_P (decl) && !dependent_scope_p (scope))
++                       type = TREE_TYPE (decl);
++                     decl = build_qualified_name (type,
++                                                  scope,
++                                                  id_expression,
++                                                  template_p);
++                   }
+                }
+              if (TREE_TYPE (decl))
+                decl = convert_from_reference (decl);
 diff -Naur gcc-4.4.0.orig/gcc/cp/typeck.c gcc-4.4.0/gcc/cp/typeck.c
 --- gcc-4.4.0.orig/gcc/cp/typeck.c      2009-04-06 21:38:10.000000000 -0700
-+++ gcc-4.4.0/gcc/cp/typeck.c   2009-04-23 04:13:57.000000000 -0700
-@@ -1508,7 +1508,7 @@
++++ gcc-4.4.0/gcc/cp/typeck.c   2009-06-03 11:11:53.000000000 -0700
+@@ -260,6 +260,19 @@
+   enum tree_code code2 = TREE_CODE (t2);
+   tree attributes;
+ 
++  /* In what follows, we slightly generalize the rules given in [expr] so
++     as to deal with `long long' and `complex'.  First, merge the
++     attributes.  */
++  attributes = (*targetm.merge_type_attributes) (t1, t2);
++
++  if (SCOPED_ENUM_P (t1) || SCOPED_ENUM_P (t2))
++    {
++      if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
++       return build_type_attribute_variant (t1, attributes);
++      else
++       return NULL_TREE;
++    }
++
+   /* FIXME: Attributes.  */
+   gcc_assert (ARITHMETIC_TYPE_P (t1)
+              || TREE_CODE (t1) == VECTOR_TYPE
+@@ -268,11 +281,6 @@
+              || TREE_CODE (t2) == VECTOR_TYPE
+              || UNSCOPED_ENUM_P (t2));
+ 
+-  /* In what follows, we slightly generalize the rules given in [expr] so
+-     as to deal with `long long' and `complex'.  First, merge the
+-     attributes.  */
+-  attributes = (*targetm.merge_type_attributes) (t1, t2);
+-
+   /* If one type is complex, form the common type of the non-complex
+      components, then make that complex.  Use T1 or T2 if it is the
+      required type.  */
+@@ -1508,7 +1516,7 @@
  bool
  invalid_nonstatic_memfn_p (const_tree expr, tsubst_flags_t complain)
@@ -950 +1388 @@
        if (complain & tf_error)
          error ("invalid use of non-static member function");
+@@ -2437,6 +2445,10 @@
+ 
+   if (processing_template_decl)
+     {
++      /* Retain the type if we know the operand is a pointer so that
++        describable_type doesn't make auto deduction break.  */
++      if (TREE_TYPE (expr) && POINTER_TYPE_P (TREE_TYPE (expr)))
++       return build_min (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
+       if (type_dependent_expression_p (expr))
+        return build_min_nt (INDIRECT_REF, expr);
+       expr = build_non_dependent_expr (expr);
+@@ -3589,9 +3601,9 @@
+ 
+       build_type = boolean_type_node;
+       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
+-          || code0 == COMPLEX_TYPE)
++          || code0 == COMPLEX_TYPE || code0 == ENUMERAL_TYPE)
+          && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+-             || code1 == COMPLEX_TYPE))
++             || code1 == COMPLEX_TYPE || code1 == ENUMERAL_TYPE))
+        short_compare = 1;
+       else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
+               || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
+@@ -3863,9 +3875,10 @@
+       break;
+     }
+ 
+-  if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
++  if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
++       || code0 == ENUMERAL_TYPE)
+        && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+-          || code1 == COMPLEX_TYPE)))
++          || code1 == COMPLEX_TYPE || code1 == ENUMERAL_TYPE)))
+     arithmetic_types_p = 1;
+   else
+     {
+@@ -5967,8 +5980,11 @@
+ 
+   if (modifycode == INIT_EXPR)
+     {
+-      if (TREE_CODE (rhs) == CONSTRUCTOR)
++      if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
++       /* Do the default thing.  */;
++      else if (TREE_CODE (rhs) == CONSTRUCTOR)
+        {
++         /* Compound literal.  */
+          if (! same_type_p (TREE_TYPE (rhs), lhstype))
+            /* Call convert to generate an error; see PR 11063.  */
+            rhs = convert (lhstype, rhs);
 diff -Naur gcc-4.4.0.orig/gcc/cse.c gcc-4.4.0/gcc/cse.c
 --- gcc-4.4.0.orig/gcc/cse.c    2009-03-14 01:10:55.000000000 -0700
@@ -992 +1479 @@
 diff -Naur gcc-4.4.0.orig/gcc/DATESTAMP gcc-4.4.0/gcc/DATESTAMP
 --- gcc-4.4.0.orig/gcc/DATESTAMP        2009-04-20 17:16:42.000000000 -0700
-+++ gcc-4.4.0/gcc/DATESTAMP     2009-04-28 17:16:54.000000000 -0700
++++ gcc-4.4.0/gcc/DATESTAMP     2009-06-04 17:16:45.000000000 -0700
 @@ -1 +1 @@
 -20090421
-+20090429
++20090605
 diff -Naur gcc-4.4.0.orig/gcc/dbxout.c gcc-4.4.0/gcc/dbxout.c
 --- gcc-4.4.0.orig/gcc/dbxout.c 2009-02-27 11:49:42.000000000 -0800
@@ -1008 +1495 @@
           int did_output;
           int blocknum = BLOCK_NUMBER (block);
+diff -Naur gcc-4.4.0.orig/gcc/dfp.c gcc-4.4.0/gcc/dfp.c
+--- gcc-4.4.0.orig/gcc/dfp.c    2008-06-18 18:13:53.000000000 -0700
++++ gcc-4.4.0/gcc/dfp.c 2009-05-07 14:38:46.000000000 -0700
+@@ -1,5 +1,5 @@
+ /* Decimal floating point support.
+-   Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
++   Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ 
+ This file is part of GCC.
+ 
+@@ -132,6 +132,7 @@
+   decNumber dn;
+   decimal32 d32;
+   decContext set;
++  int32_t image;
+ 
+   decContextDefault (&set, DEC_INIT_DECIMAL128);
+   set.traps = 0;
+@@ -139,7 +140,8 @@
+   decimal_to_decnumber (r, &dn); 
+   decimal32FromNumber (&d32, &dn, &set);
+ 
+-  buf[0] = *(uint32_t *) d32.bytes;
++  memcpy (&image, d32.bytes, sizeof (int32_t));
++  buf[0] = image;
+ }
+ 
+ /* Decode an IEEE 754 decimal32 type into a real.  */
+@@ -151,11 +153,13 @@
+   decNumber dn;
+   decimal32 d32;
+   decContext set;
++  int32_t image;
+ 
+   decContextDefault (&set, DEC_INIT_DECIMAL128);
+   set.traps = 0;
+ 
+-  *((uint32_t *) d32.bytes) = (uint32_t) buf[0];
++  image = buf[0];
++  memcpy (&d32.bytes, &image, sizeof (int32_t));
+ 
+   decimal32ToNumber (&d32, &dn);
+   decimal_from_decnumber (r, &dn, &set); 
+@@ -170,6 +174,7 @@
+   decNumber dn;
+   decimal64 d64;
+   decContext set;
++  int32_t image;
+ 
+   decContextDefault (&set, DEC_INIT_DECIMAL128);
+   set.traps = 0;
+@@ -179,13 +184,17 @@
+ 
+   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
+     {
+-      buf[0] = *(uint32_t *) &d64.bytes[0];
+-      buf[1] = *(uint32_t *) &d64.bytes[4];
++      memcpy (&image, &d64.bytes[0], sizeof (int32_t));
++      buf[0] = image;
++      memcpy (&image, &d64.bytes[4], sizeof (int32_t));
++      buf[1] = image;
+     }
+   else
+     {
+-      buf[0] = *(uint32_t *) &d64.bytes[4];
+-      buf[1] = *(uint32_t *) &d64.bytes[0];
++      memcpy (&image, &d64.bytes[4], sizeof (int32_t));
++      buf[0] = image;
++      memcpy (&image, &d64.bytes[0], sizeof (int32_t));
++      buf[1] = image;
+     }
+ }
+ 
+@@ -198,19 +207,24 @@
+   decNumber dn;
+   decimal64 d64;
+   decContext set;
++  int32_t image;
+ 
+   decContextDefault (&set, DEC_INIT_DECIMAL128);
+   set.traps = 0;
+ 
+   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
+     {
+-      *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[0];
+-      *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[1];
++      image = buf[0];
++      memcpy (&d64.bytes[0], &image, sizeof (int32_t));
++      image = buf[1];
++      memcpy (&d64.bytes[4], &image, sizeof (int32_t));
+     }
+   else
+     {
+-      *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[1];
+-      *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[0];
++      image = buf[1];
++      memcpy (&d64.bytes[0], &image, sizeof (int32_t));
++      image = buf[0];
++      memcpy (&d64.bytes[4], &image, sizeof (int32_t));
+     }
+ 
+   decimal64ToNumber (&d64, &dn);
+@@ -226,6 +240,7 @@
+   decNumber dn;
+   decContext set;
+   decimal128 d128;
++  int32_t image;
+ 
+   decContextDefault (&set, DEC_INIT_DECIMAL128);
+   set.traps = 0;
+@@ -235,17 +250,25 @@
+ 
+   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
+     {
+-      buf[0] = *(uint32_t *) &d128.bytes[0];
+-      buf[1] = *(uint32_t *) &d128.bytes[4];
+-      buf[2] = *(uint32_t *) &d128.bytes[8];
+-      buf[3] = *(uint32_t *) &d128.bytes[12];
++      memcpy (&image, &d128.bytes[0], sizeof (int32_t));
++      buf[0] = image;
++      memcpy (&image, &d128.bytes[4], sizeof (int32_t));
++      buf[1] = image;
++      memcpy (&image, &d128.bytes[8], sizeof (int32_t));
++      buf[2] = image;
++      memcpy (&image, &d128.bytes[12], sizeof (int32_t));
++      buf[3] = image;
+     }
+   else
+     {
+-      buf[0] = *(uint32_t *) &d128.bytes[12];
+-      buf[1] = *(uint32_t *) &d128.bytes[8];
+-      buf[2] = *(uint32_t *) &d128.bytes[4];
+-      buf[3] = *(uint32_t *) &d128.bytes[0];
++      memcpy (&image, &d128.bytes[12], sizeof (int32_t));
++      buf[0] = image;
++      memcpy (&image, &d128.bytes[8], sizeof (int32_t));
++      buf[1] = image;
++      memcpy (&image, &d128.bytes[4], sizeof (int32_t));
++      buf[2] = image;
++      memcpy (&image, &d128.bytes[0], sizeof (int32_t));
++      buf[3] = image;
+     }
+ }
+ 
+@@ -258,23 +281,32 @@
+   decNumber dn;
+   decimal128 d128;
+   decContext set;
++  int32_t image;
+ 
+   decContextDefault (&set, DEC_INIT_DECIMAL128);
+   set.traps = 0;
+ 
+   if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
+     {
+-      *((uint32_t *) &d128.bytes[0])  = (uint32_t) buf[0];
+-      *((uint32_t *) &d128.bytes[4])  = (uint32_t) buf[1];
+-      *((uint32_t *) &d128.bytes[8])  = (uint32_t) buf[2];
+-      *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[3];
++      image = buf[0];
++      memcpy (&d128.bytes[0],  &image, sizeof (int32_t));
++      image = buf[1];
++      memcpy (&d128.bytes[4],  &image, sizeof (int32_t));
++      image = buf[2];
++      memcpy (&d128.bytes[8],  &image, sizeof (int32_t));
++      image = buf[3];
++      memcpy (&d128.bytes[12], &image, sizeof (int32_t));
+     }
+   else
+     {
+-      *((uint32_t *) &d128.bytes[0])  = (uint32_t) buf[3];
+-      *((uint32_t *) &d128.bytes[4])  = (uint32_t) buf[2];
+-      *((uint32_t *) &d128.bytes[8])  = (uint32_t) buf[1];
+-      *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[0];
++      image = buf[3];
++      memcpy (&d128.bytes[0],  &image, sizeof (int32_t));
++      image = buf[2];
++      memcpy (&d128.bytes[4],  &image, sizeof (int32_t));
++      image = buf[1];
++      memcpy (&d128.bytes[8],  &image, sizeof (int32_t));
++      image = buf[0];
++      memcpy (&d128.bytes[12], &image, sizeof (int32_t));
+     }
+ 
+   decimal128ToNumber (&d128, &dn);
+diff -Naur gcc-4.4.0.orig/gcc/doc/gccint.texi gcc-4.4.0/gcc/doc/gccint.texi
+--- gcc-4.4.0.orig/gcc/doc/gccint.texi  2008-09-21 08:05:14.000000000 -0700
++++ gcc-4.4.0/gcc/doc/gccint.texi       2009-05-23 10:55:01.000000000 -0700
+@@ -109,10 +109,10 @@
+ * Options::         Option specification files.
+ * Passes::          Order of passes, what they do, and what each file is for.
+ * Trees::           The source representation used by the C and C++ front ends.
+-* RTL::             The intermediate representation that most passes work on.
+ * GENERIC::         Language-independent representation generated by Front Ends
+ * GIMPLE::          Tuple representation used by Tree SSA optimizers
+ * Tree SSA::        Analysis and optimization of GIMPLE
++* RTL::             Machine-dependent low-level intermediate representation.
+ * Control Flow::    Maintaining and manipulating the control flow graph.
+ * Loop Analysis and Representation:: Analysis and representation of loops
+ * Machine Desc::    How to write machine description instruction patterns.
+diff -Naur gcc-4.4.0.orig/gcc/doc/md.texi gcc-4.4.0/gcc/doc/md.texi
+--- gcc-4.4.0.orig/gcc/doc/md.texi      2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/doc/md.texi   2009-05-07 01:14:55.000000000 -0700
+@@ -5111,8 +5111,6 @@
+ Operand 0 is the memory on which the atomic operation is performed.
+ Operand 1 is the second operand to the binary operator.
+ 
+-The ``nand'' operation is @code{~op0 & op1}.
+-
+ This pattern must issue any memory barrier instructions such that all
+ memory operations before the atomic operation occur before the atomic
+ operation and all memory operations after the atomic operation occur
+diff -Naur gcc-4.4.0.orig/gcc/doc/passes.texi gcc-4.4.0/gcc/doc/passes.texi
+--- gcc-4.4.0.orig/gcc/doc/passes.texi  2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/doc/passes.texi       2009-05-23 10:55:01.000000000 -0700
+@@ -21,7 +21,7 @@
+ * Parsing pass::         The language front end turns text into bits.
+ * Gimplification pass::  The bits are turned into something we can optimize.
+ * Pass manager::         Sequencing the optimization passes.
+-* Tree-SSA passes::      Optimizations on a high-level representation.
++* Tree SSA passes::      Optimizations on a high-level representation.
+ * RTL passes::           Optimizations on a low-level representation.
+ @end menu
+ 
+@@ -94,8 +94,8 @@
+ should be passed to @code{cgraph_finalize_function}.
+ 
+ TODO: I know rest_of_compilation currently has all sorts of
+-rtl-generation semantics.  I plan to move all code generation
+-bits (both tree and rtl) to compile_function.  Should we hide
++RTL generation semantics.  I plan to move all code generation
++bits (both Tree and RTL) to compile_function.  Should we hide
+ cgraph from the front ends and move back to rest_of_compilation
+ as the official interface?  Possibly we should rename all three
+ interfaces such that the names match in some meaningful way and
+@@ -172,12 +172,12 @@
+ 
+ TODO: describe the global variables set up by the pass manager,
+ and a brief description of how a new pass should use it.
+-I need to look at what info rtl passes use first@enddots{}
++I need to look at what info RTL passes use first@enddots{}
+ 
+-@node Tree-SSA passes
+-@section Tree-SSA passes
++@node Tree SSA passes
++@section Tree SSA passes
+ 
+-The following briefly describes the tree optimization passes that are
++The following briefly describes the Tree optimization passes that are
+ run after gimplification and what source files they are located in.
+ 
+ @itemize @bullet
+@@ -401,7 +401,7 @@
+ The optimizations performed by this pass are:
+ 
+ Loop invariant motion.  This pass moves only invariants that
+-would be hard to handle on rtl level (function calls, operations that expand to
++would be hard to handle on RTL level (function calls, operations that expand to
+ nontrivial sequences of insns).  With @option{-funswitch-loops} it also moves
+ operands of conditions that are invariant out of the loop, so that we can use
+ just trivial invariantness analysis in loop unswitching.  The pass also includes
+@@ -422,8 +422,8 @@
+ out of the loops.  To achieve this, a duplicate of the loop is created for
+ each possible outcome of conditional jump(s).  The pass is implemented in
+ @file{tree-ssa-loop-unswitch.c}.  This pass should eventually replace the
+-rtl-level loop unswitching in @file{loop-unswitch.c}, but currently
+-the rtl-level pass is not completely redundant yet due to deficiencies
++RTL level loop unswitching in @file{loop-unswitch.c}, but currently
++the RTL level pass is not completely redundant yet due to deficiencies
+ in tree level alias analysis.
+ 
+ The optimizations also use various utility functions contained in
+@@ -651,8 +651,8 @@
+ @node RTL passes
+ @section RTL passes
+ 
+-The following briefly describes the rtl generation and optimization
+-passes that are run after tree optimization.
++The following briefly describes the RTL generation and optimization
++passes that are run after the Tree optimization passes.
+ 
+ @itemize @bullet
+ @item RTL generation
+@@ -679,15 +679,15 @@
+ and @code{gencodes}, tell this pass which standard names are available
+ for use and which patterns correspond to them.
+ 
+-@item Generate exception handling landing pads
++@item Generation of exception landing pads
+ 
+ This pass generates the glue that handles communication between the
+ exception handling library routines and the exception handlers within
+ the function.  Entry points in the function that are invoked by the
+ exception handling library are called @dfn{landing pads}.  The code
+-for this pass is located within @file{except.c}.
++for this pass is located in @file{except.c}.
+ 
+-@item Cleanup control flow graph
++@item Control flow graph cleanup
+ 
+ This pass removes unreachable code, simplifies jumps to next, jumps to
+ jump, jumps across jumps, etc.  The pass is run multiple times.
+@@ -702,16 +702,16 @@
+ variables that come from a single definition, and
+ seeing if the result can be simplified.  It performs copy propagation
+ and addressing mode selection.  The pass is run twice, with values
+-being propagated into loops only on the second run.  It is located in
+-@file{fwprop.c}.
++being propagated into loops only on the second run.  The code is
++located in @file{fwprop.c}.
+ 
+ @item Common subexpression elimination
+ 
+ This pass removes redundant computation within basic blocks, and
+ optimizes addressing modes based on cost.  The pass is run twice.
+-The source is located in @file{cse.c}.
++The code for this pass is located in @file{cse.c}.
+ 
+-@item Global common subexpression elimination.
++@item Global common subexpression elimination
+ 
+ This pass performs two
+ different types of GCSE  depending on whether you are optimizing for
+@@ -755,22 +755,13 @@
+ assignments with arithmetic, boolean value producing comparison
+ instructions, and conditional move instructions.  In the very last
+ invocation after reload, it will generate predicated instructions
+-when supported by the target.  The pass is located in @file{ifcvt.c}.
++when supported by the target.  The code is located in @file{ifcvt.c}.
+ 
+ @item Web construction
+ 
+ This pass splits independent uses of each pseudo-register.  This can
+ improve effect of the other transformation, such as CSE or register
+-allocation.  Its source files are @file{web.c}.
+-
+-@item Life analysis
+-
+-This pass computes which pseudo-registers are live at each point in
+-the program, and makes the first instruction that uses a value point
+-at the instruction that computed the value.  It then deletes
+-computations whose results are never used, and combines memory
+-references with add or subtract instructions to make autoincrement or
+-autodecrement addressing.  The pass is located in @file{flow.c}.
++allocation.  The code for this pass is located in @file{web.c}.
+ 
+ @item Instruction combination
+ 
+@@ -778,23 +769,23 @@
+ are related by data flow into single instructions.  It combines the
+ RTL expressions for the instructions by substitution, simplifies the
+ result using algebra, and then attempts to match the result against
+-the machine description.  The pass is located in @file{combine.c}.
++the machine description.  The code is located in @file{combine.c}.
+ 
+ @item Register movement
+ 
+ This pass looks for cases where matching constraints would force an
+ instruction to need a reload, and this reload would be a
+ register-to-register move.  It then attempts to change the registers
+-used by the instruction to avoid the move instruction.
+-The pass is located in @file{regmove.c}.
++used by the instruction to avoid the move instruction.  The code is
++located in @file{regmove.c}.
+ 
+-@item Optimize mode switching
++@item Mode switching optimization
+ 
+ This pass looks for instructions that require the processor to be in a
+ specific ``mode'' and minimizes the number of mode changes required to
+ satisfy all users.  What these modes are, and what they apply to are
+-completely target-specific.
+-The source is located in @file{mode-switching.c}.
++completely target-specific.  The code for this pass is located in
++@file{mode-switching.c}.
+ 
+ @cindex modulo scheduling
+ @cindex sms, swing, software pipelining
+@@ -802,8 +793,8 @@
+ 
+ This pass looks at innermost loops and reorders their instructions
+ by overlapping different iterations.  Modulo scheduling is performed
+-immediately before instruction scheduling.
+-The pass is located in (@file{modulo-sched.c}).
++immediately before instruction scheduling.  The code for this pass is
++located in @file{modulo-sched.c}.
+ 
+ @item Instruction scheduling
+ 
+@@ -813,7 +804,7 @@
+ It re-orders instructions within a basic block to try to separate the
+ definition and use of items that otherwise would cause pipeline
+ stalls.  This pass is performed twice, before and after register
+-allocation.  The pass is located in @file{haifa-sched.c},
++allocation.  The code for this pass is located in @file{haifa-sched.c},
+ @file{sched-deps.c}, @file{sched-ebb.c}, @file{sched-rgn.c} and
+ @file{sched-vis.c}.
+ 
+@@ -884,13 +875,13 @@
+ position in code and generates notes describing the variable locations
+ to RTL code.  The location lists are then generated according to these
+ notes to debug information if the debugging information format supports
+-location lists.
++location lists.  The code is located in @file{var-tracking.c}.
+ 
+ @item Delayed branch scheduling
+ 
+ This optional pass attempts to find instructions that can go into the
+-delay slots of other instructions, usually jumps and calls.  The
+-source file name is @file{reorg.c}.
++delay slots of other instructions, usually jumps and calls.  The code
++for this pass is located in @file{reorg.c}.
+ 
+ @item Branch shortening
+ 
+@@ -899,13 +890,14 @@
+ In this pass, the compiler figures out what how far each instruction
+ will be from each other instruction, and therefore whether the usual
+ instructions, or the longer sequences, must be used for each branch.
++The code for this pass is located in @file{final.c}.
+ 
+ @item Register-to-stack conversion
+ 
+ Conversion from usage of some hard registers to usage of a register
+ stack may be done at this point.  Currently, this is supported only
+-for the floating-point registers of the Intel 80387 coprocessor.   The
+-source file name is @file{reg-stack.c}.
++for the floating-point registers of the Intel 80387 coprocessor.  The
++code for this pass is located in @file{reg-stack.c}.
+ 
+ @item Final
+ 
+diff -Naur gcc-4.4.0.orig/gcc/doc/rtl.texi gcc-4.4.0/gcc/doc/rtl.texi
+--- gcc-4.4.0.orig/gcc/doc/rtl.texi     2008-10-15 17:51:34.000000000 -0700
++++ gcc-4.4.0/gcc/doc/rtl.texi  2009-05-23 10:55:01.000000000 -0700
+@@ -10,10 +10,10 @@
+ @cindex representation of RTL
+ @cindex Register Transfer Language (RTL)
+ 
+-Most of the work of the compiler is done on an intermediate representation
+-called register transfer language.  In this language, the instructions to be
+-output are described, pretty much one by one, in an algebraic form that
+-describes what the instruction does.
++The last part of the compiler work is done on a low-level intermediate
++representation called Register Transfer Language.  In this language, the
++instructions to be output are described, pretty much one by one, in an
++algebraic form that describes what the instruction does.
+ 
+ RTL is inspired by Lisp lists.  It has both an internal form, made up of
+ structures that point at other structures, and a textual form that is used
+diff -Naur gcc-4.4.0.orig/gcc/dojump.c gcc-4.4.0/gcc/dojump.c
+--- gcc-4.4.0.orig/gcc/dojump.c 2009-01-09 05:43:14.000000000 -0800
++++ gcc-4.4.0/gcc/dojump.c      2009-05-07 08:36:23.000000000 -0700
+@@ -141,7 +141,8 @@
+     }
+ 
+   /* Fill in the integers.  */
+-  XEXP (and_test, 1) = GEN_INT ((unsigned HOST_WIDE_INT) 1 << bitnum);
++  XEXP (and_test, 1)
++    = immed_double_const ((unsigned HOST_WIDE_INT) 1 << bitnum, 0, mode);
+   XEXP (XEXP (shift_test, 0), 1) = GEN_INT (bitnum);
+ 
+   return (rtx_cost (and_test, IF_THEN_ELSE, optimize_insn_for_speed_p ())
+@@ -475,10 +476,10 @@
+                  && prefer_and_bit_test (TYPE_MODE (argtype),
+                                          TREE_INT_CST_LOW (shift)))
+                {
+-                 HOST_WIDE_INT mask = (HOST_WIDE_INT) 1
+-                                      << TREE_INT_CST_LOW (shift);
++                 unsigned HOST_WIDE_INT mask
++                   = (unsigned HOST_WIDE_INT) 1 << TREE_INT_CST_LOW (shift);
+                  do_jump (build2 (BIT_AND_EXPR, argtype, arg,
+-                                  build_int_cst_type (argtype, mask)),
++                                  build_int_cst_wide_type (argtype, mask, 0)),
+                           clr_label, set_label);
+                  break;
+                }
 diff -Naur gcc-4.4.0.orig/gcc/dse.c gcc-4.4.0/gcc/dse.c
 --- gcc-4.4.0.orig/gcc/dse.c    2009-03-18 10:04:26.000000000 -0700
-+++ gcc-4.4.0/gcc/dse.c 2009-04-27 04:55:13.000000000 -0700
++++ gcc-4.4.0/gcc/dse.c 2009-05-13 14:42:03.000000000 -0700
 @@ -223,7 +223,7 @@
    /* This canonized mem.  */
@@ -1151 +2115 @@
               /* If this read is just reading back something that we just
                  stored, rewrite the read.  */
-@@ -2224,7 +2257,7 @@
+@@ -2212,6 +2245,7 @@
+          if (store_info->rhs
+              && store_info->group_id == -1
+              && store_info->cse_base == base
++             && width != -1
+              && offset >= store_info->begin
+              && offset + width <= store_info->end
+              && all_positions_needed_p (store_info,
+@@ -2224,7 +2258,7 @@
             remove = canon_true_dependence (store_info->mem, 
                                             GET_MODE (store_info->mem),
@@ -1160 +2132 @@
           if (remove)
             {
-@@ -3066,8 +3099,9 @@
+@@ -3066,8 +3100,9 @@
                   if ((read_info->group_id < 0)
                       && canon_true_dependence (group->base_mem, 
@@ -1172 +2144 @@
                       if (kill)
                         bitmap_ior_into (kill, group->group_kill);
+diff -Naur gcc-4.4.0.orig/gcc/dwarf2out.c gcc-4.4.0/gcc/dwarf2out.c
+--- gcc-4.4.0.orig/gcc/dwarf2out.c      2009-03-23 16:21:38.000000000 -0700
++++ gcc-4.4.0/gcc/dwarf2out.c   2009-06-03 10:32:45.000000000 -0700
+@@ -694,14 +694,15 @@
+   *p = cfi;
+ }
+ 
+-/* Generate a new label for the CFI info to refer to.  */
++/* Generate a new label for the CFI info to refer to.  FORCE is true
++   if a label needs to be output even when using .cfi_* directives.  */
+ 
+ char *
+-dwarf2out_cfi_label (void)
++dwarf2out_cfi_label (bool force)
+ {
+   static char label[20];
+ 
+-  if (dwarf2out_do_cfi_asm ())
++  if (!force && dwarf2out_do_cfi_asm ())
+     {
+       /* In this case, we will be emitting the asm directive instead of
+         the label, so just return a placeholder to keep the rest of the
+@@ -729,11 +730,59 @@
+     {
+       if (label)
+        {
+-         output_cfi_directive (cfi);
++         dw_fde_ref fde = current_fde ();
++
++         gcc_assert (fde != NULL);
+ 
+          /* We still have to add the cfi to the list so that
+-            lookup_cfa works later on.  */
+-         list_head = &current_fde ()->dw_fde_cfi;
++            lookup_cfa works later on.  When -g2 and above we
++            even need to force emitting of CFI labels and
++            add to list a DW_CFA_set_loc for convert_cfa_to_fb_loc_list
++            purposes.  */
++         switch (cfi->dw_cfi_opc)
++           {
++           case DW_CFA_def_cfa_offset:
++           case DW_CFA_def_cfa_offset_sf:
++           case DW_CFA_def_cfa_register:
++           case DW_CFA_def_cfa:
++           case DW_CFA_def_cfa_sf:
++           case DW_CFA_def_cfa_expression:
++           case DW_CFA_restore_state:
++             if (write_symbols != DWARF2_DEBUG
++                 && write_symbols != VMS_AND_DWARF2_DEBUG)
++               break;
++             if (debug_info_level <= DINFO_LEVEL_TERSE)
++               break;
++
++             if (*label == 0 || strcmp (label, "<do not output>") == 0)
++               label = dwarf2out_cfi_label (true);
++
++             if (fde->dw_fde_current_label == NULL
++                 || strcmp (label, fde->dw_fde_current_label) != 0)
++               {
++                 dw_cfi_ref xcfi;
++
++                 label = xstrdup (label);
++
++                 /* Set the location counter to the new label.  */
++                 xcfi = new_cfi ();
++                 /* It doesn't metter whether DW_CFA_set_loc
++                    or DW_CFA_advance_loc4 is added here, those aren't
++                    emitted into assembly, only looked up by
++                    convert_cfa_to_fb_loc_list.  */
++                 xcfi->dw_cfi_opc = DW_CFA_set_loc;
++                 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
++                 add_cfi (&fde->dw_fde_cfi, xcfi);
++                 fde->dw_fde_current_label = label;
++               }
++             break;
++           default:
++             break;
++           }
++
++         output_cfi_directive (cfi);
++
++         list_head = &fde->dw_fde_cfi;
+        }
+       /* ??? If this is a CFI for the CIE, we don't emit.  This
+         assumes that the standard CIE contents that the assembler
+@@ -748,7 +797,7 @@
+       gcc_assert (fde != NULL);
+ 
+       if (*label == 0)
+-       label = dwarf2out_cfi_label ();
++       label = dwarf2out_cfi_label (false);
+ 
+       if (fde->dw_fde_current_label == NULL
+          || strcmp (label, fde->dw_fde_current_label) != 0)
+@@ -1464,7 +1513,7 @@
+   if (offset == 0)
+     return;
+ 
+-  label = dwarf2out_cfi_label ();
++  label = dwarf2out_cfi_label (false);
+   dwarf2out_args_size_adjust (offset, label);
+ }
+ 
+@@ -2417,7 +2466,7 @@
+       return;
+     }
+ 
+-  label = dwarf2out_cfi_label ();
++  label = dwarf2out_cfi_label (false);
+   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
+   if (src)
+     insn = XEXP (src, 0);
+@@ -2731,42 +2780,42 @@
+     case DW_CFA_offset:
+     case DW_CFA_offset_extended:
+     case DW_CFA_offset_extended_sf:
+-      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
++      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
+       fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
+               r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
+       break;
+ 
+     case DW_CFA_restore:
+     case DW_CFA_restore_extended:
+-      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
++      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
+       fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
+       break;
+ 
+     case DW_CFA_undefined:
+-      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
++      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
+       fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
+       break;
+ 
+     case DW_CFA_same_value:
+-      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
++      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
+       fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
+       break;
+ 
+     case DW_CFA_def_cfa:
+     case DW_CFA_def_cfa_sf:
+-      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
++      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
+       fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
+               r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
+       break;
+ 
+     case DW_CFA_def_cfa_register:
+-      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
++      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
+       fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
+       break;
+ 
+     case DW_CFA_register:
+-      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
+-      r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 0);
++      r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
++      r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
+       fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
+       break;
+ 
+@@ -14646,6 +14695,12 @@
+       /* Prevent broken recursion; we can't hand off to the same type.  */
+       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
+ 
++      /* Use the DIE of the containing namespace as the parent DIE of
++         the type description DIE we want to generate.  */
++      if (DECL_CONTEXT (TYPE_NAME (type))
++         && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
++       context_die = lookup_decl_die (DECL_CONTEXT (TYPE_NAME (type)));
++
+       TREE_ASM_WRITTEN (type) = 1;
+       gen_decl_die (TYPE_NAME (type), NULL, context_die);
+       return;
 diff -Naur gcc-4.4.0.orig/gcc/fold-const.c gcc-4.4.0/gcc/fold-const.c
 --- gcc-4.4.0.orig/gcc/fold-const.c     2009-03-11 08:24:00.000000000 -0700
-+++ gcc-4.4.0/gcc/fold-const.c  2009-04-24 04:34:59.000000000 -0700
++++ gcc-4.4.0/gcc/fold-const.c  2009-05-20 14:11:10.000000000 -0700
 @@ -5293,31 +5293,34 @@
         break;
@@ -1220 +2368 @@
        case NE_EXPR:
         break;
-@@ -11861,7 +11864,8 @@
+@@ -11360,6 +11363,8 @@
+              if (prec < HOST_BITS_PER_WIDE_INT
+                  || newmask == ~(unsigned HOST_WIDE_INT) 0)
+                {
++                 tree newmaskt;
++
+                  if (shift_type != TREE_TYPE (arg0))
+                    {
+                      tem = fold_build2 (TREE_CODE (arg0), shift_type,
+@@ -11370,9 +11375,9 @@
+                    }
+                  else
+                    tem = op0;
+-                 return fold_build2 (BIT_AND_EXPR, type, tem,
+-                                     build_int_cst_type (TREE_TYPE (op1),
+-                                                         newmask));
++                 newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
++                 if (!tree_int_cst_equal (newmaskt, arg1))
++                   return fold_build2 (BIT_AND_EXPR, type, tem, newmaskt);
+                }
+            }
+        }
+@@ -11861,7 +11866,8 @@
               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
                 low = low % TYPE_PRECISION (type);
@@ -1230 +2400 @@
                 low = TYPE_PRECISION (type) - 1;
             }
-diff -Naur gcc-4.4.0.orig/gcc/fortran/ChangeLog gcc-4.4.0/gcc/fortran/ChangeLog
---- gcc-4.4.0.orig/gcc/fortran/ChangeLog        2009-04-21 01:44:29.000000000 -0700
-+++ gcc-4.4.0/gcc/fortran/ChangeLog     2009-04-22 04:37:04.000000000 -0700
-@@ -1,3 +1,13 @@
-+2009-04-22  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       Backport from mainline:
-+       2009-03-30  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       * f95-lang.c (gfc_init_builtin_functions): Define BUILT_IN_HUGE_VAL
-+       family of intrinsics instead of BUILT_IN_INF family.
-+       * trans-intrinsics.c (gfc_conv_intrinsic_nearest): Use
-+       BUILT_IN_HUGE_VAL instead of BUILT_IN_INF.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
+diff -Naur gcc-4.4.0.orig/gcc/fortran/data.c gcc-4.4.0/gcc/fortran/data.c
+--- gcc-4.4.0.orig/gcc/fortran/data.c   2008-07-28 17:45:52.000000000 -0700
++++ gcc-4.4.0/gcc/fortran/data.c        2009-06-04 10:01:45.000000000 -0700
+@@ -416,7 +416,11 @@
+     }
+ 
+   if (ref || last_ts->type == BT_CHARACTER)
+-    expr = create_character_intializer (init, last_ts, ref, rvalue);
++    {
++      if (lvalue->ts.cl->length == NULL && !(ref && ref->u.ss.length != NULL))
++       return FAILURE;
++      expr = create_character_intializer (init, last_ts, ref, rvalue);
++    }
+   else
+     {
+       /* Overwriting an existing initializer is non-standard but usually only
 diff -Naur gcc-4.4.0.orig/gcc/fortran/f95-lang.c gcc-4.4.0/gcc/fortran/f95-lang.c
 --- gcc-4.4.0.orig/gcc/fortran/f95-lang.c       2008-10-07 11:15:32.000000000 -0700
@@ -1269 +2438 @@
    /* lround{f,,l} and llround{f,,l} */
    type = tree_cons (NULL_TREE, float_type_node, void_list_node);
+diff -Naur gcc-4.4.0.orig/gcc/fortran/module.c gcc-4.4.0/gcc/fortran/module.c
+--- gcc-4.4.0.orig/gcc/fortran/module.c 2009-02-26 23:45:47.000000000 -0800
++++ gcc-4.4.0/gcc/fortran/module.c      2009-05-22 05:54:23.000000000 -0700
+@@ -4738,7 +4738,7 @@
+   if ((file = fopen (filename, "r")) == NULL)
+     return -1;
+ 
+-  /* Read two lines.  */
++  /* Read the first line.  */
+   if (fgets (buf, sizeof (buf) - 1, file) == NULL)
+     {
+       fclose (file);
+@@ -4748,8 +4748,12 @@
+   /* The file also needs to be overwritten if the version number changed.  */
+   n = strlen ("GFORTRAN module version '" MOD_VERSION "' created");
+   if (strncmp (buf, "GFORTRAN module version '" MOD_VERSION "' created", n) != 0)
+-    return -1;
++    {
++      fclose (file);
++      return -1;
++    }
+  
++  /* Read a second line.  */
+   if (fgets (buf, sizeof (buf) - 1, file) == NULL)
+     {
+       fclose (file);
+diff -Naur gcc-4.4.0.orig/gcc/fortran/simplify.c gcc-4.4.0/gcc/fortran/simplify.c
+--- gcc-4.4.0.orig/gcc/fortran/simplify.c       2009-03-06 01:06:51.000000000 -0800
++++ gcc-4.4.0/gcc/fortran/simplify.c    2009-06-03 12:39:09.000000000 -0700
+@@ -2410,10 +2410,13 @@
+   bs = gfc_integer_kinds[i].bit_size;
+   if (mpz_cmp_si (e->value.integer, 0) == 0)
+     lz = bs;
++  else if (mpz_cmp_si (e->value.integer, 0) < 0)
++    lz = 0;
+   else
+     lz = bs - mpz_sizeinbase (e->value.integer, 2);
+ 
+-  result = gfc_constant_result (BT_INTEGER, gfc_default_integer_kind, &e->where);
++  result = gfc_constant_result (BT_INTEGER, gfc_default_integer_kind,
++                               &e->where);
+   mpz_set_ui (result->value.integer, lz);
+ 
+   return result;
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-array.c gcc-4.4.0/gcc/fortran/trans-array.c
+--- gcc-4.4.0.orig/gcc/fortran/trans-array.c    2009-02-25 22:23:42.000000000 -0800
++++ gcc-4.4.0/gcc/fortran/trans-array.c 2009-05-10 09:14:37.000000000 -0700
+@@ -1246,10 +1246,11 @@
+                  gfc_init_se (&se, NULL);
+                  gfc_conv_constant (&se, p->expr);
+ 
++                 if (c->expr->ts.type != BT_CHARACTER)
++                   se.expr = fold_convert (type, se.expr);
+                  /* For constant character array constructors we build
+                     an array of pointers.  */
+-                 if (p->expr->ts.type == BT_CHARACTER
+-                     && POINTER_TYPE_P (type))
++                 else if (POINTER_TYPE_P (type))
+                    se.expr = gfc_build_addr_expr
+                                (gfc_get_pchar_type (p->expr->ts.kind),
+                                 se.expr);
+@@ -1618,7 +1619,9 @@
+     {
+       gfc_init_se (&se, NULL);
+       gfc_conv_constant (&se, c->expr);
+-      if (c->expr->ts.type == BT_CHARACTER && POINTER_TYPE_P (type))
++      if (c->expr->ts.type != BT_CHARACTER)
++       se.expr = fold_convert (type, se.expr);
++      else if (POINTER_TYPE_P (type))
+        se.expr = gfc_build_addr_expr (gfc_get_pchar_type (c->expr->ts.kind),
+                                       se.expr);
+       list = tree_cons (build_int_cst (gfc_array_index_type, nelem),
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans.c gcc-4.4.0/gcc/fortran/trans.c
+--- gcc-4.4.0.orig/gcc/fortran/trans.c  2008-11-01 06:26:19.000000000 -0700
++++ gcc-4.4.0/gcc/fortran/trans.c       2009-05-10 08:34:55.000000000 -0700
+@@ -1109,12 +1109,14 @@
+            if (code->resolved_isym
+                && code->resolved_isym->id == GFC_ISYM_MVBITS)
+              is_mvbits = true;
+-           res = gfc_trans_call (code, is_mvbits);
++           res = gfc_trans_call (code, is_mvbits, NULL_TREE,
++                                 NULL_TREE, false);
+          }
+          break;
+ 
+        case EXEC_ASSIGN_CALL:
+-         res = gfc_trans_call (code, true);
++         res = gfc_trans_call (code, true, NULL_TREE,
++                               NULL_TREE, false);
+          break;
+ 
+        case EXEC_RETURN:
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-decl.c gcc-4.4.0/gcc/fortran/trans-decl.c
+--- gcc-4.4.0.orig/gcc/fortran/trans-decl.c     2009-04-08 07:03:33.000000000 -0700
++++ gcc-4.4.0/gcc/fortran/trans-decl.c  2009-06-03 12:39:09.000000000 -0700
+@@ -141,6 +141,8 @@
+ tree gfor_fndecl_size0;
+ tree gfor_fndecl_size1;
+ tree gfor_fndecl_iargc;
++tree gfor_fndecl_clz128;
++tree gfor_fndecl_ctz128;
+ 
+ /* Intrinsic functions implemented in Fortran.  */
+ tree gfor_fndecl_sc_kind;
+@@ -2488,6 +2490,19 @@
+     gfc_build_library_function_decl (get_identifier (PREFIX ("iargc")),
+                                     gfc_int4_type_node,
+                                     0);
++
++  if (gfc_type_for_size (128, true))
++    {
++      tree uint128 = gfc_type_for_size (128, true);
++
++      gfor_fndecl_clz128 =
++       gfc_build_library_function_decl (get_identifier (PREFIX ("clz128")),
++                                        integer_type_node, 1, uint128);
++
++      gfor_fndecl_ctz128 =
++       gfc_build_library_function_decl (get_identifier (PREFIX ("ctz128")),
++                                        integer_type_node, 1, uint128);
++    }
+ }
+ 
+ 
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-expr.c gcc-4.4.0/gcc/fortran/trans-expr.c
+--- gcc-4.4.0.orig/gcc/fortran/trans-expr.c     2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/fortran/trans-expr.c  2009-05-10 08:34:55.000000000 -0700
+@@ -1526,48 +1526,6 @@
+ }
+ 
+ 
+-/* Translate the call for an elemental subroutine call used in an operator
+-   assignment.  This is a simplified version of gfc_conv_function_call.  */
+-
+-tree
+-gfc_conv_operator_assign (gfc_se *lse, gfc_se *rse, gfc_symbol *sym)
+-{
+-  tree args;
+-  tree tmp;
+-  gfc_se se;
+-  stmtblock_t block;
+-
+-  /* Only elemental subroutines with two arguments.  */
+-  gcc_assert (sym->attr.elemental && sym->attr.subroutine);
+-  gcc_assert (sym->formal->next->next == NULL);
+-
+-  gfc_init_block (&block);
+-
+-  gfc_add_block_to_block (&block, &lse->pre);
+-  gfc_add_block_to_block (&block, &rse->pre);
+-
+-  /* Build the argument list for the call, including hidden string lengths.  */
+-  args = gfc_chainon_list (NULL_TREE, build_fold_addr_expr (lse->expr));
+-  args = gfc_chainon_list (args, build_fold_addr_expr (rse->expr));
+-  if (lse->string_length != NULL_TREE)
+-    args = gfc_chainon_list (args, lse->string_length);
+-  if (rse->string_length != NULL_TREE)
+-    args = gfc_chainon_list (args, rse->string_length);    
+-
+-  /* Build the function call.  */
+-  gfc_init_se (&se, NULL);
+-  gfc_conv_function_val (&se, sym);
+-  tmp = TREE_TYPE (TREE_TYPE (TREE_TYPE (se.expr)));
+-  tmp = build_call_list (tmp, se.expr, args);
+-  gfc_add_expr_to_block (&block, tmp);
+-
+-  gfc_add_block_to_block (&block, &lse->post);
+-  gfc_add_block_to_block (&block, &rse->post);
+-
+-  return gfc_finish_block (&block);
+-}
+-
+-
+ /* Initialize MAPPING.  */
+ 
+ void
+@@ -2782,7 +2740,18 @@
+              break;
+            }
+ 
++         if (e->expr_type == EXPR_OP
++               && e->value.op.op == INTRINSIC_PARENTHESES
++               && e->value.op.op1->expr_type == EXPR_VARIABLE)
++           {
++             tree local_tmp;
++             local_tmp = gfc_evaluate_now (tmp, &se->pre);
++             local_tmp = gfc_copy_alloc_comp (e->ts.derived, local_tmp, tmp, parm_rank);
++             gfc_add_expr_to_block (&se->post, local_tmp);
++           }
++
+          tmp = gfc_deallocate_alloc_comp (e->ts.derived, tmp, parm_rank);
++
+          gfc_add_expr_to_block (&se->post, tmp);
+         }
+ 
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans.h gcc-4.4.0/gcc/fortran/trans.h
+--- gcc-4.4.0.orig/gcc/fortran/trans.h  2008-12-18 02:05:54.000000000 -0800
++++ gcc-4.4.0/gcc/fortran/trans.h       2009-06-03 12:39:09.000000000 -0700
+@@ -310,9 +310,6 @@
+ /* Does an intrinsic map directly to an external library call.  */
+ int gfc_is_intrinsic_libcall (gfc_expr *);
+ 
+-/* Used to call the elemental subroutines used in operator assignments.  */
+-tree gfc_conv_operator_assign (gfc_se *, gfc_se *, gfc_symbol *);
+-
+ /* Also used to CALL subroutines.  */
+ int gfc_conv_function_call (gfc_se *, gfc_symbol *, gfc_actual_arglist *,
+                            tree);
+@@ -594,6 +591,8 @@
+ extern GTY(()) tree gfor_fndecl_size0;
+ extern GTY(()) tree gfor_fndecl_size1;
+ extern GTY(()) tree gfor_fndecl_iargc;
++extern GTY(()) tree gfor_fndecl_clz128;
++extern GTY(()) tree gfor_fndecl_ctz128;
+ 
+ /* Implemented in Fortran.  */
+ extern GTY(()) tree gfor_fndecl_sc_kind;
 diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-intrinsic.c gcc-4.4.0/gcc/fortran/trans-intrinsic.c
 --- gcc-4.4.0.orig/gcc/fortran/trans-intrinsic.c        2009-02-20 07:20:38.000000000 -0800
-+++ gcc-4.4.0/gcc/fortran/trans-intrinsic.c     2009-04-22 04:37:04.000000000 -0700
-@@ -3129,32 +3129,32 @@
++++ gcc-4.4.0/gcc/fortran/trans-intrinsic.c     2009-06-03 12:39:09.000000000 -0700
+@@ -2707,53 +2707,51 @@
+   tree leadz;
+   tree bit_size;
+   tree tmp;
+-  int arg_kind;
+-  int i, n, s;
++  tree func;
++  int s, argsize;
+ 
+   gfc_conv_intrinsic_function_args (se, expr, &arg, 1);
++  argsize = TYPE_PRECISION (TREE_TYPE (arg));
+ 
+   /* Which variant of __builtin_clz* should we call?  */
+-  arg_kind = expr->value.function.actual->expr->ts.kind;
+-  i = gfc_validate_kind (BT_INTEGER, arg_kind, false);
+-  switch (arg_kind)
++  if (argsize <= INT_TYPE_SIZE)
+     {
+-      case 1:
+-      case 2:
+-      case 4:
+-        arg_type = unsigned_type_node;
+-       n = BUILT_IN_CLZ;
+-       break;
+-
+-      case 8:
+-        arg_type = long_unsigned_type_node;
+-       n = BUILT_IN_CLZL;
+-       break;
+-
+-      case 16:
+-        arg_type = long_long_unsigned_type_node;
+-       n = BUILT_IN_CLZLL;
+-       break;
+-
+-      default:
+-        gcc_unreachable ();
++      arg_type = unsigned_type_node;
++      func = built_in_decls[BUILT_IN_CLZ];
++    }
++  else if (argsize <= LONG_TYPE_SIZE)
++    {
++      arg_type = long_unsigned_type_node;
++      func = built_in_decls[BUILT_IN_CLZL];
++    }
++  else if (argsize <= LONG_LONG_TYPE_SIZE)
++    {
++      arg_type = long_long_unsigned_type_node;
++      func = built_in_decls[BUILT_IN_CLZLL];
++    }
++  else
++    {
++      gcc_assert (argsize == 128);
++      arg_type = gfc_build_uint_type (argsize);
++      func = gfor_fndecl_clz128;
+     }
+ 
+-  /* Convert the actual argument to the proper argument type for the built-in
++  /* Convert the actual argument twice: first, to the unsigned type of the
++     same size; then, to the proper argument type for the built-in
+      function.  But the return type is of the default INTEGER kind.  */
++  arg = fold_convert (gfc_build_uint_type (argsize), arg);
+   arg = fold_convert (arg_type, arg);
+   result_type = gfc_get_int_type (gfc_default_integer_kind);
+ 
+   /* Compute LEADZ for the case i .ne. 0.  */
+-  s = TYPE_PRECISION (arg_type) - gfc_integer_kinds[i].bit_size;
+-  tmp = fold_convert (result_type, build_call_expr (built_in_decls[n], 1, arg));
++  s = TYPE_PRECISION (arg_type) - argsize;
++  tmp = fold_convert (result_type, build_call_expr (func, 1, arg));
+   leadz = fold_build2 (MINUS_EXPR, result_type,
+                       tmp, build_int_cst (result_type, s));
+ 
+   /* Build BIT_SIZE.  */
+-  bit_size = build_int_cst (result_type, gfc_integer_kinds[i].bit_size);
++  bit_size = build_int_cst (result_type, argsize);
+ 
+-  /* ??? For some combinations of targets and integer kinds, the condition
+-        can be avoided if CLZ_DEFINED_VALUE_AT_ZERO is used.  Later.  */
+   cond = fold_build2 (EQ_EXPR, boolean_type_node,
+                      arg, build_int_cst (arg_type, 0));
+   se->expr = fold_build3 (COND_EXPR, result_type, cond, bit_size, leadz);
+@@ -2774,50 +2772,48 @@
+   tree result_type;
+   tree trailz;
+   tree bit_size;
+-  int arg_kind;
+-  int i, n;
++  tree func;
++  int argsize;
+ 
+   gfc_conv_intrinsic_function_args (se, expr, &arg, 1);
++  argsize = TYPE_PRECISION (TREE_TYPE (arg));
+ 
+-  /* Which variant of __builtin_clz* should we call?  */
+-  arg_kind = expr->value.function.actual->expr->ts.kind;
+-  i = gfc_validate_kind (BT_INTEGER, arg_kind, false);
+-  switch (expr->ts.kind)
++  /* Which variant of __builtin_ctz* should we call?  */
++  if (argsize <= INT_TYPE_SIZE)
+     {
+-      case 1:
+-      case 2:
+-      case 4:
+-        arg_type = unsigned_type_node;
+-       n = BUILT_IN_CTZ;
+-       break;
+-
+-      case 8:
+-        arg_type = long_unsigned_type_node;
+-       n = BUILT_IN_CTZL;
+-       break;
+-
+-      case 16:
+-        arg_type = long_long_unsigned_type_node;
+-       n = BUILT_IN_CTZLL;
+-       break;
+-
+-      default:
+-        gcc_unreachable ();
++      arg_type = unsigned_type_node;
++      func = built_in_decls[BUILT_IN_CTZ];
++    }
++  else if (argsize <= LONG_TYPE_SIZE)
++    {
++      arg_type = long_unsigned_type_node;
++      func = built_in_decls[BUILT_IN_CTZL];
++    }
++  else if (argsize <= LONG_LONG_TYPE_SIZE)
++    {
++      arg_type = long_long_unsigned_type_node;
++      func = built_in_decls[BUILT_IN_CTZLL];
++    }
++  else
++    {
++      gcc_assert (argsize == 128);
++      arg_type = gfc_build_uint_type (argsize);
++      func = gfor_fndecl_ctz128;
+     }
+ 
+-  /* Convert the actual argument to the proper argument type for the built-in
++  /* Convert the actual argument twice: first, to the unsigned type of the
++     same size; then, to the proper argument type for the built-in
+      function.  But the return type is of the default INTEGER kind.  */
++  arg = fold_convert (gfc_build_uint_type (argsize), arg);
+   arg = fold_convert (arg_type, arg);
+   result_type = gfc_get_int_type (gfc_default_integer_kind);
+ 
+   /* Compute TRAILZ for the case i .ne. 0.  */
+-  trailz = fold_convert (result_type, build_call_expr (built_in_decls[n], 1, arg));
++  trailz = fold_convert (result_type, build_call_expr (func, 1, arg));
+ 
+   /* Build BIT_SIZE.  */
+-  bit_size = build_int_cst (result_type, gfc_integer_kinds[i].bit_size);
++  bit_size = build_int_cst (result_type, argsize);
+ 
+-  /* ??? For some combinations of targets and integer kinds, the condition
+-        can be avoided if CTZ_DEFINED_VALUE_AT_ZERO is used.  Later.  */
+   cond = fold_build2 (EQ_EXPR, boolean_type_node,
+                      arg, build_int_cst (arg_type, 0));
+   se->expr = fold_build3 (COND_EXPR, result_type, cond, bit_size, trailz);
+@@ -3129,32 +3125,32 @@
  
  
@@ -1310 +2857 @@
        default:
         gcc_unreachable ();
-@@ -3163,7 +3163,7 @@
+@@ -3163,7 +3159,7 @@
    type = gfc_typenode_for_spec (&expr->ts);
    gfc_conv_intrinsic_function_args (se, expr, args, 2);
@@ -1319 +2866 @@
    se->expr = build_call_expr (built_in_decls[nextafter], 2,
                               fold_convert (type, args[0]), tmp);
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-stmt.c gcc-4.4.0/gcc/fortran/trans-stmt.c
+--- gcc-4.4.0.orig/gcc/fortran/trans-stmt.c     2009-01-27 10:07:54.000000000 -0800
++++ gcc-4.4.0/gcc/fortran/trans-stmt.c  2009-05-10 08:34:55.000000000 -0700
+@@ -270,9 +270,11 @@
+          gfc_conv_expr_descriptor (&parmse, e, gfc_walk_expr (e));
+          gfc_add_block_to_block (&se->pre, &parmse.pre);
+ 
+-         /* If we've got INTENT(INOUT), initialize the array temporary with
+-            a copy of the values.  */
+-         if (fsym->attr.intent == INTENT_INOUT)
++         /* If we've got INTENT(INOUT) or a derived type with INTENT(OUT),
++            initialize the array temporary with a copy of the values.  */
++         if (fsym->attr.intent == INTENT_INOUT
++               || (fsym->ts.type ==BT_DERIVED
++                     && fsym->attr.intent == INTENT_OUT))
+            initial = parmse.expr;
+          else
+            initial = NULL_TREE;
+@@ -332,12 +334,16 @@
+ /* Translate the CALL statement.  Builds a call to an F95 subroutine.  */
+ 
+ tree
+-gfc_trans_call (gfc_code * code, bool dependency_check)
++gfc_trans_call (gfc_code * code, bool dependency_check,
++               tree mask, tree count1, bool invert)
+ {
+   gfc_se se;
+   gfc_ss * ss;
+   int has_alternate_specifier;
+   gfc_dep_check check_variable;
++  tree index = NULL_TREE;
++  tree maskexpr = NULL_TREE;
++  tree tmp;
+ 
+   /* A CALL starts a new block because the actual arguments may have to
+      be evaluated first.  */
+@@ -429,10 +435,31 @@
+       gfc_start_scalarized_body (&loop, &body);
+       gfc_init_block (&block);
+ 
++      if (mask && count1)
++       {
++         /* Form the mask expression according to the mask.  */
++         index = count1;
++         maskexpr = gfc_build_array_ref (mask, index, NULL);
++         if (invert)
++           maskexpr = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (maskexpr),
++                                   maskexpr);
++       }
++
+       /* Add the subroutine call to the block.  */
+-      gfc_conv_function_call (&loopse, code->resolved_sym, code->ext.actual,
+-                             NULL_TREE);
+-      gfc_add_expr_to_block (&loopse.pre, loopse.expr);
++      gfc_conv_function_call (&loopse, code->resolved_sym,
++                             code->ext.actual, NULL_TREE);
++
++      if (mask && count1)
++       {
++         tmp = build3_v (COND_EXPR, maskexpr, loopse.expr,
++                         build_empty_stmt ());
++         gfc_add_expr_to_block (&loopse.pre, tmp);
++         tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
++                            count1, gfc_index_one_node);
++         gfc_add_modify (&loopse.pre, count1, tmp);
++       }
++      else
++       gfc_add_expr_to_block (&loopse.pre, loopse.expr);
+ 
+       gfc_add_block_to_block (&block, &loopse.pre);
+       gfc_add_block_to_block (&block, &loopse.post);
+@@ -2981,7 +3008,7 @@
+        /* Explicit subroutine calls are prevented by the frontend but interface
+           assignments can legitimately produce them.  */
+        case EXEC_ASSIGN_CALL:
+-         assign = gfc_trans_call (c, true);
++         assign = gfc_trans_call (c, true, NULL_TREE, NULL_TREE, false);
+           tmp = gfc_trans_nested_forall_loop (nested_forall_info, assign, 1);
+           gfc_add_expr_to_block (&block, tmp);
+           break;
+@@ -3176,7 +3203,7 @@
+ gfc_trans_where_assign (gfc_expr *expr1, gfc_expr *expr2,
+                        tree mask, bool invert,
+                         tree count1, tree count2,
+-                       gfc_symbol *sym)
++                       gfc_code *cnext)
+ {
+   gfc_se lse;
+   gfc_se rse;
+@@ -3190,6 +3217,10 @@
+   stmtblock_t body;
+   tree index, maskexpr;
+ 
++  /* A defined assignment. */  
++  if (cnext && cnext->resolved_sym)
++    return gfc_trans_call (cnext, true, mask, count1, invert);
++
+ #if 0
+   /* TODO: handle this special case.
+      Special case a single function returning an array.  */
+@@ -3291,11 +3322,8 @@
+     maskexpr = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (maskexpr), maskexpr);
+ 
+   /* Use the scalar assignment as is.  */
+-  if (sym == NULL)
+-    tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts,
+-                                  loop.temp_ss != NULL, false);
+-  else
+-    tmp = gfc_conv_operator_assign (&lse, &rse, sym);
++  tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts,
++                                loop.temp_ss != NULL, false);
+ 
+   tmp = build3_v (COND_EXPR, maskexpr, tmp, build_empty_stmt ());
+ 
+@@ -3562,7 +3590,7 @@
+                       tmp = gfc_trans_where_assign (expr1, expr2,
+                                                    cmask, invert,
+                                                    count1, count2,
+-                                                   cnext->resolved_sym);
++                                                   cnext);
+ 
+                       tmp = gfc_trans_nested_forall_loop (nested_forall_info,
+                                                           tmp, 1);
+@@ -3580,7 +3608,7 @@
+                   tmp = gfc_trans_where_assign (expr1, expr2,
+                                                cmask, invert,
+                                                count1, count2,
+-                                               cnext->resolved_sym);
++                                               cnext);
+                   gfc_add_expr_to_block (block, tmp);
+ 
+                 }
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-stmt.h gcc-4.4.0/gcc/fortran/trans-stmt.h
+--- gcc-4.4.0.orig/gcc/fortran/trans-stmt.h     2008-04-05 15:23:27.000000000 -0700
++++ gcc-4.4.0/gcc/fortran/trans-stmt.h  2009-05-10 08:34:55.000000000 -0700
+@@ -39,7 +39,7 @@
+ tree gfc_trans_entry (gfc_code *);
+ tree gfc_trans_pause (gfc_code *);
+ tree gfc_trans_stop (gfc_code *);
+-tree gfc_trans_call (gfc_code *, bool);
++tree gfc_trans_call (gfc_code *, bool, tree, tree, bool);
+ tree gfc_trans_return (gfc_code *);
+ tree gfc_trans_if (gfc_code *);
+ tree gfc_trans_arithmetic_if (gfc_code *);
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-types.c gcc-4.4.0/gcc/fortran/trans-types.c
+--- gcc-4.4.0.orig/gcc/fortran/trans-types.c    2009-03-30 07:53:17.000000000 -0700
++++ gcc-4.4.0/gcc/fortran/trans-types.c 2009-06-03 12:39:09.000000000 -0700
+@@ -595,7 +595,7 @@
+   return make_signed_type (mode_precision);
+ }
+ 
+-static tree
++tree
+ gfc_build_uint_type (int size)
+ {
+   if (size == CHAR_TYPE_SIZE)
+diff -Naur gcc-4.4.0.orig/gcc/fortran/trans-types.h gcc-4.4.0/gcc/fortran/trans-types.h
+--- gcc-4.4.0.orig/gcc/fortran/trans-types.h    2008-05-18 15:45:05.000000000 -0700
++++ gcc-4.4.0/gcc/fortran/trans-types.h 2009-06-03 12:39:09.000000000 -0700
+@@ -68,6 +68,7 @@
+ 
+ tree gfc_type_for_size (unsigned, int);
+ tree gfc_type_for_mode (enum machine_mode, int);
++tree gfc_build_uint_type (int);
+ 
+ tree gfc_get_element_type (tree);
+ tree gfc_get_array_type_bounds (tree, int, tree *, tree *, int,
 diff -Naur gcc-4.4.0.orig/gcc/fwprop.c gcc-4.4.0/gcc/fwprop.c
 --- gcc-4.4.0.orig/gcc/fwprop.c 2009-02-20 07:20:38.000000000 -0800
@@ -1469 +3183 @@
                         if (set_p)
                           SET_BIT (bmap[bb_index], indx);
+diff -Naur gcc-4.4.0.orig/gcc/gimple.h gcc-4.4.0/gcc/gimple.h
+--- gcc-4.4.0.orig/gcc/gimple.h 2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/gimple.h      2009-05-18 03:13:43.000000000 -0700
+@@ -1394,35 +1394,6 @@
+   return (gimple_has_ops (g)) ? (bool) g->gsbase.modified : false;
+ }
+ 
+-/* Return the type of the main expression computed by STMT.  Return
+-   void_type_node if the statement computes nothing.  */
+-
+-static inline tree
+-gimple_expr_type (const_gimple stmt)
+-{
+-  enum gimple_code code = gimple_code (stmt);
+-
+-  if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
+-    {
+-      tree type = TREE_TYPE (gimple_get_lhs (stmt));
+-      /* Integral sub-types are never the type of the expression,
+-         but they still can be the type of the result as the base
+-        type (in which expressions are computed) is trivially
+-        convertible to one of its sub-types.  So always return
+-        the base type here.  */
+-      if (INTEGRAL_TYPE_P (type)
+-         && TREE_TYPE (type)
+-         /* But only if they are trivially convertible.  */
+-         && useless_type_conversion_p (type, TREE_TYPE (type)))
+-       type = TREE_TYPE (type);
+-      return type;
+-    }
+-  else if (code == GIMPLE_COND)
+-    return boolean_type_node;
+-  else
+-    return void_type_node;
+-}
+-
+ 
+ /* Return the tree code for the expression computed by STMT.  This is
+    only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN.  For
+@@ -4285,6 +4256,55 @@
+ }
+ 
+ 
++/* Return the type of the main expression computed by STMT.  Return
++   void_type_node if the statement computes nothing.  */
++
++static inline tree
++gimple_expr_type (const_gimple stmt)
++{
++  enum gimple_code code = gimple_code (stmt);
++
++  if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
++    {
++      tree type;
++      /* In general we want to pass out a type that can be substituted
++         for both the RHS and the LHS types if there is a possibly
++        useless conversion involved.  That means returning the
++        original RHS type as far as we can reconstruct it.  */
++      if (code == GIMPLE_CALL)
++       type = gimple_call_return_type (stmt);
++      else
++       switch (gimple_assign_rhs_code (stmt))
++         {
++         case POINTER_PLUS_EXPR:
++           type = TREE_TYPE (gimple_assign_rhs1 (stmt));
++           break;
++
++         default:
++           /* As fallback use the type of the LHS.  */
++           type = TREE_TYPE (gimple_get_lhs (stmt));
++           break;
++         }
++
++      /* Integral sub-types are never the type of the expression,
++         but they still can be the type of the result as the base
++        type (in which expressions are computed) is trivially
++        convertible to one of its sub-types.  So always return
++        the base type here.  */
++      if (INTEGRAL_TYPE_P (type)
++         && TREE_TYPE (type)
++         /* But only if they are trivially convertible.  */
++         && useless_type_conversion_p (type, TREE_TYPE (type)))
++       type = TREE_TYPE (type);
++      return type;
++    }
++  else if (code == GIMPLE_COND)
++    return boolean_type_node;
++  else
++    return void_type_node;
++}
++
++
+ /* Return a new iterator pointing to GIMPLE_SEQ's first statement.  */
+ 
+ static inline gimple_stmt_iterator
+diff -Naur gcc-4.4.0.orig/gcc/gimplify.c gcc-4.4.0/gcc/gimplify.c
+--- gcc-4.4.0.orig/gcc/gimplify.c       2009-03-11 18:02:16.000000000 -0700
++++ gcc-4.4.0/gcc/gimplify.c    2009-05-12 09:19:29.000000000 -0700
+@@ -1628,20 +1628,63 @@
+        }
+       len = i;
+ 
++      if (!VEC_empty (tree, labels))
++       sort_case_labels (labels);
++
+       if (!default_case)
+        {
+-         gimple new_default;
++         tree type = TREE_TYPE (switch_expr);
+ 
+          /* If the switch has no default label, add one, so that we jump
+-            around the switch body.  */
+-         default_case = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE,
+-                                NULL_TREE, create_artificial_label ());
+-         new_default = gimple_build_label (CASE_LABEL (default_case));
+-         gimplify_seq_add_stmt (&switch_body_seq, new_default);
+-       }
++            around the switch body.  If the labels already cover the whole
++            range of type, add the default label pointing to one of the
++            existing labels.  */
++         if (type == void_type_node)
++           type = TREE_TYPE (SWITCH_COND (switch_expr));
++         if (len
++             && INTEGRAL_TYPE_P (type)
++             && TYPE_MIN_VALUE (type)
++             && TYPE_MAX_VALUE (type)
++             && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
++                                    TYPE_MIN_VALUE (type)))
++           {
++             tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
++             if (!high)
++               high = CASE_LOW (VEC_index (tree, labels, len - 1));
++             if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
++               {
++                 for (i = 1; i < len; i++)
++                   {
++                     high = CASE_LOW (VEC_index (tree, labels, i));
++                     low = CASE_HIGH (VEC_index (tree, labels, i - 1));
++                     if (!low)
++                       low = CASE_LOW (VEC_index (tree, labels, i - 1));
++                     if ((TREE_INT_CST_LOW (low) + 1
++                          != TREE_INT_CST_LOW (high))
++                         || (TREE_INT_CST_HIGH (low)
++                             + (TREE_INT_CST_LOW (high) == 0)
++                             != TREE_INT_CST_HIGH (high)))
++                       break;
++                   }
++                 if (i == len)
++                   default_case = build3 (CASE_LABEL_EXPR, void_type_node,
++                                          NULL_TREE, NULL_TREE,
++                                          CASE_LABEL (VEC_index (tree,
++                                                                 labels, 0)));
++               }
++           }
+ 
+-      if (!VEC_empty (tree, labels))
+-       sort_case_labels (labels);
++         if (!default_case)
++           {
++             gimple new_default;
++
++             default_case = build3 (CASE_LABEL_EXPR, void_type_node,
++                                    NULL_TREE, NULL_TREE,
++                                    create_artificial_label ());
++             new_default = gimple_build_label (CASE_LABEL (default_case));
++             gimplify_seq_add_stmt (&switch_body_seq, new_default);
++           }
++       }
+ 
+       gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr), 
+                                                default_case, labels);
+diff -Naur gcc-4.4.0.orig/gcc/ipa-utils.h gcc-4.4.0/gcc/ipa-utils.h
+--- gcc-4.4.0.orig/gcc/ipa-utils.h      2007-07-26 01:37:01.000000000 -0700
++++ gcc-4.4.0/gcc/ipa-utils.h   2009-05-14 08:52:58.000000000 -0700
+@@ -23,9 +23,6 @@
+ #include "tree.h"
+ #include "cgraph.h"
+ 
+-/* Used for parsing attributes of asm code.  */
+-extern tree memory_identifier_string;
+-
+ struct ipa_dfs_info {
+   int dfn_number;
+   int low_link;
 diff -Naur gcc-4.4.0.orig/gcc/ira-color.c gcc-4.4.0/gcc/ira-color.c
 --- gcc-4.4.0.orig/gcc/ira-color.c      2009-02-20 07:20:38.000000000 -0800
@@ -1532 +3430 @@
 diff -Naur gcc-4.4.0.orig/gcc/ira-conflicts.c gcc-4.4.0/gcc/ira-conflicts.c
 --- gcc-4.4.0.orig/gcc/ira-conflicts.c  2009-03-12 07:39:55.000000000 -0700
-+++ gcc-4.4.0/gcc/ira-conflicts.c       2009-04-22 13:16:13.000000000 -0700
++++ gcc-4.4.0/gcc/ira-conflicts.c       2009-05-03 12:40:35.000000000 -0700
 @@ -411,9 +411,9 @@
      /* Can not be tied.  It is not in the cover class.  */
@@ -1545 +3443 @@
      {
        ira_allocate_and_set_costs
+@@ -806,7 +806,7 @@
+       if ((! flag_caller_saves && ALLOCNO_CALLS_CROSSED_NUM (a) != 0)
+          /* For debugging purposes don't put user defined variables in
+             callee-clobbered registers.  */
+-         || (optimize <= 1
++         || (optimize == 0
+              && (attrs = REG_ATTRS (regno_reg_rtx [ALLOCNO_REGNO (a)])) != NULL
+              && (decl = attrs->decl) != NULL
+              && VAR_OR_FUNCTION_DECL_P (decl)
 diff -Naur gcc-4.4.0.orig/gcc/ira-costs.c gcc-4.4.0/gcc/ira-costs.c
 --- gcc-4.4.0.orig/gcc/ira-costs.c      2008-12-18 05:49:47.000000000 -0800
@@ -1787 +3694 @@
                 (&ALLOCNO_CONFLICT_HARD_REG_COSTS (operand_a), cover_class, 0);
               ALLOCNO_CONFLICT_HARD_REG_COSTS (operand_a)
-diff -Naur gcc-4.4.0.orig/gcc/po/ChangeLog gcc-4.4.0/gcc/po/ChangeLog
---- gcc-4.4.0.orig/gcc/po/ChangeLog     2009-04-21 01:44:44.000000000 -0700
-+++ gcc-4.4.0/gcc/po/ChangeLog  2009-04-22 09:34:22.000000000 -0700
-@@ -1,3 +1,12 @@
-+2009-04-22  Joseph Myers  <joseph@codesourcery.com>
-+
-+       * gcc.pot: Regenerate.
-+
-+2009-04-22  Joseph Myers  <joseph@codesourcery.com>
-+
-+       * exgettext: Also look for */*/config-lang.in to find language
-+       subdirectories.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
+diff -Naur gcc-4.4.0.orig/gcc/Makefile.in gcc-4.4.0/gcc/Makefile.in
+--- gcc-4.4.0.orig/gcc/Makefile.in      2009-03-25 05:00:32.000000000 -0700
++++ gcc-4.4.0/gcc/Makefile.in   2009-05-21 16:17:37.000000000 -0700
+@@ -2785,7 +2785,8 @@
+    value-prof.h $(TREE_INLINE_H) $(TARGET_H)
+ cfgrtl.o : cfgrtl.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
+    $(FLAGS_H) insn-config.h $(BASIC_BLOCK_H) $(REGS_H) hard-reg-set.h \
+-   output.h $(TOPLEV_H) $(FUNCTION_H) except.h $(TM_P_H) insn-config.h $(EXPR_H) \
++   output.h $(TOPLEV_H) $(FUNCTION_H) except.h $(TM_P_H) $(INSN_ATTR_H) \
++   insn-config.h $(EXPR_H) \
+    $(CFGLAYOUT_H) $(CFGLOOP_H) $(OBSTACK_H) $(TARGET_H) $(TREE_H) \
+    tree-pass.h $(DF_H) $(GGC_H)
+ cfganal.o : cfganal.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
 diff -Naur gcc-4.4.0.orig/gcc/po/exgettext gcc-4.4.0/gcc/po/exgettext
 --- gcc-4.4.0.orig/gcc/po/exgettext     2009-04-09 16:23:07.000000000 -0700
@@ -13060 +14964 @@
 +msgid "%<-gnat%> misspelled as %<-gant%>"
 +msgstr ""
+diff -Naur gcc-4.4.0.orig/gcc/reg-stack.c gcc-4.4.0/gcc/reg-stack.c
+--- gcc-4.4.0.orig/gcc/reg-stack.c      2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/reg-stack.c   2009-05-22 11:59:30.000000000 -0700
+@@ -1371,21 +1371,23 @@
+ 
+            if (pat != PATTERN (insn))
+              {
+-               /* The fix_truncdi_1 pattern wants to be able to allocate
+-                  its own scratch register.  It does this by clobbering
+-                  an fp reg so that it is assured of an empty reg-stack
+-                  register.  If the register is live, kill it now.
+-                  Remove the DEAD/UNUSED note so we don't try to kill it
+-                  later too.  */
++               /* The fix_truncdi_1 pattern wants to be able to
++                  allocate its own scratch register.  It does this by
++                  clobbering an fp reg so that it is assured of an
++                  empty reg-stack register.  If the register is live,
++                  kill it now.  Remove the DEAD/UNUSED note so we
++                  don't try to kill it later too.
++
++                  In reality the UNUSED note can be absent in some
++                  complicated cases when the register is reused for
++                  partially set variable.  */
+ 
+                if (note)
+                  emit_pop_insn (insn, regstack, *dest, EMIT_BEFORE);
+                else
+-                 {
+-                   note = find_reg_note (insn, REG_UNUSED, *dest);
+-                   gcc_assert (note);
+-                 }
+-               remove_note (insn, note);
++                 note = find_reg_note (insn, REG_UNUSED, *dest);
++               if (note)
++                 remove_note (insn, note);
+                replace_reg (dest, FIRST_STACK_REG + 1);
+              }
+            else
+diff -Naur gcc-4.4.0.orig/gcc/resource.c gcc-4.4.0/gcc/resource.c
+--- gcc-4.4.0.orig/gcc/resource.c       2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/resource.c    2009-05-21 16:17:37.000000000 -0700
+@@ -135,8 +135,6 @@
+ static int
+ find_basic_block (rtx insn, int search_limit)
+ {
+-  basic_block bb;
+-
+   /* Scan backwards to the previous BARRIER.  Then see if we can find a
+      label that starts a basic block.  Return the basic block number.  */
+   for (insn = prev_nonnote_insn (insn);
+@@ -157,11 +155,8 @@
+   for (insn = next_nonnote_insn (insn);
+        insn && LABEL_P (insn);
+        insn = next_nonnote_insn (insn))
+-    {
+-      FOR_EACH_BB (bb)
+-       if (insn == BB_HEAD (bb))
+-         return bb->index;
+-    }
++    if (BLOCK_FOR_INSN (insn))
++      return BLOCK_FOR_INSN (insn)->index;
+ 
+   return -1;
+ }
+@@ -848,13 +843,12 @@
+    (with no intervening active insns) to see if any of them start a basic
+    block.  If we hit the start of the function first, we use block 0.
+ 
+-   Once we have found a basic block and a corresponding first insns, we can
+-   accurately compute the live status from basic_block_live_regs and
+-   reg_renumber.  (By starting at a label following a BARRIER, we are immune
+-   to actions taken by reload and jump.)  Then we scan all insns between
+-   that point and our target.  For each CLOBBER (or for call-clobbered regs
+-   when we pass a CALL_INSN), mark the appropriate registers are dead.  For
+-   a SET, mark them as live.
++   Once we have found a basic block and a corresponding first insn, we can
++   accurately compute the live status (by starting at a label following a
++   BARRIER, we are immune to actions taken by reload and jump.)  Then we
++   scan all insns between that point and our target.  For each CLOBBER (or
++   for call-clobbered regs when we pass a CALL_INSN), mark the appropriate
++   registers are dead.  For a SET, mark them as live.
+ 
+    We have to be careful when using REG_DEAD notes because they are not
+    updated by such things as find_equiv_reg.  So keep track of registers
+@@ -954,13 +948,10 @@
+      TARGET.  Otherwise, we must assume everything is live.  */
+   if (b != -1)
+     {
+-      regset regs_live = DF_LR_IN (BASIC_BLOCK (b));
++      regset regs_live = df_get_live_in (BASIC_BLOCK (b));
+       rtx start_insn, stop_insn;
+ 
+-      /* Compute hard regs live at start of block -- this is the real hard regs
+-        marked live, plus live pseudo regs that have been renumbered to
+-        hard regs.  */
+-
++      /* Compute hard regs live at start of block.  */
+       REG_SET_TO_HARD_REG_SET (current_live_regs, regs_live);
+ 
+       /* Get starting and ending insn, handling the case where each might
+@@ -1046,10 +1037,24 @@
+ 
+          else if (LABEL_P (real_insn))
+            {
++             basic_block bb;
++
+              /* A label clobbers the pending dead registers since neither
+                 reload nor jump will propagate a value across a label.  */
+              AND_COMPL_HARD_REG_SET (current_live_regs, pending_dead_regs);
+              CLEAR_HARD_REG_SET (pending_dead_regs);
++
++             /* We must conservatively assume that all registers that used
++                to be live here still are.  The fallthrough edge may have
++                left a live register uninitialized.  */
++             bb = BLOCK_FOR_INSN (real_insn);
++             if (bb)
++               {
++                 HARD_REG_SET extra_live;
++
++                 REG_SET_TO_HARD_REG_SET (extra_live, df_get_live_in (bb));
++                 IOR_HARD_REG_SET (current_live_regs, extra_live);
++               }
+            }
+ 
+          /* The beginning of the epilogue corresponds to the end of the
+@@ -1121,6 +1126,7 @@
+ init_resource_info (rtx epilogue_insn)
+ {
+   int i;
++  basic_block bb;
+ 
+   /* Indicate what resources are required to be valid at the end of the current
+      function.  The condition code never is and memory always is.  If the
+@@ -1189,6 +1195,11 @@
+   /* Allocate and initialize the tables used by mark_target_live_regs.  */
+   target_hash_table = XCNEWVEC (struct target_info *, TARGET_HASH_PRIME);
+   bb_ticks = XCNEWVEC (int, last_basic_block);
++
++  /* Set the BLOCK_FOR_INSN of each label that starts a basic block.  */
++  FOR_EACH_BB (bb)
++    if (LABEL_P (BB_HEAD (bb)))
++      BLOCK_FOR_INSN (BB_HEAD (bb)) = bb;
+ }
+ 
+
+ /* Free up the resources allocated to mark_target_live_regs ().  This
+@@ -1197,6 +1208,8 @@
+ void
+ free_resource_info (void)
+ {
++  basic_block bb;
++
+   if (target_hash_table != NULL)
+     {
+       int i;
+@@ -1222,6 +1235,10 @@
+       free (bb_ticks);
+       bb_ticks = NULL;
+     }
++
++  FOR_EACH_BB (bb)
++    if (LABEL_P (BB_HEAD (bb)))
++      BLOCK_FOR_INSN (BB_HEAD (bb)) = NULL;
+ }
+ 
+
+ /* Clear any hashed information that we have stored for INSN.  */
 diff -Naur gcc-4.4.0.orig/gcc/rtl.h gcc-4.4.0/gcc/rtl.h
 --- gcc-4.4.0.orig/gcc/rtl.h    2009-03-18 10:04:26.000000000 -0700
@@ -13083 +15154 @@
        goto restart;
  
-diff -Naur gcc-4.4.0.orig/gcc/testsuite/ChangeLog gcc-4.4.0/gcc/testsuite/ChangeLog
---- gcc-4.4.0.orig/gcc/testsuite/ChangeLog      2009-04-21 01:44:06.000000000 -0700
-+++ gcc-4.4.0/gcc/testsuite/ChangeLog   2009-04-29 08:54:18.000000000 -0700
-@@ -1,3 +1,183 @@
-+2009-04-29  H.J. Lu  <hongjiu.lu@intel.com>
-+
-+       Backport from mainline:
-+       2009-04-29  Richard Guenther  <rguenther@suse.de>
-+
-+       PR middle-end/39937
-+       * gcc.c-torture/compile/pr39937.c: New testcase.
-+
-+2009-04-29  H.J. Lu  <hongjiu.lu@intel.com>
-+
-+       Backport from mainline:
-+       2009-04-29  Richard Guenther  <rguenther@suse.de>
-+
-+       PR tree-optimization/39941
-+       * gcc.c-torture/compile/pr39941.c: New testcase.
-+
-+       2009-04-29  Anmol P. Paralkar  <anmol@freescale.com>
-+
-+       PR target/39565
-+       * gcc.dg/pr39565.c: New testcase.
-+
-+       2009-04-28  Richard Guenther  <rguenther@suse.de>
-+
-+       PR middle-end/39937
-+       * gfortran.fortran-torture/compile/pr39937.f: New testcase.
-+
-+2009-04-28  Jing Yu  <jingyu@google.com>
-+
-+       Backport from mainline:
-+       2009-04-28  Jing Yu  <jingyu@google.com>
-+
-+       PR testsuite/39790
-+       * lib/target-supports.exp (check_effective_target_tls): Remove
-+       comment of caching.
-+       (check_effective_target_tls_native): Likewise.
-+       (check_effective_target_tls_runtime): Likewise.
-+       * gcc.dg/tls/alias-1.c (dg-require-effective-target): Change target
-+       tls to tls_runtime.
-+       * gcc.dg/tls/opt-2.c: Add dg-require-effective-target tls_runtime.
-+
-+2009-04-28  Michael Meissner  <meissner@linux.vnet.ibm.com>
-+
-+       Backport from mainline:
-+       PR testsuite/39769
-+       * gcc.dg/vmx/3a-04.c (test): Don't rely on floating point equality
-+       for testing the results of estimate instructions.
-+       * gcc.dg/vmx/3a-04m.c (test): Ditto.
-+       * gcc.dg/vmx/3a-05.c (test): Ditto.
-+
-+2009-04-28  H.J. Lu  <hongjiu.lu@intel.com>
-+
-+       Backport from mainline:
-+       2009-04-27  H.J. Lu  <hongjiu.lu@intel.com>
-+
-+       PR target/39903
-+       * gcc.dg/torture/pr39903-1.c: New.
-+       * gcc.dg/torture/pr39903-2.c: Likewise.
-+
-+2009-04-27  Jakub Jelinek  <jakub@redhat.com>
-+
-+       PR rtl-optimization/39794
-+       * gcc.dg/pr39794.c: New test.
-+
-+2009-04-26  Jakub Jelinek  <jakub@redhat.com>
-+
-+       PR inline-asm/39543
-+       * gcc.target/i386/pr39543-1.c: New test.
-+       * gcc.target/i386/pr39543-2.c: New test.
-+       * gcc.target/i386/pr39543-3.c: New test.
-+
-+       PR c/39889
-+       * gcc.dg/Wunused-value-3.c: New test.
-+
-+2009-04-24  Paolo Bonzini  <bonzini@gnu.org>
-+
-+       PR middle-end/39867
-+       * gcc.dg/pr39867.c: New.
-+
-+2009-04-23  Dodji Seketeli  <dodji@redhat.com>
-+
-+       PR c++/38228
-+       * g++.dg/expr/bound-mem-fun.C: New test.
-+
-+2009-04-22  Eric Botcazou  <ebotcazou@adacore.com>
-+
-+       * gnat.dg/enum2.adb: New test.
-+       * gnat.dg/enum2_pkg.ads: New helper.
-+
-+2009-04-22  Jakub Jelinek  <jakub@redhat.com>
-+
-+       PR c/39855
-+       * gcc.dg/torture/pr39855.c: New test.
-+
-+2009-04-22  Richard Guenther  <rguenther@suse.de>
-+
-+       PR tree-optimization/39824
-+       * gcc.c-torture/compile/pr39824.c: New testcase.
-+
-+2009-04-22  Dodji Seketeli  <dodji@redhat.com>
-+
-+       PR c++/39639
-+       * g++.dg/cpp0x/pr39639.C: New test.
-+
-+2009-04-22  H.J. Lu  <hongjiu.lu@intel.com>
-+
-+       Backport from mainline:
-+       2009-04-22  Richard Guenther  <rguenther@suse.de>
-+
-+       PR tree-optimization/39845
-+       * gcc.c-torture/compile/pr39845.c: New testcase.
-+
-+       2009-04-21  Richard Guenther  <rguenther@suse.de>
-+
-+       PR middle-end/39829
-+       * gcc.dg/torture/pr39829.c: New testcase.
-+
-+2009-04-12  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       Backport from mainline:
-+
-+       2009-04-17  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       * gfortran.fortran-torture/execute/getarg_1.x: New file.
-+
-+       2009-04-17  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       * gfortran.dg/vect/pr39318.f90: Guard with "target fopenmp".
-+
-+       2009-04-17  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       * gfortran.dg/chmod_1.f90: Disable on spu-*-* targets.
-+       * gfortran.dg/chmod_2.f90: Likewise.
-+       * gfortran.dg/chmod_3.f90: Likewise.
-+       * gfortran.dg/open_errors.f90: Likewise.
-+       * gfortran.dg/stat_1.f90: Likewise.
-+       * gfortran.dg/stat_2.f90: Likewise.
-+
-+       2009-04-17  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       * gfortran.fortran-torture/execute/nan_inf_fmt.x: Skip on spu-*-*.
-+       * gfortran.fortran-torture/execute/intrinsic_nearest.x: Likewise.
-+       * gfortran.fortran-torture/execute/intrinsic_set_exponent.x: Likewise.
-+       * gfortran.dg/nearest_1.f90: Likewise.
-+       * gfortran.dg/nearest_3.f90: Likewise.
-+       * gfortran.dg/isnan_1.f90: Likewise.
-+       * gfortran.dg/isnan_2.f90: Likewise.
-+       * gfortran.dg/nan_1.f90: Likewise.
-+       * gfortran.dg/nan_2.f90: Likewise.
-+       * gfortran.dg/nan_3.f90: Likewise.
-+       * gfortran.dg/nan_4.f90: Likewise.
-+       * gfortran.dg/module_nan.f90: Likewise.
-+       * gfortran.dg/int_conv_2.f90: Likewise.
-+       * gfortran.dg/init_flag_3.f90: Likewise.
-+       * gfortran.dg/namelist_42.f90: Likewise.
-+       * gfortran.dg/namelist_43.f90: Likewise.
-+       * gfortran.dg/real_const_3.f90: Likewise.
-+       * gfortran.dg/transfer_simplify_1.f90: Likewise.
-+
-+       * gfortran.dg/default_format_1.f90: XFAIL on spu-*-*.
-+       * gfortran.dg/default_format_denormal_1.f90: XFAIL on spu-*-*.
-+       * gfortran.dg/scalar_mask_2.f90: XFAIL on spu-*-*.
-+       * gfortran.dg/integer_exponentiation_3.F90: XFAIL on spu-*-*.
-+       * gfortran.dg/integer_exponentiation_5.F90: XFAIL on spu-*-*.
-+
-+       * gfortran.dg/elemental_subroutine_1.f90: Relax "epsilon" check.
-+       * gfortran.dg/gamma_5.f90: Likewise.
-+
-+       2009-04-17  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
-+
-+       * lib/gcc-dg.exp (gcc-dg-prune): Make linker message check
-+       less strict so it also works with auto-overlay support.
-+       * lib/gcc-defs.exp (${tool}_check_unsupported_p): Add check
-+       for "exceeds local store" linker errors on the SPU.
-+
-+       * lib/gfortran.exp: Include target-supports.exp.
-+       (gfortran_init): On SPU targets where automatic overlay support
-+       is available, use it to build all Fortran test cases.
-+
-+       * gfortran.dg/pr20257.f90: Skip on spu-*-* targets.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20000211-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20000211-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20000211-1.c     2000-02-11 11:36:25.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20000211-1.c  2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef long unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef unsigned char Bufbyte;
+ typedef int Bytecount;
+ typedef int Charcount;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20010328-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20010328-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20010328-1.c     2001-03-28 09:46:52.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20010328-1.c  2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef unsigned int __u_int;
+ typedef unsigned long __u_long;
+ 
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20030320-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20030320-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20030320-1.c     2003-03-20 16:13:41.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20030320-1.c  2009-05-28 02:19:37.000000000 -0700
+@@ -2,7 +2,7 @@
+    conditional returns without updating dominance info.
+    Extracted from glibc's dl-load.c.  */
+ 
+-typedef unsigned long size_t;
++typedef __SIZE_TYPE__ size_t;
+ 
+ static size_t
+ is_dst (const char *start, const char *name, const char *str,
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20030405-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20030405-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20030405-1.c     2004-05-12 23:41:07.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20030405-1.c  2009-05-28 02:19:37.000000000 -0700
+@@ -6,7 +6,7 @@
+    and when the PHI node at the end of the while() is visited the first
+    time, CCP will try to assign it a value of UNDEFINED, but the default
+    value for *str is a constant.  */
+-typedef        unsigned int size_t;
++typedef        __SIZE_TYPE__ size_t;
+ size_t strlength (const char * const);
+ char foo();
+ 
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20030902-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20030902-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20030902-1.c     2004-05-12 23:41:07.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20030902-1.c  2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef unsigned long int reg_syntax_t;
+ struct re_pattern_buffer
+ {
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20060202-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20060202-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20060202-1.c     2006-02-02 16:24:50.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20060202-1.c  2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef const struct objc_selector
+ {
+   void *sel_id;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20080613-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20080613-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20080613-1.c     2008-06-13 03:20:57.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20080613-1.c  2009-05-28 02:19:37.000000000 -0700
+@@ -1,7 +1,7 @@
+ /* PR middle-end/36520 */
+ /* Testcase by Richard Guenther <rguenth@gcc.gnu.org> */
+ 
+-typedef long unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef unsigned short int sa_family_t;
+ struct cmsghdr   {
+     size_t cmsg_len;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20090519-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20090519-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/20090519-1.c     1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/20090519-1.c  2009-05-19 04:54:16.000000000 -0700
+@@ -0,0 +1,11 @@
++typedef struct { int licensed;  } __pmPDUInfo;
++void __pmDecodeXtendError (int *);
++void do_handshake(void)
++{
++  __pmPDUInfo *pduinfo;
++  int challenge;
++  __pmDecodeXtendError(&challenge);
++  pduinfo = (__pmPDUInfo *)&challenge;
++  *pduinfo = *pduinfo;
++}
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/920428-2.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/920428-2.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/920428-2.c       1998-12-16 14:24:51.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/920428-2.c    2009-05-28 02:19:37.000000000 -0700
+@@ -41,7 +41,7 @@
+  short _flag;
+  char _file;
+ } _iob[];
+-typedef unsigned long size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef char *va_list;
+ struct _iobuf *fopen(const char *filename, const char *type);
+ struct _iobuf *freopen(const char *filename, const char *type, struct _iobuf *stream);
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/980329-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/980329-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/980329-1.c       1998-12-16 14:24:51.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/980329-1.c    2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned long int size_t;
++typedef __SIZE_TYPE__ size_t;
+ struct re_pattern_buffer
+   {
+     unsigned char *buffer;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/980816-1.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/980816-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/980816-1.c       1998-12-16 14:24:51.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/980816-1.c    2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef void *XtPointer;
+ 
+ typedef struct _WidgetRec *Widget;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr32584.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr32584.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr32584.c        2007-07-02 11:27:46.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr32584.c     2009-05-28 02:19:37.000000000 -0700
+@@ -1,5 +1,8 @@
+-typedef long unsigned int size_t;
+-typedef long int __ssize_t;
++typedef __SIZE_TYPE__ size_t;
++/* Kludge */
++#define unsigned
++typedef __SIZE_TYPE__ __ssize_t;
++#undef unsigned
+ typedef struct
+ {
+ } __mbstate_t;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr33173.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr33173.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr33173.c        2007-08-27 07:18:36.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr33173.c     2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef long unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef struct
+ {
+ }
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr33382.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr33382.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr33382.c        2007-09-12 01:07:12.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr33382.c     2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef struct {
+     int disable;
+     char *searchconfig[];
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr34334.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr34334.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr34334.c        2007-12-04 09:20:34.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr34334.c     2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ __extension__ typedef long long int __quad_t;
+ __extension__ typedef unsigned int __mode_t;
+ __extension__ typedef __quad_t __off64_t;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr34688.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr34688.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr34688.c        2008-01-26 15:08:54.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr34688.c     2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+          typedef struct {
+         }
+          HashTable;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr35043.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr35043.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr35043.c        2008-02-04 05:30:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr35043.c     2009-05-28 02:19:37.000000000 -0700
+@@ -1,4 +1,4 @@
+-typedef long unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef struct   {
+       long double dat[2];
+ } gsl_complex_long_double;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr37669.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr37669.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr37669.c        2008-09-29 14:23:52.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr37669.c     2009-05-28 02:19:37.000000000 -0700
+@@ -1,6 +1,6 @@
+ /* This testcase used to fail because a miscompiled execute_fold_all_builtins. */
+ 
+-typedef long unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ extern __inline __attribute__ ((__always_inline__)) int __attribute__
+ ((__nothrow__)) snprintf (char *__restrict __s, size_t __n, __const char
+ *__restrict __fmt, ...)  {
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr39824.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr39824.c
 --- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr39824.c        1969-12-31 16:00:00.000000000 -0800
@@ -13379 +15450 @@
 +}
 +
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr39983.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr39983.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr39983.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr39983.c     2009-05-06 10:45:40.000000000 -0700
+@@ -0,0 +1,17 @@
++typedef struct {
++    int *p;
++} *A;
++
++extern const int a[1];
++extern const int b[1];
++
++void foo()
++{
++  A x;
++  A y;
++  static const int * const c[] = { b };
++
++  x->p = (int*)c[0];
++  y->p = (int*)a;
++}
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr39999.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr39999.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr39999.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr39999.c     2009-05-18 03:13:43.000000000 -0700
+@@ -0,0 +1,18 @@
++void foo(void *);
++void
++MMAPGCD (int *A1, int *A2)
++{
++  int *t;
++
++  do
++    {
++      t = A1;
++      A1 = A2;
++      A2 = t;
++    }
++  while (A2[-1]);
++
++  foo (A1-1);
++  foo (A2-1);
++}
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40023.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40023.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40023.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40023.c     2009-05-06 10:45:40.000000000 -0700
+@@ -0,0 +1,11 @@
++typedef __builtin_va_list va_list;
++typedef struct {
++    va_list ap;
++} ScanfState;
++void
++GetInt(ScanfState *state, long llval)
++{
++  *__builtin_va_arg(state->ap,long *) = llval;
++  __builtin_va_end(state->ap);
++}
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40026.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40026.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40026.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40026.c     2009-05-11 09:49:17.000000000 -0700
+@@ -0,0 +1,15 @@
++typedef struct {
++    unsigned long bits;
++} S;
++struct T {
++    S span;
++    int flags;
++};
++
++struct T f(int x)
++{
++  return (struct T) {
++      .span = (S) { 0UL },
++      .flags = (x ? 256 : 0),
++  };
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40035.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40035.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40035.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40035.c     2009-05-13 14:42:03.000000000 -0700
+@@ -0,0 +1,20 @@
++typedef __SIZE_TYPE__ size_t;
++void *memmove (void *dest, const void *src, size_t count);
++size_t strlen (const char *s);
++
++int
++foo (char *param, char *val)
++{
++  if (val)
++    {
++      if (val == param + strlen (param) + 1)
++        val[-1] = '=';
++      else if (val == param + strlen (param) + 2)
++        {
++          val[-2] = '=';
++          memmove (val - 1, val, strlen (val) + 1);
++          val--;
++        }
++    }
++  return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40080.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40080.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40080.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40080.c     2009-05-11 09:49:17.000000000 -0700
+@@ -0,0 +1,44 @@
++extern void *ff(void*,int);
++
++struct lpgl { struct lpgl *next; };
++struct lpgd { struct lpgl *first; };
++
++typedef int (*xfn)( );
++static void xDP_IF_EnumGroupsInGroup ( void *a, int b, xfn fn)
++{
++  struct lpgd *lpGData;
++  struct lpgl *lpGList;
++
++  if( ( lpGData = ff( a, b ) ) == ((void *)0) )
++    return;
++
++  if( lpGData->first  == ((void *)0) )
++    return;
++  lpGList = lpGData->first;
++
++  for( ;; ) {
++    if( !(*fn)( ) )
++      return;
++    if( lpGList->next == ((void *)0) )
++      break;
++    lpGList = lpGList->next;
++  }
++  return;
++}
++
++
++static int 
++xcbDeletePlayerFromAllGroups() {
++  xDP_IF_EnumGroupsInGroup(0, 0, 0);
++  return 1;
++}
++
++void xDP_IF_EnumGroups( xfn fn) {
++  xDP_IF_EnumGroupsInGroup( 0, 0, fn);
++}
++
++static void xDP_IF_DestroyPlayer () {
++  xDP_IF_EnumGroups( xcbDeletePlayerFromAllGroups);
++}
++
++void* foo=xDP_IF_DestroyPlayer;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40204.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40204.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40204.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40204.c     2009-05-20 14:11:10.000000000 -0700
+@@ -0,0 +1,14 @@
++/* PR middle-end/40204 */
++
++struct S
++{
++  unsigned int a : 4;
++  unsigned int b : 28;
++} s;
++char c;
++
++void
++f (void)
++{
++  s.a = (c >> 4) & ~(1 << 4);
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40233.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40233.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40233.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40233.c     2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,10 @@
++typedef int aligned __attribute__((aligned(64)));
++struct Frame {
++  aligned i;
++};
++
++void foo(struct Frame *p)
++{
++  aligned *q = &p->i;
++  *q = 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40252.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40252.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40252.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40252.c     2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,6 @@
++typedef unsigned int uint32_t;
++static void IP(uint32_t v[2])
++{
++    v[0] = ((v[0] << 1) | ((v[0] >> 31) & 1L)) & 0xffffffffL;
++}
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40291.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40291.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/compile/pr40291.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/compile/pr40291.c     2009-05-29 08:47:31.000000000 -0700
+@@ -0,0 +1,7 @@
++/* PR middle-end/40291 */
++
++int
++foo (void *x, char *y, unsigned long long z)
++{
++  return memcmp (x, y, z);
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/execute/pr40022.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/execute/pr40022.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/execute/pr40022.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/execute/pr40022.c     2009-05-06 01:32:24.000000000 -0700
+@@ -0,0 +1,51 @@
++extern void abort (void);
++
++struct A
++{
++  struct A *a;
++};
++
++struct B
++{
++  struct A *b;
++};
++
++__attribute__((noinline))
++struct A *
++foo (struct A *x)
++{
++  asm volatile ("" : : "g" (x) : "memory");
++  return x;
++}
++
++__attribute__((noinline))
++void
++bar (struct B *w, struct A *x, struct A *y, struct A *z)
++{
++  struct A **c;
++  c = &w->b;
++  *c = foo (x);
++  while (*c)
++    c = &(*c)->a;
++  *c = foo (y);
++  while (*c)
++    c = &(*c)->a;
++  *c = foo (z);
++}
++
++struct B d;
++struct A e, f, g;
++
++int
++main (void)
++{
++  f.a = &g;
++  bar (&d, &e, &f, 0);
++  if (d.b == 0
++      || d.b->a == 0
++      || d.b->a->a == 0
++      || d.b->a->a->a != 0)
++    abort ();
++  return 0;
++}
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/execute/pr40057.c gcc-4.4.0/gcc/testsuite/gcc.c-torture/execute/pr40057.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.c-torture/execute/pr40057.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.c-torture/execute/pr40057.c     2009-05-07 08:36:23.000000000 -0700
+@@ -0,0 +1,37 @@
++/* PR middle-end/40057 */
++
++extern void abort (void);
++
++__attribute__((noinline)) int
++foo (unsigned long long x)
++{
++  unsigned long long y = (x >> 31ULL) & 1ULL;
++  if (y == 0ULL)
++    return 0;
++  return -1;
++}
++
++__attribute__((noinline)) int
++bar (long long x)
++{
++  long long y = (x >> 31LL) & 1LL;
++  if (y == 0LL)
++    return 0;
++  return -1;
++}
++
++int
++main (void)
++{
++  if (sizeof (long long) != 8)
++    return 0;
++  if (foo (0x1682a9aaaULL))
++    abort ();
++  if (!foo (0x1882a9aaaULL))
++    abort ();
++  if (bar (0x1682a9aaaLL))
++    abort ();
++  if (!bar (0x1882a9aaaLL))
++    abort ();
++  return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/20050629-1.c gcc-4.4.0/gcc/testsuite/gcc.dg/20050629-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/20050629-1.c    2005-06-29 17:51:17.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/20050629-1.c 2009-05-28 02:19:37.000000000 -0700
+@@ -5,7 +5,7 @@
+    contains many warnings, but it exposes a copy propagation bug that
+    is somewhat difficult to reproduce otherwise.  */
+ 
+-typedef long unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+   extern void fancy_abort (const char *, int, const char *) __attribute__ ((__noreturn__));
+   typedef union tree_node *tree;
+   enum tree_code {
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/dfp/pr39986.c gcc-4.4.0/gcc/testsuite/gcc.dg/dfp/pr39986.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/dfp/pr39986.c   1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/dfp/pr39986.c        2009-05-06 10:14:00.000000000 -0700
+@@ -0,0 +1,31 @@
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++/* Check that the compiler generates the correct decimal float constants.  */
++
++_Decimal32 a = 100.223df;
++_Decimal32 b = -2.3df;
++_Decimal64 c = 3.4e-4dd;
++_Decimal64 d = -4.500dd;
++_Decimal128 e = 5678901234567.89e+200dl;
++_Decimal128 f = -678901.234e-6dl;
++
++/* The first value is DPD, the second is BID.  The order differs depending
++   on whether the target is big-endian or little-endian.  */
++
++/* { dg-final { scan-assembler ".long\t(572653859|822183807)\n" } } */
++
++/* { dg-final { scan-assembler ".long\t(-1572863965|-1308622825)\n" } } */
++
++/* { dg-final { scan-assembler ".long\t(52|34)\n" } } */
++/* { dg-final { scan-assembler ".long\t(572784640|824180736)\n" } } */
++
++/* { dg-final { scan-assembler ".long\t(4736|4500)\n" } } */
++/* { dg-final { scan-assembler ".long\t(-1574174720|-1319108608)\n" } } */
++
++/* { dg-final { scan-assembler ".long\t(-1975952433|957645077)\n" } } */
++/* { dg-final { scan-assembler ".long\t(190215|132222)\n" } } */
++/* { dg-final { scan-assembler ".long\t(574193664|835452928)\n" } } */
++
++/* { dg-final { scan-assembler ".long\t(931280180|678901234)\n" } } */
++/* { dg-final { scan-assembler ".long\t(-1576681472|-1339162624)\n" } } */
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr33667.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr33667.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr33667.c       2007-10-05 10:56:52.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/pr33667.c    2009-05-28 02:19:37.000000000 -0700
+@@ -1,7 +1,7 @@
+ /* { dg-do compile } */
+ /* { dg-options "-O2" } */
+ 
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ typedef unsigned char uint8_t;
+ typedef unsigned short int uint16_t;
+ typedef unsigned long long int uint64_t;
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr39565.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr39565.c
 --- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr39565.c       1969-12-31 16:00:00.000000000 -0800
@@ -13430 +15858 @@
 +    abort ();
 +  exit (0);
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr39666-1.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr39666-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr39666-1.c     1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/pr39666-1.c  2009-05-12 09:19:29.000000000 -0700
+@@ -0,0 +1,22 @@
++/* PR middle-end/39666 */
++/* { dg-do compile } */
++/* { dg-options "-O2 -Wuninitialized" } */
++
++int
++foo (int i)
++{
++  int j;
++  switch (i)
++    {
++    case -__INT_MAX__ - 1 ... -1:
++      j = 6;
++      break;
++    case 0:
++      j = 5;
++      break;
++    case 1 ... __INT_MAX__:
++      j = 4;
++      break;
++    }
++  return j;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr39666-2.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr39666-2.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr39666-2.c     1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/pr39666-2.c  2009-05-12 09:19:29.000000000 -0700
+@@ -0,0 +1,22 @@
++/* PR middle-end/39666 */
++/* { dg-do compile } */
++/* { dg-options "-O2 -Wuninitialized" } */
++
++int
++foo (int i)
++{
++  int j;       /* { dg-warning "may be used uninitialized" } */
++  switch (i)
++    {
++    case -__INT_MAX__ - 1 ... -1:
++      j = 6;
++      break;
++    case 0:
++      j = 5;
++      break;
++    case 2 ... __INT_MAX__:
++      j = 4;
++      break;
++    }
++  return j;
 +}
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr39794.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr39794.c
@@ -13484 +15964 @@
 +}
 +
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr40172-1.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr40172-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr40172-1.c     1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/pr40172-1.c  2009-05-19 14:24:23.000000000 -0700
+@@ -0,0 +1,31 @@
++/* PR middle-end/40172 */
++/* { dg-do compile } */
++/* { dg-options "-Wall -W -Werror -Wlogical-op" } */
++
++struct rtx_def;
++typedef struct rtx_def *rtx; 
++
++extern int foo;
++extern int bar;
++extern int xxx;
++
++int
++test (void)
++{
++  if (((rtx) 0 != (rtx) 0) && xxx ? foo : bar)
++    return 1;
++  else if ((foo & 0) && xxx)
++    return 2;
++  else if (foo & 0)
++    return 3;
++  else if (0 && xxx)
++    return 4;
++  else if (0)
++    return 5;
++  if (((int) 0 != (int) 0) && bar ? foo : xxx)
++    return 6;
++  else if (0 != 0 && foo ? xxx : bar)
++    return 7;
++  else
++    return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr40172-2.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr40172-2.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr40172-2.c     1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/pr40172-2.c  2009-05-19 14:24:23.000000000 -0700
+@@ -0,0 +1,16 @@
++/* PR middle-end/40172 */
++/* { dg-do compile } */
++/* { dg-options "-Wall -W -Werror" } */
++
++extern int xxx;
++
++#define XXX xxx
++
++int
++test (void)
++{
++  if (!XXX && xxx)
++    return 4;
++  else
++    return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr40172-3.c gcc-4.4.0/gcc/testsuite/gcc.dg/pr40172-3.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/pr40172-3.c     1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/pr40172-3.c  2009-05-19 14:24:23.000000000 -0700
+@@ -0,0 +1,16 @@
++/* PR middle-end/40172 */
++/* { dg-do compile */
++/* { dg-options "-Wall -W -Werror -Wlogical-op" } */
++
++extern int xxx;
++
++#define XXX xxx
++
++int
++test (void)
++{
++  if (!XXX && xxx)
++    return 4;
++  else
++    return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/prefetch-loop-arrays-1.c gcc-4.4.0/gcc/testsuite/gcc.dg/prefetch-loop-arrays-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/prefetch-loop-arrays-1.c        2006-09-17 18:54:33.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/prefetch-loop-arrays-1.c     2009-05-28 02:19:37.000000000 -0700
+@@ -3,7 +3,7 @@
+ /* { dg-options "-O2 -fprefetch-loop-arrays -w" } */
+ /* { dg-options "-O2 -fprefetch-loop-arrays -march=i686 -msse -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+ 
+-typedef unsigned long size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ 
+ struct re_pattern_buffer
+ {
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tls/alias-1.c gcc-4.4.0/gcc/testsuite/gcc.dg/tls/alias-1.c
 --- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tls/alias-1.c   2007-09-18 19:35:29.000000000 -0700
@@ -13507 +16074 @@
  __thread int thr;
  
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/torture/pr39204.c gcc-4.4.0/gcc/testsuite/gcc.dg/torture/pr39204.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/torture/pr39204.c       2009-02-17 07:01:40.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/torture/pr39204.c    2009-05-28 02:19:37.000000000 -0700
+@@ -1,7 +1,7 @@
+ /* { dg-do compile } */
+ /* { dg-options "-w" } */
+ 
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ typedef unsigned char __u_char;
+ typedef unsigned short int __u_short;
+ typedef unsigned int __u_int;
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/torture/pr39829.c gcc-4.4.0/gcc/testsuite/gcc.dg/torture/pr39829.c
 --- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/torture/pr39829.c       1969-12-31 16:00:00.000000000 -0800
@@ -13622 +16201 @@
 +  return 0;
 +}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/20041122-1.c gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/20041122-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/20041122-1.c   2008-08-20 05:59:10.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/20041122-1.c        2009-05-28 02:19:37.000000000 -0700
+@@ -2,7 +2,7 @@
+ /* { dg-options "-O1 -fdump-tree-dom2" } */
+ 
+ 
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ extern void *xmalloc (size_t) __attribute__ ((__malloc__));
+ struct edge_def
+ {
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/pr36908.c gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/pr36908.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/pr36908.c      2008-11-03 08:35:13.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/pr36908.c   2009-05-28 02:19:37.000000000 -0700
+@@ -2,7 +2,7 @@
+ /* { dg-options "-O2 -ftree-loop-distribution" } */
+ #define NULL ((void *)0)
+ 
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ extern void *foo(size_t nelem, size_t elsize);
+ extern void bar (char*, ...);
+ 
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/pr38250.c gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/pr38250.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/pr38250.c      2008-12-03 05:43:12.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/pr38250.c   2009-05-28 02:19:37.000000000 -0700
+@@ -1,7 +1,7 @@
+ /* { dg-do compile } */
+ /* { dg-options "-O2 -ftree-loop-distribution" } */
+ 
+-typedef long unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ typedef struct   {
+           long dat[2];
+ } gsl_complex_long_double;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/pr40087.c gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/pr40087.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/pr40087.c      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/pr40087.c   2009-05-22 13:43:39.000000000 -0700
+@@ -0,0 +1,30 @@
++/* { dg-do run } */
++/* { dg-options "-O1 " } */
++
++extern void abort (void);
++
++static void __attribute__((always_inline))
++reverse(int *first, int *last)
++{
++  if (first == last--) 
++    return;
++  while (first != last)
++    {
++      int t = *first;
++      *first = *last;
++      *last = t;
++      if (++first == last--)
++        break;
++    }
++}
++
++int main()
++{
++  int seq[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
++
++  reverse(seq, seq + 8);
++  if (seq[3] != 5 || seq[4] != 4)
++    abort ();
++
++  return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c   2007-08-16 13:28:43.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c        2009-05-28 02:19:37.000000000 -0700
+@@ -1,7 +1,7 @@
+ /* { dg-do compile } */
+ /* { dg-options "-O -w -fdump-tree-dse-vops" } */
+ 
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ typedef struct _IO_FILE FILE;
+ typedef struct
+ {
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vect/pr40074.c gcc-4.4.0/gcc/testsuite/gcc.dg/vect/pr40074.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vect/pr40074.c  1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/vect/pr40074.c       2009-05-11 04:54:02.000000000 -0700
+@@ -0,0 +1,54 @@
++/* { dg-require-effective-target vect_int } */
++
++#include <stdarg.h>
++#include "tree-vect.h"
++
++#define N 16 
++
++typedef struct {
++   int a;
++   int b;
++   int c;
++   int d;
++} s;
++
++
++s arr[N] = {{7,0,1,5}, {7,2,3,5}, {7,4,5,5}, {7,6,7,5}, {7,8,9,5}, {7,10,11,5}, {7,12,13,5}, {7,14,15,5}, {7,16,17,5}, {7,18,19,5}, {7,20,21,5}, {7,22,23,5}, {7,24,25,5}, {7,26,27,5}, {7,28,29,5}, {7,30,31,5}};
++
++__attribute__ ((noinline)) int
++main1 ()
++{
++  s *p = arr, *q = arr + 1;
++  int res[N];
++  int i;
++
++  for (i = 0; i < N-1; i++)
++    {
++      res[i] = p->b + p->d + q->b;
++      p++;
++      q++;
++    }
++  
++  /* check results:  */
++  for (i = 0; i < N-1; i++)
++    {
++      if (res[i] != arr[i].b + arr[i].d + arr[i+1].b)
++       abort ();
++    }
++
++  return 0;
++}
++
++int main (void)
++{
++  int i;
++  
++  check_vect ();
++
++  main1 ();
++
++  return 0;
++}
++
++/* { dg-final { cleanup-tree-dump "vect" } } */
++  
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vect/pr40238.c gcc-4.4.0/gcc/testsuite/gcc.dg/vect/pr40238.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vect/pr40238.c  1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/vect/pr40238.c       2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,35 @@
++/* { dg-do compile } */
++
++extern int xdo_rb_ctr_row( int *pos_code);
++
++int xgp_ahd_interpolate (int tile)
++{
++ int p[4];
++
++ switch (tile) {
++ default:
++ case 0:
++ case 1:
++  p[0] = 0; p[1] = 1; p[2] = 2; p[3] = 3;
++  break;
++ case 2:
++ case 3:
++  p[0] = 1; p[1] = 0; p[2] = 3; p[3] = 2;
++  break;
++ case 4:
++ case 5:
++  p[0] = 3; p[1] = 2; p[2] = 1; p[3] = 0;
++  break;
++ case 6:
++ case 7:
++  p[0] = 2; p[1] = 3; p[2] = 0; p[3] = 1;
++  break;
++ }
++
++ xdo_rb_ctr_row(p);
++ xdo_rb_ctr_row(p);
++ return 0;
++}
++
++/* { dg-final { cleanup-tree-dump "vect" } } */
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vect/pr40254.c gcc-4.4.0/gcc/testsuite/gcc.dg/vect/pr40254.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vect/pr40254.c  1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.dg/vect/pr40254.c       2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,39 @@
++#include <stdlib.h>
++#include <stdarg.h>
++#include "tree-vect.h"
++
++struct s
++{
++  int *x;
++  int x1;
++  int x2;
++  int x3;
++  int *y;
++};
++
++struct s arr[64] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
++
++__attribute__ ((noinline)) void
++foo (int i, int *in_x, int *in_y)
++{
++  arr[i].x = in_x;
++  arr[i].y = in_y;
++}
++
++int
++main (void)
++{
++  int a, b;
++
++  check_vect ();
++
++  foo (5, &a, &b);
++
++  if (arr[5].x != &a || arr[5].y != &b)
++    abort ();
++
++  return 0;
++}
++
++/* { dg-final { cleanup-tree-dump "vect" } } */
++
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vmx/3a-04.c gcc-4.4.0/gcc/testsuite/gcc.dg/vmx/3a-04.c
 --- gcc-4.4.0.orig/gcc/testsuite/gcc.dg/vmx/3a-04.c     2004-04-17 18:01:41.000000000 -0700
@@ -13751 +16552 @@
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.target/i386/pr39543-2.c gcc-4.4.0/gcc/testsuite/gcc.target/i386/pr39543-2.c
 --- gcc-4.4.0.orig/gcc/testsuite/gcc.target/i386/pr39543-2.c    1969-12-31 16:00:00.000000000 -0800
-+++ gcc-4.4.0/gcc/testsuite/gcc.target/i386/pr39543-2.c 2009-04-26 11:58:04.000000000 -0700
-@@ -0,0 +1,51 @@
++++ gcc-4.4.0/gcc/testsuite/gcc.target/i386/pr39543-2.c 2009-05-13 13:24:52.000000000 -0700
+@@ -0,0 +1,52 @@
 +/* PR inline-asm/39543 */
 +/* { dg-do compile } */
 +/* { dg-options "-O3" } */
++/* { dg-skip-if "" { ilp32 && { ! nonpic } } { "*" } { "" } } */
 +
 +float __attribute__ ((aligned (16))) s0[128];
@@ -13850 +16652 @@
 +                 "m" (p[30]), "m" (p[32]));
 +}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.target/powerpc/altivec-30.c gcc-4.4.0/gcc/testsuite/gcc.target/powerpc/altivec-30.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.target/powerpc/altivec-30.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.target/powerpc/altivec-30.c     2009-05-29 00:14:20.000000000 -0700
+@@ -0,0 +1,32 @@
++/* { dg-do compile { target powerpc*-*-* } } */
++/* { dg-require-effective-target powerpc_altivec_ok } */
++/* { dg-options "-maltivec" } */
++
++#include <stdbool.h>
++#include <altivec.h>
++
++#define f0(type) void x0##type (vector bool type x) { }
++f0 (int)
++
++#define f1(v, type) void x1##type (v bool type x) { }
++f1 (vector, int)
++
++#define f2(b, type) void x2##type (vector b type x) { }
++f2 (bool, int)
++
++#define f3(v, b, type) void x3##type (v b type x) { }
++f3 (vector, bool, int)
++
++#define f4(v, b, type) void x4##type (v type b x) { }
++f4 (vector, bool, int)
++
++#define B bool
++#define I int
++#define BI bool int
++#define VBI vector bool int
++
++vector bool int a;
++vector B int b;
++vector B I c;
++vector BI d;
++VBI e;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.target/powerpc/altivec-31.c gcc-4.4.0/gcc/testsuite/gcc.target/powerpc/altivec-31.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.target/powerpc/altivec-31.c        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gcc.target/powerpc/altivec-31.c     2009-05-29 00:14:20.000000000 -0700
+@@ -0,0 +1,29 @@
++/* { dg-do compile { target powerpc*-*-* } } */
++/* { dg-require-effective-target powerpc_altivec_ok } */
++/* { dg-options "-maltivec" } */
++
++#define f0(type) void x0##type (vector _Bool type x) { }
++f0 (int)
++
++#define f1(v, type) void x1##type (v _Bool type x) { }
++f1 (vector, int)
++
++#define f2(b, type) void x2##type (vector b type x) { }
++f2 (_Bool, int)
++
++#define f3(v, b, type) void x3##type (v b type x) { }
++f3 (vector, _Bool, int)
++
++#define f4(v, b, type) void x4##type (v type b x) { }
++f4 (vector, _Bool, int)
++
++#define B _Bool
++#define I int
++#define BI _Bool int
++#define VBI vector _Bool int
++
++vector _Bool int a;
++vector B int b;
++vector B I c;
++vector BI d;
++VBI e;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.target/powerpc/altivec-types-1.c gcc-4.4.0/gcc/testsuite/gcc.target/powerpc/altivec-types-1.c
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.target/powerpc/altivec-types-1.c   2008-08-26 14:39:49.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.target/powerpc/altivec-types-1.c        2009-05-29 00:14:20.000000000 -0700
+@@ -24,6 +24,7 @@
+ __vector signed vsj;
+ __vector __bool vbj;
+ __vector float vf;
++__vector _Bool vb;
+ 
+ /* These should be rejected as invalid AltiVec types.  */
+ 
+@@ -37,7 +38,6 @@
+ __vector __bool long long int vblli;   /* { dg-error "AltiVec types" "" } */
+ __vector double vd1;                   /* { dg-error "AltiVec types" "" } */
+ __vector long double vld;              /* { dg-error "AltiVec types" "" } */
+-__vector _Bool vb;                     /* { dg-error "AltiVec types" "" } */
+ __vector _Complex float vcf;           /* { dg-error "AltiVec types" "" } */
+ __vector _Complex double vcd;          /* { dg-error "AltiVec types" "" } */
+ __vector _Complex long double vcld;    /* { dg-error "AltiVec types" "" } */
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gcc.target/x86_64/abi/asm-support.S gcc-4.4.0/gcc/testsuite/gcc.target/x86_64/abi/asm-support.S
+--- gcc-4.4.0.orig/gcc/testsuite/gcc.target/x86_64/abi/asm-support.S    2008-08-28 12:36:58.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gcc.target/x86_64/abi/asm-support.S 2009-05-18 09:54:31.000000000 -0700
+@@ -49,7 +49,9 @@
+        .type   snapshot_ret, @function
+ snapshot_ret:
+        movq    %rdi, rdi(%rip)
++       subq    $8, %rsp
+        call    *callthis(%rip)
++       addq    $8, %rsp
+        movq    %rax, rax(%rip)
+        movq    %rdx, rdx(%rip)
+        movdqu  %xmm0, xmm_regs+0(%rip)
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/auto14.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/auto14.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/auto14.C  1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/auto14.C       2009-06-03 11:11:53.000000000 -0700
+@@ -0,0 +1,29 @@
++// PR c++/40306, c++/40307
++// { dg-options "-std=c++0x" }
++// { dg-do run }
++
++template< typename T >
++struct test {
++   test run() {
++      auto tmp = *this;
++      return tmp;
++   }
++   test run_pass() {
++      test tmp( *this );
++      return tmp;
++   }
++
++   test run_fail() {
++      auto tmp( *this );
++      return tmp;
++   }
++};
++
++int main()
++{
++   test<int> x;
++   x.run();
++   x.run_pass();
++   x.run_fail();
++   return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/enum3.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/enum3.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/enum3.C   1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/enum3.C        2009-05-25 16:07:05.000000000 -0700
+@@ -0,0 +1,17 @@
++// PR c++/38064
++// { dg-options "-std=c++0x" }
++// { dg-do run }
++
++enum class E { elem };
++
++template <class T>
++void f (T t);
++
++bool f (bool b) { return b; }
++
++int main()
++{
++  E e = E::elem;
++  if (!f (e == E::elem))
++    return 1;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist13.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist13.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist13.C      2009-02-03 09:23:11.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist13.C   2009-06-03 11:11:53.000000000 -0700
+@@ -2,4 +2,7 @@
+ // { dg-do compile }
+ // { dg-options "-std=gnu++0x" }
+ 
+-__complex__ int i ({0});       // { dg-error "cannot convert" }
++#include <complex>
++
++__complex__ int i ({0});
++std::complex<int> i2 ({0});
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist15.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist15.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist15.C      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist15.C   2009-05-28 09:09:04.000000000 -0700
+@@ -0,0 +1,17 @@
++// { dg-options "-std=c++0x" }
++
++#include <vector>
++#include <typeinfo>
++
++using namespace std;
++
++template< typename ... ArgTypes >
++void test( ArgTypes ... args ) {
++   vector<type_info*> x = { &typeid(ArgTypes)... }; // { dg-error "" }
++}
++
++int main()
++{
++    test( 1, 3.14f, 2.78 );
++    return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist16.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist16.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist16.C      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist16.C   2009-06-03 11:11:53.000000000 -0700
+@@ -0,0 +1,12 @@
++// { dg-options "-std=c++0x" }
++// { dg-do run }
++
++extern "C" void abort();
++
++void f(int i) { if (i != 42) abort(); }
++
++int main()
++{
++  f({42});
++  return {0};
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist17.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist17.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist17.C      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist17.C   2009-06-03 11:11:53.000000000 -0700
+@@ -0,0 +1,9 @@
++// { dg-options "-std=c++0x" }
++
++void f(int i);
++
++int main()
++{
++  f({42.0});                   // { dg-error "narrowing" }
++  return {1.0};                        // { dg-error "narrowing" }
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist18.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist18.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist18.C      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist18.C   2009-06-03 11:11:53.000000000 -0700
+@@ -0,0 +1,19 @@
++// PR c++/40308, 40311
++// { dg-do run }
++// { dg-options "-std=c++0x" }
++
++template< typename T >
++struct test {
++   test() : data{} {}
++
++   T data;
++};
++
++int main()
++{
++   test<int> x;
++   test<int*> y;
++   int * a = new int{};
++   int * b = new int{5};
++   return 0;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist19.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist19.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/initlist19.C      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/initlist19.C   2009-06-03 11:11:53.000000000 -0700
+@@ -0,0 +1,8 @@
++// { dg-options "-std=c++0x" }
++
++void f(double);
++int main()
++{
++  f({{1}});                    // { dg-error "too many braces" }
++  // { dg-error "" "" { target *-*-* } 6 } allow other errors, too
++}
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/pr39639.C gcc-4.4.0/gcc/testsuite/g++.dg/cpp0x/pr39639.C
 --- gcc-4.4.0.orig/gcc/testsuite/g++.dg/cpp0x/pr39639.C 1969-12-31 16:00:00.000000000 -0800
@@ -13874 +16928 @@
 +}
 +
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/debug/dwarf2/nested-1.C gcc-4.4.0/gcc/testsuite/g++.dg/debug/dwarf2/nested-1.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/debug/dwarf2/nested-1.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/debug/dwarf2/nested-1.C      2009-05-18 12:24:17.000000000 -0700
+@@ -0,0 +1,29 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR debug/40109
++// { dg-do compile }
++// { dg-options  "-g -dA -O0" }
++
++namespace A
++{
++
++  class B
++  {
++  };
++  typedef A::B AB;
++};
++
++int
++main()
++{
++  A::AB ab;
++  return 0;
++}
++
++// { dg-final { scan-assembler "DW_TAG_typedef" } }
++//
++// What we want to do here is to be sure that the DIE of A::AB is generated
++// as a child of the DIE of the namespace A declaration.
++// So this test won't catch a regression on this fix yet. To write a proper
++// test for this fix, we would need a dwarf reader written in tcl,
++// or something along those lines.
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/eh/nested-try.C gcc-4.4.0/gcc/testsuite/g++.dg/eh/nested-try.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/eh/nested-try.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/eh/nested-try.C      2009-05-11 09:49:17.000000000 -0700
+@@ -0,0 +1,25 @@
++// { dg-do compile }
++// Nested try statements shadowing each other was crashing in EH edge redirection.
++// PR middle-end/40043
++struct A
++{
++  ~A();
++  void foo();
++};
++
++void bar()
++{
++  A a;
++
++  try
++  {
++    A b;
++
++    try
++    {
++      b.foo();
++    }
++    catch (int) {}
++  }
++  catch (int) {}
++}
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/expr/bound-mem-fun.C gcc-4.4.0/gcc/testsuite/g++.dg/expr/bound-mem-fun.C
 --- gcc-4.4.0.orig/gcc/testsuite/g++.dg/expr/bound-mem-fun.C    1969-12-31 16:00:00.000000000 -0800
@@ -13896 +17012 @@
 +
 +
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/ext/altivec-15.C gcc-4.4.0/gcc/testsuite/g++.dg/ext/altivec-15.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/ext/altivec-15.C        2008-03-25 20:32:13.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/g++.dg/ext/altivec-15.C     2009-04-30 10:53:23.000000000 -0700
+@@ -2,12 +2,15 @@
+ /* { dg-require-effective-target powerpc_altivec_ok } */
+ /* { dg-options "-maltivec" } */
+ 
++/* This test was added for an internal compiler error.  The number and
++   content of error messages is irrelevant.  */
++
+ struct SubData
+ {
+     inline const Float Clamp(Float f, Float f0, Float f1) // { dg-error "" }
+     }
+     inline const void SinCos(Float angle, Float& sine, Float& cosine) // { dg-error "" }
+     {
+-        C0 = __builtin_vec_splat(_simdCosEstCoefficients, 0); // { dg-error "" }
+-        C1 = __builtin_vec_splat(_simdCosEstCoefficients, 1); // { dg-error "" }
++        C0 = __builtin_vec_splat(_simdCosEstCoefficients, 0);
++        C1 = __builtin_vec_splat(_simdCosEstCoefficients, 1);
+ 
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/ext/packed6.C gcc-4.4.0/gcc/testsuite/g++.dg/ext/packed6.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/ext/packed6.C   2004-05-31 14:24:31.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/g++.dg/ext/packed6.C        2009-05-28 02:37:31.000000000 -0700
+@@ -1,7 +1,7 @@
+ // PR c++/15209
+ // { dg-options "-w" }
+ 
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ typedef unsigned char uint8_t;
+ typedef unsigned short int uint16_t;
+ 
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/ext/vla7.C gcc-4.4.0/gcc/testsuite/g++.dg/ext/vla7.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/ext/vla7.C      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/ext/vla7.C   2009-05-04 23:41:33.000000000 -0700
+@@ -0,0 +1,30 @@
++// PR c++/40013
++// { dg-options "" }
++
++template <class T>
++struct A
++{
++  struct B
++  {
++    struct
++    {
++      int fn () { return 0; }
++    } b;
++  };
++  void test ();
++};
++
++template <class T>
++void
++A <T>::test ()
++{
++  B a;
++  int vla[a.b.fn ()];
++}
++
++int
++main ()
++{
++  A <char> a;
++  a.test ();
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/opt/memcpy1.C gcc-4.4.0/gcc/testsuite/g++.dg/opt/memcpy1.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/opt/memcpy1.C   2007-12-10 14:30:02.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/opt/memcpy1.C        2009-05-28 02:37:31.000000000 -0700
+@@ -6,7 +6,7 @@
+ 
+ typedef unsigned char uint8_t;
+ typedef uint8_t uint8;
+-typedef long unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ class csVector2
+ {
+ public:float x;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/pr37742.C gcc-4.4.0/gcc/testsuite/g++.dg/pr37742.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/pr37742.C       2008-11-05 04:17:10.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/pr37742.C    2009-05-28 02:37:31.000000000 -0700
+@@ -1,6 +1,6 @@
+ /* { dg-do compile } */
+ 
+-typedef long unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ void*   __valarray_get_memory(size_t __n);
+ int*__restrict__
+ __valarray_get_storage(size_t __n)
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/call7.C gcc-4.4.0/gcc/testsuite/g++.dg/template/call7.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/call7.C        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/call7.C     2009-05-06 13:43:41.000000000 -0700
+@@ -0,0 +1,19 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin: PR c++/17395
++// { dg-do "compile" }
++
++template<int> struct X { };
++
++void fu(int a, X<sizeof(a)>) { }
++
++template<class T>
++void bhar(T a, X<sizeof(a)>) { }
++
++int
++main()
++{
++  int x;
++  X<sizeof(int)> y;
++  fu(x, y);
++  bhar(x, y);
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-1.C gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-1.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-1.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-1.C      2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,18 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/39754
++// { dg-do "compile" }
++
++template < typename > struct A ;
++template < typename T , typename = A < T > > struct B { } ;
++template < class W , class > struct D
++{
++  typedef W X ;
++  A<X*> a ;
++};
++
++template < class Y > struct E
++{
++  B<Y*> b ;
++} ;
++E<int> e ;
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-2.C gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-2.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-2.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-2.C      2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,18 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/39754
++// { dg-do "compile" }
++
++template < typename > struct A ;
++template < typename T , typename = A < T > > struct B { } ;
++template < class W , class > struct D
++{
++  typedef W X ;
++  A< X()> a ;
++};
++
++template < class Y > struct E
++{
++  B< Y()> b ;
++};
++E<int> e ;
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-3.C gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-3.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-3.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-3.C      2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,20 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/39754
++// { dg-do "compile" }
++
++template<typename> struct A ;
++template<typename T , typename = A<T> > struct B { } ;
++template<class W , class > struct D
++{
++  typedef W X ;
++  typedef X (FP) ();
++  A<FP&> a ;
++} ;
++
++template < class Y > struct E
++{
++  typedef Y (FP) ();
++  B<FP&> b ;
++} ;
++E < int > e ;
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-4.C gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-4.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-4.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-4.C      2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,22 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/39754
++// { dg-do "compile" }
++
++template<typename> struct A ;
++template<typename T ,typename = A<T> > struct B { } ;
++
++template<class W, class>
++struct D
++{
++  typedef W X;
++  A<X[2]> a;
++} ;
++
++template<class Y>
++struct E
++{
++  B<Y[2]> b;
++};
++
++E < int > e;
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-5.C gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-5.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-5.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-5.C      2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,22 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/39754
++// { dg-do "compile" }
++
++struct Foo {};
++template<typename> struct A ;
++template<typename T ,typename = A<T> > struct B { } ;
++
++template<class W, class>
++struct D
++{
++  typedef W X ;
++  A<X Foo::*> a ;
++} ;
++
++template<class Y>
++struct E
++{
++  B<Y Foo::*> b ;
++} ;
++E < int > e ;
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-6.C gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-6.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-6.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-6.C      2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,22 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/39754
++// { dg-do "compile" }
++
++struct Foo {};
++template<typename> struct A ;
++template<typename T ,typename = A<T> > struct B { } ;
++
++template<class W, class>
++struct D
++{
++  typedef W X;
++  A<void (Foo::*) (X)> a;
++} ;
++
++template<class Y>
++struct E
++{
++  B<void (Foo::*) (Y)> b;
++};
++E < int > e ;
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-7.C gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-7.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/canon-type-7.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/canon-type-7.C      2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,21 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/39754
++// { dg-do "compile" }
++
++struct Foo {};
++template<typename> struct A ;
++template<typename T ,typename = A<T> > struct B { } ;
++
++template<class W, class>
++struct D
++{
++  typedef W X;
++  A<X (Foo::*) (X)> a ;
++};
++
++template<class Y>
++struct E
++{
++  B<Y (Foo::*) (Y)> b ;
++};
++E<int> e ;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/dtor6.C gcc-4.4.0/gcc/testsuite/g++.dg/template/dtor6.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/dtor6.C        1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/dtor6.C     2009-05-17 13:34:30.000000000 -0700
+@@ -0,0 +1,10 @@
++// PR c++/40139
++
++template<int> struct A
++{
++  static int i;
++};
++
++template<int N> int A<N>::i = { A::~A }; // { dg-error "" }
++
++template class A<0>;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/typedef18.C gcc-4.4.0/gcc/testsuite/g++.dg/template/typedef18.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/typedef18.C    1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/typedef18.C 2009-05-30 06:49:33.000000000 -0700
+@@ -0,0 +1,24 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/40007
++// { dg-do compile }
++
++template<typename T>
++struct x
++{
++  protected:
++  typedef int type;
++};
++
++template<typename T>
++struct y : public x<T>
++{
++  typename x<T>::type z;
++};
++
++template<>
++struct y<void> : public x<void>
++{
++  typedef x<void>::type z;
++};
++
++template class y<int>;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/typedef19.C gcc-4.4.0/gcc/testsuite/g++.dg/template/typedef19.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/typedef19.C    1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/typedef19.C 2009-05-30 16:46:31.000000000 -0700
+@@ -0,0 +1,21 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/40007
++// { dg-do compile }
++
++class A
++{
++  typedef int mytype; // { dg-error "'typedef int A::mytype' is private" "" { xfail *-*-* } }
++};
++
++template <class T>
++class B : public A
++{
++};
++
++template<class T>
++class B<T*> : public A
++{ // { dg-error "within this context" "" { xfail *-*-* } }
++  mytype mem;
++};
++
++B<int*> b;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/typedef20.C gcc-4.4.0/gcc/testsuite/g++.dg/template/typedef20.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/template/typedef20.C    1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/template/typedef20.C 2009-05-30 16:46:31.000000000 -0700
+@@ -0,0 +1,27 @@
++// Contributed by Dodji Seketeli <dodji@redhat.com>
++// Origin PR c++/40007
++// { dg-do compile }
++
++class x
++{
++  typedef int privtype; // { dg-error "is private" "" { xfail *-*-* } }
++
++protected:
++  typedef int type;
++};
++
++template<typename T>
++struct y : public x
++{
++  typename x::type z;
++};
++
++template<typename T>
++struct y<T*> : public x
++{ // { dg-error "within this context" "" { xfail *-*-* } }
++  typedef x::type good;
++  typedef x::privtype bad;
++};
++
++template class y<int>;
++template class y<int*>;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/20070621-1.C gcc-4.4.0/gcc/testsuite/g++.dg/torture/20070621-1.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/20070621-1.C    2007-06-21 05:00:47.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/g++.dg/torture/20070621-1.C 2009-05-28 02:37:31.000000000 -0700
+@@ -6,7 +6,7 @@
+ 
+ */
+ 
+-typedef long int ptrdiff_t;
++__extension__ typedef __PTRDIFF_TYPE__ ptrdiff_t;
+ namespace std __attribute__ ((__visibility__ ("default"))) {
+     template<typename, typename>     struct __are_same     {
+         enum {
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/pr34222.C gcc-4.4.0/gcc/testsuite/g++.dg/torture/pr34222.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/pr34222.C       2007-12-04 09:20:34.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/torture/pr34222.C    2009-05-28 02:37:31.000000000 -0700
+@@ -3,7 +3,7 @@
+ namespace std __attribute__ ((__visibility__ ("default"))) {
+     template<class _CharT>     struct char_traits;
+   }
+-typedef long int ptrdiff_t;
++__extension__ typedef __PTRDIFF_TYPE__ ptrdiff_t;
+ namespace std __attribute__ ((__visibility__ ("default"))) {
+     typedef ptrdiff_t streamsize;
+     template<typename _CharT, typename _Traits = char_traits<_CharT> >     class basic_ifstream;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/pr34850.C gcc-4.4.0/gcc/testsuite/g++.dg/torture/pr34850.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/pr34850.C       2008-01-21 01:34:19.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/torture/pr34850.C    2009-05-28 02:37:31.000000000 -0700
+@@ -5,7 +5,7 @@
+ typedef unsigned int uint32_t;
+ typedef uint8_t byte;
+ typedef uint32_t u32bit;
+-typedef unsigned int size_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ extern "C" {
+     extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("")));
+     extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__))
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/pr40335.C gcc-4.4.0/gcc/testsuite/g++.dg/torture/pr40335.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/torture/pr40335.C       1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/torture/pr40335.C    2009-06-04 05:37:48.000000000 -0700
+@@ -0,0 +1,16 @@
++/* { dg-do run } */
++
++extern "C" void abort (void);
++int
++main (void)
++{
++  int i = -1; 
++  switch ((signed char) i)
++    {
++      case 255: /* { dg-bogus "exceeds maximum value" "" { xfail *-*-* } } */
++       abort ();
++      default:
++       break;
++    }
++}
++
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/tree-ssa/pr22444.C gcc-4.4.0/gcc/testsuite/g++.dg/tree-ssa/pr22444.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/tree-ssa/pr22444.C      2007-03-30 12:45:57.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/g++.dg/tree-ssa/pr22444.C   2009-05-28 02:37:31.000000000 -0700
+@@ -4,8 +4,8 @@
+ // with the subvars leading to the subvars not being renamed when they should
+ // { dg-do compile }
+ // { dg-options "-O2" }
+-typedef int ptrdiff_t;
+-typedef unsigned int size_t;
++__extension__ typedef __PTRDIFF_TYPE__ ptrdiff_t;
++__extension__ typedef __SIZE_TYPE__ size_t;
+ namespace std
+ {
+   template<class _T1, class _T2> struct pair
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/warn/Wuninitialized-4.C gcc-4.4.0/gcc/testsuite/g++.dg/warn/Wuninitialized-4.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/warn/Wuninitialized-4.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/warn/Wuninitialized-4.C      2009-05-12 09:19:29.000000000 -0700
+@@ -0,0 +1,22 @@
++// PR middle-end/39666
++// { dg-do compile }
++// { dg-options "-O2 -Wuninitialized" }
++
++int
++foo (int i)
++{
++  int j;
++  switch (i)
++    {
++    case -__INT_MAX__ - 1 ... -1:
++      j = 6;
++      break;
++    case 0:
++      j = 5;
++      break;
++    case 1 ... __INT_MAX__:
++      j = 4;
++      break;
++    }
++  return j;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.dg/warn/Wuninitialized-5.C gcc-4.4.0/gcc/testsuite/g++.dg/warn/Wuninitialized-5.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.dg/warn/Wuninitialized-5.C 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/g++.dg/warn/Wuninitialized-5.C      2009-05-12 09:19:29.000000000 -0700
+@@ -0,0 +1,22 @@
++// PR middle-end/39666
++// { dg-do compile }
++// { dg-options "-O2 -Wuninitialized" }
++
++int
++foo (int i)
++{
++  int j;       // { dg-warning "may be used uninitialized" }
++  switch (i)
++    {
++    case -__INT_MAX__ - 1 ... -1:
++      j = 6;
++      break;
++    case 0:
++      j = 5;
++      break;
++    case 2 ... __INT_MAX__:
++      j = 4;
++      break;
++    }
++  return j;
++}
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/alloc_comp_assign_10.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/alloc_comp_assign_10.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/alloc_comp_assign_10.f90   1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/alloc_comp_assign_10.f90        2009-05-10 03:44:22.000000000 -0700
+@@ -0,0 +1,61 @@
++! { dg-do run }
++!
++! Test the fix for PR39879, in which gfc gagged on the double
++! defined assignment where the rhs had a default initialiser.
++!
++! Contributed by David Sagan <david.sagan@gmail.com>
++!
++module test_struct
++  interface assignment (=)
++    module procedure tao_lat_equal_tao_lat
++  end interface
++  type bunch_params_struct
++    integer n_live_particle          
++  end type
++  type tao_lattice_struct
++    type (bunch_params_struct), allocatable :: bunch_params(:)
++    type (bunch_params_struct), allocatable :: bunch_params2(:)
++  end type
++  type tao_universe_struct
++    type (tao_lattice_struct), pointer :: model, design
++    character(200), pointer :: descrip => NULL()
++  end type
++  type tao_super_universe_struct
++    type (tao_universe_struct), allocatable :: u(:)          
++  end type
++  type (tao_super_universe_struct), save, target :: s
++  contains
++    subroutine tao_lat_equal_tao_lat (lat1, lat2)
++      implicit none
++      type (tao_lattice_struct), intent(inout) :: lat1
++      type (tao_lattice_struct), intent(in) :: lat2
++      if (allocated(lat2%bunch_params)) then
++        lat1%bunch_params = lat2%bunch_params
++      end if 
++      if (allocated(lat2%bunch_params2)) then
++        lat1%bunch_params2 = lat2%bunch_params2
++      end if 
++    end subroutine
++end module
++
++program tao_program
++  use test_struct
++  implicit none
++  type (tao_universe_struct), pointer :: u
++  integer n, i
++  allocate (s%u(1))
++  u => s%u(1)
++  allocate (u%design, u%model)
++  n = 112
++  allocate (u%model%bunch_params(0:n), u%design%bunch_params(0:n))
++  u%design%bunch_params%n_live_particle = [(i, i = 0, n)]
++  u%model = u%design
++  u%model = u%design ! The double assignment was the cause of the ICE
++  if (.not. allocated (u%model%bunch_params)) call abort
++  if (any (u%model%bunch_params%n_live_particle .ne. [(i, i = 0, n)])) call abort
++  Deallocate (u%model%bunch_params, u%design%bunch_params)
++  deallocate (u%design, u%model)
++  deallocate (s%u)
++end program
++
++! { dg-final { cleanup-modules "test_struct" } }
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/array_constructor_31.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/array_constructor_31.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/array_constructor_31.f90   1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/array_constructor_31.f90        2009-05-10 09:14:37.000000000 -0700
+@@ -0,0 +1,10 @@
++! { dg-do compile }
++! Test the fix for pr40018 in which the elements in the array
++! constructor would be of default type and this would cause an
++! ICE in the backend because of the type mistmatch with 'i'.
++!
++! Contributed by Francois-Xavier Coudert <fxcoudert@gcc.gnu.org>
++!
++  integer(kind=8) :: i
++  write(*,*) [(i, i = 1, 10)]
++  end
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/assumed_charlen_dummy.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/assumed_charlen_dummy.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/assumed_charlen_dummy.f90  1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/assumed_charlen_dummy.f90       2009-06-04 10:01:45.000000000 -0700
+@@ -0,0 +1,10 @@
++! { dg-do compile }
++! Test the fix for PR fortran/39893.
++! Original testcase provided by Deji Akingunola.
++! Reduced testcase provided by Dominique d'Humieres.
++!
++      SUBROUTINE XAUTOGET()
++      CHARACTER*(*) DICBA    ! { dg-error "Entity with assumed character" }
++      DATA DICBA /"CLIP" /
++      RETURN
++      END
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/chmod_1.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_1.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/chmod_1.f90        2008-04-30 13:24:46.000000000 -0700
-+++ gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_1.f90     2009-04-22 04:35:25.000000000 -0700
-@@ -1,4 +1,4 @@
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_1.f90     2009-05-09 20:35:53.000000000 -0700
+@@ -1,5 +1,6 @@
 -! { dg-do run { target { ! *-*-mingw* } } }
-+! { dg-do run { target { ! { *-*-mingw* spu-*-* } } } }
++! { dg-do run { target { ! { *-*-mingw* *-*-cygwin* spu-*-* } } } }
  ! { dg-options "-std=gnu" }
++! See PR38956.  Test fails on cygwin when user has Administrator rights
    implicit none
    character(len=*), parameter :: n = "foobar_file"
+   integer :: i
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/chmod_2.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_2.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/chmod_2.f90        2008-04-30 13:24:46.000000000 -0700
-+++ gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_2.f90     2009-04-22 04:35:25.000000000 -0700
-@@ -1,4 +1,4 @@
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_2.f90     2009-05-09 20:35:53.000000000 -0700
+@@ -1,5 +1,6 @@
 -! { dg-do run { target { ! *-*-mingw* } } }
-+! { dg-do run { target { ! { *-*-mingw* spu-*-* } } } }
++! { dg-do run { target { ! { *-*-mingw* *-*-cygwin* spu-*-* } } } }
  ! { dg-options "-std=gnu" }
++! See PR38956.  Test fails on cygwin when user has Administrator rights
    implicit none
    character(len=*), parameter :: n = "foobar_file"
+   integer :: i
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/chmod_3.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_3.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/chmod_3.f90        2008-04-30 13:24:46.000000000 -0700
-+++ gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_3.f90     2009-04-22 04:35:25.000000000 -0700
-@@ -1,4 +1,4 @@
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/chmod_3.f90     2009-05-09 20:35:53.000000000 -0700
+@@ -1,5 +1,6 @@
 -! { dg-do run { target { ! *-*-mingw* } } }
-+! { dg-do run { target { ! { *-*-mingw* spu-*-* } } } }
++! { dg-do run { target { ! { *-*-mingw* *-*-cygwin* spu-*-* } } } }
  ! { dg-options "-std=gnu -fdefault-integer-8" }
++! See PR38956.  Test fails on cygwin when user has Administrator rights
    implicit none
    character(len=*), parameter :: n = "foobar_file"
+   integer :: i
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/default_format_1.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/default_format_1.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/default_format_1.f90       2008-05-11 02:55:34.000000000 -0700
-+++ gcc-4.4.0/gcc/testsuite/gfortran.dg/default_format_1.f90    2009-04-22 04:35:25.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/default_format_1.f90    2009-05-16 04:01:47.000000000 -0700
 @@ -1,4 +1,4 @@
 -! { dg-do run }
-+! { dg-do run { xfail spu-*-* } }
++! { dg-do run { xfail spu-*-*  } }
  ! Test XFAILed on Darwin because the system's printf() lacks
  ! proper support for denormals.
@@ -13934 +17653 @@
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/default_format_denormal_1.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/default_format_denormal_1.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/default_format_denormal_1.f90      2008-12-09 23:49:40.000000000 -0800
-+++ gcc-4.4.0/gcc/testsuite/gfortran.dg/default_format_denormal_1.f90   2009-04-22 04:35:25.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/default_format_denormal_1.f90   2009-05-16 04:01:47.000000000 -0700
 @@ -1,4 +1,4 @@
 -! { dg-do run { xfail alpha*-*-* *-*-darwin[89]* *-*-freebsd* *-*-mingw* } }
-+! { dg-do run { xfail alpha*-*-* *-*-darwin[89]* *-*-freebsd* *-*-mingw* spu-*-* } }
++! { dg-do run { xfail alpha*-*-* *-*-darwin[89]* *-*-freebsd* *-*-mingw* *-*-cygwin* spu-*-* } }
  ! Test XFAILed on these platforms because the system's printf() lacks
  ! proper support for denormals.
  !
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/dependency_24.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/dependency_24.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/dependency_24.f90  1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/dependency_24.f90       2009-05-10 08:34:55.000000000 -0700
+@@ -0,0 +1,82 @@
++! { dg-do run }
++! Check the fix for PR38863 comment #1, where defined assignment
++! to derived types was not treating components correctly that were
++! not set explicitly.
++!
++! Contributed by Mikael Morin  <mikael@gcc.gnu.org>
++!
++module m
++  type t
++    integer :: i,j
++  end type t
++  type ti
++    integer :: i,j = 99
++  end type ti
++  interface assignment (=)
++    module procedure i_to_t, i_to_ti
++  end interface
++contains 
++  elemental subroutine i_to_ti (p, q)
++    type(ti), intent(out) :: p
++    integer, intent(in)  :: q
++    p%i = q
++  end subroutine
++  elemental subroutine i_to_t (p, q)
++    type(t), intent(out) :: p
++    integer, intent(in)  :: q
++    p%i = q
++  end subroutine
++end module
++
++  use m
++  call test_t  ! Check original problem
++  call test_ti ! Default initializers were treated wrongly
++contains
++  subroutine test_t
++    type(t), target :: a(3)
++    type(t), target  :: b(3)
++    type(t), dimension(:), pointer :: p
++    logical :: l(3)
++
++    a%i = 1
++    a%j = [101, 102, 103]
++    b%i = 3
++    b%j = 4
++
++    p => b
++    l = .true.
++
++    where (l)
++      a = p%i         ! Comment #1 of PR38863 concerned WHERE assignment
++    end where
++    if (any (a%j .ne. [101, 102, 103])) call abort
++
++    a = p%i           ! Ordinary assignment was wrong too.
++    if (any (a%j .ne. [101, 102, 103])) call abort
++  end subroutine
++
++  subroutine test_ti
++    type(ti), target :: a(3)
++    type(ti), target  :: b(3)
++    type(ti), dimension(:), pointer :: p
++    logical :: l(3)
++
++    a%i = 1
++    a%j = [101, 102, 103]
++    b%i = 3
++    b%j = 4
++
++    p => b
++    l = .true.
++
++    where (l)
++      a = p%i
++    end where
++    if (any (a%j .ne. 99)) call abort
++
++    a = p%i
++    if (any (a%j .ne. 99)) call abort
++  end subroutine
++end
++! { dg-final { cleanup-modules "m" } }
++
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/elemental_subroutine_1.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/elemental_subroutine_1.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/elemental_subroutine_1.f90 2007-09-17 23:34:30.000000000 -0700
@@ -14027 +17832 @@
    implicit none
    character(len=1) :: s
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/leadz_trailz_1.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/leadz_trailz_1.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/leadz_trailz_1.f90 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/leadz_trailz_1.f90      2009-06-03 12:39:09.000000000 -0700
+@@ -0,0 +1,133 @@
++! { dg-do run }
++
++  integer(kind=1) :: i1
++  integer(kind=2) :: i2
++  integer(kind=4) :: i4
++  integer(kind=8) :: i8
++
++  i1 = -1
++  i2 = -1
++  i4 = -1
++  i8 = -1
++
++  if (leadz(i1) /= 0) call abort
++  if (leadz(i2) /= 0) call abort
++  if (leadz(i4) /= 0) call abort
++  if (leadz(i8) /= 0) call abort
++
++  if (trailz(i1) /= 0) call abort
++  if (trailz(i2) /= 0) call abort
++  if (trailz(i4) /= 0) call abort
++  if (trailz(i8) /= 0) call abort
++
++  if (leadz(-1_1) /= 0) call abort
++  if (leadz(-1_2) /= 0) call abort
++  if (leadz(-1_4) /= 0) call abort
++  if (leadz(-1_8) /= 0) call abort
++
++  if (trailz(-1_1) /= 0) call abort
++  if (trailz(-1_2) /= 0) call abort
++  if (trailz(-1_4) /= 0) call abort
++  if (trailz(-1_8) /= 0) call abort
++
++  i1 = -64
++  i2 = -64
++  i4 = -64
++  i8 = -64
++
++  if (leadz(i1) /= 0) call abort
++  if (leadz(i2) /= 0) call abort
++  if (leadz(i4) /= 0) call abort
++  if (leadz(i8) /= 0) call abort
++
++  if (trailz(i1) /= 6) call abort
++  if (trailz(i2) /= 6) call abort
++  if (trailz(i4) /= 6) call abort
++  if (trailz(i8) /= 6) call abort
++
++  if (leadz(-64_1) /= 0) call abort
++  if (leadz(-64_2) /= 0) call abort
++  if (leadz(-64_4) /= 0) call abort
++  if (leadz(-64_8) /= 0) call abort
++
++  if (trailz(-64_1) /= 6) call abort
++  if (trailz(-64_2) /= 6) call abort
++  if (trailz(-64_4) /= 6) call abort
++  if (trailz(-64_8) /= 6) call abort
++
++  i1 = -108
++  i2 = -108
++  i4 = -108
++  i8 = -108
++
++  if (leadz(i1) /= 0) call abort
++  if (leadz(i2) /= 0) call abort
++  if (leadz(i4) /= 0) call abort
++  if (leadz(i8) /= 0) call abort
++
++  if (trailz(i1) /= 2) call abort
++  if (trailz(i2) /= 2) call abort
++  if (trailz(i4) /= 2) call abort
++  if (trailz(i8) /= 2) call abort
++
++  if (leadz(-108_1) /= 0) call abort
++  if (leadz(-108_2) /= 0) call abort
++  if (leadz(-108_4) /= 0) call abort
++  if (leadz(-108_8) /= 0) call abort
++
++  if (trailz(-108_1) /= 2) call abort
++  if (trailz(-108_2) /= 2) call abort
++  if (trailz(-108_4) /= 2) call abort
++  if (trailz(-108_8) /= 2) call abort
++
++  i1 = 1
++  i2 = 1
++  i4 = 1
++  i8 = 1
++
++  if (leadz(i1) /= bit_size(i1) - 1) call abort
++  if (leadz(i2) /= bit_size(i2) - 1) call abort
++  if (leadz(i4) /= bit_size(i4) - 1) call abort
++  if (leadz(i8) /= bit_size(i8) - 1) call abort
++
++  if (trailz(i1) /= 0) call abort
++  if (trailz(i2) /= 0) call abort
++  if (trailz(i4) /= 0) call abort
++  if (trailz(i8) /= 0) call abort
++
++  if (leadz(1_1) /= bit_size(1_1) - 1) call abort
++  if (leadz(1_2) /= bit_size(1_2) - 1) call abort
++  if (leadz(1_4) /= bit_size(1_4) - 1) call abort
++  if (leadz(1_8) /= bit_size(1_8) - 1) call abort
++
++  if (trailz(1_1) /= 0) call abort
++  if (trailz(1_2) /= 0) call abort
++  if (trailz(1_4) /= 0) call abort
++  if (trailz(1_8) /= 0) call abort
++
++  i1 = 64
++  i2 = 64
++  i4 = 64
++  i8 = 64
++
++  if (leadz(i1) /= 1) call abort
++  if (leadz(i2) /= 9) call abort
++  if (leadz(i4) /= 25) call abort
++  if (leadz(i8) /= 57) call abort
++
++  if (trailz(i1) /= 6) call abort
++  if (trailz(i2) /= 6) call abort
++  if (trailz(i4) /= 6) call abort
++  if (trailz(i8) /= 6) call abort
++
++  if (leadz(64_1) /= 1) call abort
++  if (leadz(64_2) /= 9) call abort
++  if (leadz(64_4) /= 25) call abort
++  if (leadz(64_8) /= 57) call abort
++
++  if (trailz(64_1) /= 6) call abort
++  if (trailz(64_2) /= 6) call abort
++  if (trailz(64_4) /= 6) call abort
++  if (trailz(64_8) /= 6) call abort
++
++end
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/leadz_trailz_2.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/leadz_trailz_2.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/leadz_trailz_2.f90 1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/leadz_trailz_2.f90      2009-06-03 12:39:09.000000000 -0700
+@@ -0,0 +1,36 @@
++! { dg-do run }
++! { dg-require-effective-target fortran_large_int }
++
++  integer(kind=16) :: i16
++
++  i16 = -1
++  if (leadz(i16) /= 0) call abort
++  if (trailz(i16) /= 0) call abort
++  if (leadz(-1_16) /= 0) call abort
++  if (trailz(-1_16) /= 0) call abort
++
++  i16 = -64
++  if (leadz(i16) /= 0) call abort
++  if (trailz(i16) /= 6) call abort
++  if (leadz(-64_16) /= 0) call abort
++  if (trailz(-64_16) /= 6) call abort
++
++  i16 = -108
++  if (leadz(i16) /= 0) call abort
++  if (trailz(i16) /= 2) call abort
++  if (leadz(-108_16) /= 0) call abort
++  if (trailz(-108_16) /= 2) call abort
++
++  i16 = 1
++  if (leadz(i16) /= bit_size(i16) - 1) call abort
++  if (trailz(i16) /= 0) call abort
++  if (leadz(1_16) /= bit_size(1_16) - 1) call abort
++  if (trailz(1_16) /= 0) call abort
++
++  i16 = 64
++  if (leadz(i16) /= 121) call abort
++  if (trailz(i16) /= 6) call abort
++  if (leadz(64_16) /= 121) call abort
++  if (trailz(64_16) /= 6) call abort
++
++end
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/module_nan.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/module_nan.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/module_nan.f90     2008-12-09 23:49:40.000000000 -0800
@@ -14125 +18107 @@
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/open_errors.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/open_errors.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/open_errors.f90    2008-04-30 13:24:46.000000000 -0700
-+++ gcc-4.4.0/gcc/testsuite/gfortran.dg/open_errors.f90 2009-04-22 04:35:25.000000000 -0700
-@@ -1,4 +1,4 @@
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/open_errors.f90 2009-05-09 20:35:53.000000000 -0700
+@@ -1,6 +1,7 @@
 -! { dg-do run { target { ! *-*-mingw* } } }
-+! { dg-do run { target { ! { *-*-mingw* spu-*-* } } } }
++! { dg-do run { target { ! { *-*-mingw* *-*-cygwin* spu-*-* } } } }
  ! PR30005 Enhanced error messages for OPEN
  ! Submitted by Jerry DeLisle  <jvdelisle@gcc.gnu.org>
++! See PR38956.  Test fails on cygwin when user has Administrator rights
  character(60) :: msg
+ character(25) :: n = "temptestfile"
+ logical :: there
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/pr20257.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/pr20257.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/pr20257.f90        2008-03-04 16:59:34.000000000 -0800
@@ -14141 +18126 @@
    real(8) array(10000)
  
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/pr39666-1.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/pr39666-1.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/pr39666-1.f90      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/pr39666-1.f90   2009-05-12 09:19:29.000000000 -0700
+@@ -0,0 +1,14 @@
++! PR middle-end/39666
++! { dg-do compile }
++! { dg-options "-O2 -Wuninitialized" }
++
++FUNCTION f(n)
++  INTEGER, INTENT(in) :: n
++  REAL                :: f
++
++  SELECT CASE (n)
++    CASE (:-1); f = -1.0
++    CASE (0);   f =  0.0
++    CASE (1:);  f =  1.0
++  END SELECT
++END FUNCTION
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/pr39666-2.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/pr39666-2.f90
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/pr39666-2.f90      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.dg/pr39666-2.f90   2009-05-12 09:19:29.000000000 -0700
+@@ -0,0 +1,14 @@
++! PR middle-end/39666
++! { dg-do compile }
++! { dg-options "-O2 -Wuninitialized" }
++
++FUNCTION f(n)  ! { dg-warning "may be used uninitialized" }
++  INTEGER, INTENT(in) :: n
++  REAL                :: f
++
++  SELECT CASE (n)
++    CASE (:-1); f = -1.0
++    CASE (0);   f =  0.0
++    CASE (2:);  f =  1.0
++  END SELECT
++END FUNCTION
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/real_const_3.f90 gcc-4.4.0/gcc/testsuite/gfortran.dg/real_const_3.f90
 --- gcc-4.4.0.orig/gcc/testsuite/gfortran.dg/real_const_3.f90   2008-12-09 23:49:40.000000000 -0800
@@ -14272 +18293 @@
  add-ieee-options
  return 0
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/gfortran.fortran-torture/execute/pr40021.f gcc-4.4.0/gcc/testsuite/gfortran.fortran-torture/execute/pr40021.f
+--- gcc-4.4.0.orig/gcc/testsuite/gfortran.fortran-torture/execute/pr40021.f     1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/gcc/testsuite/gfortran.fortran-torture/execute/pr40021.f  2009-05-06 10:45:40.000000000 -0700
+@@ -0,0 +1,40 @@
++C Derived from lapack
++        PROGRAM test
++        DOUBLE PRECISION DA
++        INTEGER I, N
++        DOUBLE PRECISION DX(9),DY(9)
++
++        EXTERNAL DAXPY
++        N=5
++        DA=1.0
++        DATA DX/-2, -1, -3, -4, 1, 2, 10, 15, 14/
++        DATA DY/0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0/
++        CALL DAXPY (N,DA,DX,DY)
++        DO 10 I = 1, N
++          if (DX(I).ne.DY(I)) call abort
++10      CONTINUE
++        STOP
++        END
++
++      SUBROUTINE DAXPY(N,DA,DX,DY)
++      DOUBLE PRECISION DA
++      INTEGER N
++      DOUBLE PRECISION DX(*),DY(*)
++      INTEGER I,IX,IY,M,MP1
++      INTRINSIC MOD
++      IF (N.LE.0) RETURN
++   20 M = MOD(N,4)
++      IF (M.EQ.0) GO TO 40
++      DO 30 I = 1,M
++          DY(I) = DY(I) + DA*DX(I)
++   30 CONTINUE
++      IF (N.LT.4) RETURN
++   40 MP1 = M + 1
++      DO 50 I = MP1,N,4
++          DY(I) = DY(I) + DA*DX(I)
++          DY(I+1) = DY(I+1) + DA*DX(I+1)
++          DY(I+2) = DY(I+2) + DA*DX(I+2)
++          DY(I+3) = DY(I+3) + DA*DX(I+3)
++   50 CONTINUE
++      RETURN
++      END
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/gnat.dg/enum2.adb gcc-4.4.0/gcc/testsuite/gnat.dg/enum2.adb
 --- gcc-4.4.0.orig/gcc/testsuite/gnat.dg/enum2.adb      1969-12-31 16:00:00.000000000 -0800
@@ -14299 +18364 @@
 +  Null_String : constant F_String := (Controlled with Data => null);
 +end Enum2_Pkg;
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.old-deja/g++.brendan/array1.C gcc-4.4.0/gcc/testsuite/g++.old-deja/g++.brendan/array1.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.old-deja/g++.brendan/array1.C      2003-04-30 19:02:59.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/g++.old-deja/g++.brendan/array1.C   2009-05-26 23:37:45.000000000 -0700
+@@ -3,5 +3,5 @@
+ // GROUPS passed array-bindings
+ 
+ extern "C" int printf (const char *, ...);
+-char array[~(~0ul>>1)|~(0ul>>3)];  // { dg-error "" } overflow in array dimension.*
++char array[~(~((__SIZE_TYPE__)0ul)>>1)|~(((__SIZE_TYPE__)0ul)>>3)];  // { dg-error "" } overflow in array dimension.*
+ int main () { printf ("PASS\n"); return 0; }
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C gcc-4.4.0/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C     2003-04-30 19:02:59.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C  2009-05-26 23:37:45.000000000 -0700
+@@ -1,6 +1,6 @@
+ // { dg-do assemble  }
+ // GROUPS passed old-abort
+-typedef long unsigned int size_t;
++typedef __SIZE_TYPE__ size_t;
+ typedef void (*RF_Ptr)(void *);
+ 
+ struct _im_pers_mem_spec {
+@@ -9,7 +9,7 @@
+ };
+ 
+ struct _type_desc {
+-  _type_desc(char *, int , RF_Ptr , int , int ,...);
++  _type_desc(const char *, int , RF_Ptr , int , int ,...);
+ };
+ 
+ struct metatype { int base_list; };
+diff -Naur gcc-4.4.0.orig/gcc/testsuite/g++.old-deja/g++.jason/new3.C gcc-4.4.0/gcc/testsuite/g++.old-deja/g++.jason/new3.C
+--- gcc-4.4.0.orig/gcc/testsuite/g++.old-deja/g++.jason/new3.C  2003-04-30 19:02:59.000000000 -0700
++++ gcc-4.4.0/gcc/testsuite/g++.old-deja/g++.jason/new3.C       2009-05-26 23:37:45.000000000 -0700
+@@ -1,5 +1,5 @@
+ // { dg-do run  }
+-// { dg-options "-fcheck-new -pedantic" }
++// { dg-options "-fcheck-new -pedantic -Wno-long-long" }
+ // PRMS Id: 6037
+ 
+ extern "C" void * malloc (__SIZE_TYPE__);
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/lib/gcc-defs.exp gcc-4.4.0/gcc/testsuite/lib/gcc-defs.exp
 --- gcc-4.4.0.orig/gcc/testsuite/lib/gcc-defs.exp       2009-03-19 15:10:22.000000000 -0700
@@ -14352 +18457 @@
 diff -Naur gcc-4.4.0.orig/gcc/testsuite/lib/target-supports.exp gcc-4.4.0/gcc/testsuite/lib/target-supports.exp
 --- gcc-4.4.0.orig/gcc/testsuite/lib/target-supports.exp        2009-03-16 14:11:57.000000000 -0700
-+++ gcc-4.4.0/gcc/testsuite/lib/target-supports.exp     2009-04-28 13:57:42.000000000 -0700
-@@ -544,8 +544,6 @@
++++ gcc-4.4.0/gcc/testsuite/lib/target-supports.exp     2009-05-12 01:41:28.000000000 -0700
+@@ -466,6 +466,11 @@
+        return 0
+     }
+ 
++    # cygwin does not support -p.
++    if { [istarget *-*-cygwin*] && [lindex $test_what 1] == "-p" } {
++       return 0
++    }
++
+     # uClibc does not have gcrt1.o.
+     if { [check_effective_target_uclibc]
+         && ([lindex $test_what 1] == "-p"
+@@ -544,8 +549,6 @@
  }
  
@@ -14362 +18479 @@
  proc check_effective_target_tls {} {
      return [check_no_compiler_messages tls assembly {
-@@ -556,8 +554,6 @@
+@@ -556,8 +559,6 @@
  }
  
@@ -14371 +18488 @@
  proc check_effective_target_tls_native {} {
      # VxWorks uses emulated TLS machinery, but with non-standard helper
-@@ -575,8 +571,6 @@
+@@ -575,8 +576,6 @@
  }
  
@@ -14400 +18517 @@
    GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
  #else
+diff -Naur gcc-4.4.0.orig/gcc/tree.h gcc-4.4.0/gcc/tree.h
+--- gcc-4.4.0.orig/gcc/tree.h   2009-03-23 09:29:33.000000000 -0700
++++ gcc-4.4.0/gcc/tree.h        2009-06-02 00:18:16.000000000 -0700
+@@ -5088,7 +5088,7 @@
+ 
+ /* Generate a new label for the CFI info to refer to.  */
+ 
+-extern char *dwarf2out_cfi_label (void);
++extern char *dwarf2out_cfi_label (bool);
+ 
+ /* Entry point to update the canonical frame address (CFA).  */
+ 
+@@ -5256,6 +5256,9 @@
+ 
+ void init_inline_once (void);
+ 
++/* In ipa-reference.c.  Used for parsing attributes of asm code.  */
++extern GTY(()) tree memory_identifier_string;
++
+ /* Compute the number of operands in an expression node NODE.  For 
+    tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
+    otherwise it is looked up from the node's code.  */
+diff -Naur gcc-4.4.0.orig/gcc/tree-inline.c gcc-4.4.0/gcc/tree-inline.c
+--- gcc-4.4.0.orig/gcc/tree-inline.c    2009-03-08 15:37:26.000000000 -0700
++++ gcc-4.4.0/gcc/tree-inline.c 2009-05-27 23:52:15.000000000 -0700
+@@ -501,7 +501,7 @@
+              && (var_ann (old_var) || !gimple_in_ssa_p (cfun)))
+            cfun->local_decls = tree_cons (NULL_TREE, old_var,
+                                                   cfun->local_decls);
+-         if (debug_info_level > DINFO_LEVEL_TERSE
++         if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
+              && !DECL_IGNORED_P (old_var)
+              && nonlocalized_list)
+            VEC_safe_push (tree, gc, *nonlocalized_list, origin_var);
+@@ -519,7 +519,7 @@
+        ;
+       else if (!new_var)
+         {
+-         if (debug_info_level > DINFO_LEVEL_TERSE
++         if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
+              && !DECL_IGNORED_P (old_var)
+              && nonlocalized_list)
+            VEC_safe_push (tree, gc, *nonlocalized_list, origin_var);
+diff -Naur gcc-4.4.0.orig/gcc/tree-scalar-evolution.c gcc-4.4.0/gcc/tree-scalar-evolution.c
+--- gcc-4.4.0.orig/gcc/tree-scalar-evolution.c  2009-03-04 09:50:20.000000000 -0800
++++ gcc-4.4.0/gcc/tree-scalar-evolution.c       2009-05-08 05:28:01.000000000 -0700
+@@ -1320,11 +1320,7 @@
+ 
+   *evolution_of_loop = evolution_of_branch;
+ 
+-  /* If the phi node is just a copy, do not increase the limit.  */
+   n = gimple_phi_num_args (condition_phi);
+-  if (n > 1)
+-    limit++;
+-
+   for (i = 1; i < n; i++)
+     {
+       /* Quickly give up when the evolution of one of the branches is
+@@ -1332,10 +1328,12 @@
+       if (*evolution_of_loop == chrec_dont_know)
+        return t_true;
+ 
++      /* Increase the limit by the PHI argument number to avoid exponential
++        time and memory complexity.  */
+       res = follow_ssa_edge_in_condition_phi_branch (i, loop, condition_phi,
+                                                     halting_phi,
+                                                     &evolution_of_branch,
+-                                                    init, limit);
++                                                    init, limit + i);
+       if (res == t_false || res == t_dont_know)
+        return res;
+ 
 diff -Naur gcc-4.4.0.orig/gcc/tree-ssa-ccp.c gcc-4.4.0/gcc/tree-ssa-ccp.c
 --- gcc-4.4.0.orig/gcc/tree-ssa-ccp.c   2009-04-16 02:39:20.000000000 -0700
@@ -14414 +18603 @@
         break;
        }
+diff -Naur gcc-4.4.0.orig/gcc/tree-ssa-forwprop.c gcc-4.4.0/gcc/tree-ssa-forwprop.c
+--- gcc-4.4.0.orig/gcc/tree-ssa-forwprop.c      2009-02-20 07:20:38.000000000 -0800
++++ gcc-4.4.0/gcc/tree-ssa-forwprop.c   2009-05-19 04:54:16.000000000 -0700
+@@ -683,6 +683,7 @@
+   tree *rhsp, *lhsp;
+   gimple use_stmt = gsi_stmt (*use_stmt_gsi);
+   enum tree_code rhs_code;
++  bool res = true;
+ 
+   gcc_assert (TREE_CODE (def_rhs) == ADDR_EXPR);
+ 
+@@ -726,19 +727,26 @@
+   /* Now see if the LHS node is an INDIRECT_REF using NAME.  If so, 
+      propagate the ADDR_EXPR into the use of NAME and fold the result.  */
+   if (TREE_CODE (lhs) == INDIRECT_REF
+-      && TREE_OPERAND (lhs, 0) == name
+-      && may_propagate_address_into_dereference (def_rhs, lhs)
+-      && (lhsp != gimple_assign_lhs_ptr (use_stmt)
+-         || useless_type_conversion_p (TREE_TYPE (TREE_OPERAND (def_rhs, 0)),
+-                                       TREE_TYPE (rhs))))
++      && TREE_OPERAND (lhs, 0) == name)
+     {
+-      *lhsp = unshare_expr (TREE_OPERAND (def_rhs, 0));
+-      fold_stmt_inplace (use_stmt);
+-      tidy_after_forward_propagate_addr (use_stmt);
++      if (may_propagate_address_into_dereference (def_rhs, lhs)
++         && (lhsp != gimple_assign_lhs_ptr (use_stmt)
++             || useless_type_conversion_p
++                  (TREE_TYPE (TREE_OPERAND (def_rhs, 0)), TREE_TYPE (rhs))))
++       {
++         *lhsp = unshare_expr (TREE_OPERAND (def_rhs, 0));
++         fold_stmt_inplace (use_stmt);
++         tidy_after_forward_propagate_addr (use_stmt);
+ 
+-      /* Continue propagating into the RHS if this was not the only use.  */
+-      if (single_use_p)
+-       return true;
++         /* Continue propagating into the RHS if this was not the only use.  */
++         if (single_use_p)
++           return true;
++       }
++      else
++       /* We can have a struct assignment dereferencing our name twice.
++          Note that we didn't propagate into the lhs to not falsely
++          claim we did when propagating into the rhs.  */
++       res = false;
+     }
+ 
+   /* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
+@@ -758,7 +766,7 @@
+       *rhsp = unshare_expr (TREE_OPERAND (def_rhs, 0));
+       fold_stmt_inplace (use_stmt);
+       tidy_after_forward_propagate_addr (use_stmt);
+-      return true;
++      return res;
+     }
+ 
+   /* Now see if the RHS node is an INDIRECT_REF using NAME.  If so, 
+@@ -789,7 +797,7 @@
+                                             true, GSI_NEW_STMT);
+         gimple_assign_set_rhs1 (use_stmt, new_rhs);
+         tidy_after_forward_propagate_addr (use_stmt);
+-        return true;
++        return res;
+        }
+      /* If the defining rhs comes from an indirect reference, then do not
+         convert into a VIEW_CONVERT_EXPR.  */
+@@ -803,7 +811,7 @@
+         *rhsp = new_rhs;
+         fold_stmt_inplace (use_stmt);
+         tidy_after_forward_propagate_addr (use_stmt);
+-        return true;
++        return res;
+        }
+    }
+ 
 diff -Naur gcc-4.4.0.orig/gcc/tree-ssa-live.c gcc-4.4.0/gcc/tree-ssa-live.c
 --- gcc-4.4.0.orig/gcc/tree-ssa-live.c  2009-03-17 10:53:01.000000000 -0700
-+++ gcc-4.4.0/gcc/tree-ssa-live.c       2009-04-22 15:24:45.000000000 -0700
++++ gcc-4.4.0/gcc/tree-ssa-live.c       2009-05-27 23:49:43.000000000 -0700
 @@ -595,6 +595,8 @@
     /* Verfify that only blocks with source location set
@@ -14426 +18691 @@
  }
  
+@@ -678,6 +680,12 @@
+   var_ann_t ann;
+   bitmap global_unused_vars = NULL;
+ 
++  /* Removing declarations from lexical blocks when not optimizing is
++     not only a waste of time, it actually causes differences in stack
++     layout.  */
++  if (!optimize)
++    return;
++
+   mark_scope_block_unused (DECL_INITIAL (current_function_decl));
+ 
+   /* Assume all locals are unused.  */
+@@ -740,8 +748,7 @@
+ 
+       if (TREE_CODE (var) != FUNCTION_DECL
+          && (!(ann = var_ann (var))
+-             || !ann->used)
+-         && (optimize || DECL_ARTIFICIAL (var)))
++             || !ann->used))
+        {
+          if (is_global_var (var))
+            {
+@@ -802,8 +809,7 @@
+        && TREE_CODE (t) != RESULT_DECL
+        && !(ann = var_ann (t))->used
+        && !ann->symbol_mem_tag
+-       && !TREE_ADDRESSABLE (t)
+-       && (optimize || DECL_ARTIFICIAL (t)))
++       && !TREE_ADDRESSABLE (t))
+       remove_referenced_var (t);
+   remove_unused_scope_block_p (DECL_INITIAL (current_function_decl));
+   if (dump_file && (dump_flags & TDF_DETAILS))
+diff -Naur gcc-4.4.0.orig/gcc/tree-ssa-loop-niter.c gcc-4.4.0/gcc/tree-ssa-loop-niter.c
+--- gcc-4.4.0.orig/gcc/tree-ssa-loop-niter.c    2009-03-16 09:07:07.000000000 -0700
++++ gcc-4.4.0/gcc/tree-ssa-loop-niter.c 2009-05-22 13:43:39.000000000 -0700
+@@ -534,7 +534,7 @@
+ }
+ 
+ /* Derives the upper bound BND on the number of executions of loop with exit
+-   condition S * i <> C, assuming that the loop is not infinite.  If
++   condition S * i <> C, assuming that this exit is taken.  If
+    NO_OVERFLOW is true, then the control variable of the loop does not
+    overflow.  If NO_OVERFLOW is true or BNDS.below >= 0, then BNDS.up
+    contains the upper bound on the value of C.  */
+@@ -574,7 +574,7 @@
+ 
+ /* Determines number of iterations of loop whose ending condition
+    is IV <> FINAL.  TYPE is the type of the iv.  The number of
+-   iterations is stored to NITER.  NEVER_INFINITE is true if
++   iterations is stored to NITER.  EXIT_MUST_BE_TAKEN is true if
+    we know that the exit must be taken eventually, i.e., that the IV
+    ever reaches the value FINAL (we derived this earlier, and possibly set
+    NITER->assumptions to make sure this is the case).  BNDS contains the
+@@ -582,7 +582,7 @@
+ 
+ static bool
+ number_of_iterations_ne (tree type, affine_iv *iv, tree final,
+-                        struct tree_niter_desc *niter, bool never_infinite,
++                        struct tree_niter_desc *niter, bool exit_must_be_taken,
+                         bounds *bnds)
+ {
+   tree niter_type = unsigned_type_for (type);
+@@ -639,9 +639,9 @@
+                               build_int_cst (niter_type, 1), bits);
+   s = fold_binary_to_constant (RSHIFT_EXPR, niter_type, s, bits);
+ 
+-  if (!never_infinite)
++  if (!exit_must_be_taken)
+     {
+-      /* If we cannot assume that the loop is not infinite, record the
++      /* If we cannot assume that the exit is taken eventually, record the
+         assumptions for divisibility of c.  */
+       assumption = fold_build2 (FLOOR_MOD_EXPR, niter_type, c, d);
+       assumption = fold_build2 (EQ_EXPR, boolean_type_node,
+@@ -664,20 +664,21 @@
+    of the final value does not overflow are recorded in NITER.  If we
+    find the final value, we adjust DELTA and return TRUE.  Otherwise
+    we return false.  BNDS bounds the value of IV1->base - IV0->base,
+-   and will be updated by the same amount as DELTA.  */
++   and will be updated by the same amount as DELTA.  EXIT_MUST_BE_TAKEN is
++   true if we know that the exit must be taken eventually.  */
+ 
+ static bool
+ number_of_iterations_lt_to_ne (tree type, affine_iv *iv0, affine_iv *iv1,
+                               struct tree_niter_desc *niter,
+                               tree *delta, tree step,
+-                              bounds *bnds)
++                              bool exit_must_be_taken, bounds *bnds)
+ {
+   tree niter_type = TREE_TYPE (step);
+   tree mod = fold_build2 (FLOOR_MOD_EXPR, niter_type, *delta, step);
+   tree tmod;
+   mpz_t mmod;
+   tree assumption = boolean_true_node, bound, noloop;
+-  bool ret = false;
++  bool ret = false, fv_comp_no_overflow;
+   tree type1 = type;
+   if (POINTER_TYPE_P (type))
+     type1 = sizetype;
+@@ -692,17 +693,31 @@
+   mpz_set_double_int (mmod, tree_to_double_int (mod), true);
+   mpz_neg (mmod, mmod);
+ 
++  /* If the induction variable does not overflow and the exit is taken,
++     then the computation of the final value does not overflow.  This is
++     also obviously the case if the new final value is equal to the
++     current one.  Finally, we postulate this for pointer type variables,
++     as the code cannot rely on the object to that the pointer points being
++     placed at the end of the address space (and more pragmatically,
++     TYPE_{MIN,MAX}_VALUE is not defined for pointers).  */
++  if (integer_zerop (mod) || POINTER_TYPE_P (type))
++    fv_comp_no_overflow = true;
++  else if (!exit_must_be_taken)
++    fv_comp_no_overflow = false;
++  else
++    fv_comp_no_overflow =
++           (iv0->no_overflow && integer_nonzerop (iv0->step))
++           || (iv1->no_overflow && integer_nonzerop (iv1->step));
++
+   if (integer_nonzerop (iv0->step))
+     {
+       /* The final value of the iv is iv1->base + MOD, assuming that this
+         computation does not overflow, and that
+         iv0->base <= iv1->base + MOD.  */
+-      if (!iv0->no_overflow && !integer_zerop (mod))
++      if (!fv_comp_no_overflow)
+        {
+          bound = fold_build2 (MINUS_EXPR, type1,
+                               TYPE_MAX_VALUE (type1), tmod);
+-         if (POINTER_TYPE_P (type))
+-           bound = fold_convert (type, bound);
+          assumption = fold_build2 (LE_EXPR, boolean_type_node,
+                                    iv1->base, bound);
+          if (integer_zerop (assumption))
+@@ -726,12 +741,10 @@
+       /* The final value of the iv is iv0->base - MOD, assuming that this
+         computation does not overflow, and that
+         iv0->base - MOD <= iv1->base. */
+-      if (!iv1->no_overflow && !integer_zerop (mod))
++      if (!fv_comp_no_overflow)
+        {
+          bound = fold_build2 (PLUS_EXPR, type1,
+                               TYPE_MIN_VALUE (type1), tmod);
+-         if (POINTER_TYPE_P (type))
+-           bound = fold_convert (type, bound);
+          assumption = fold_build2 (GE_EXPR, boolean_type_node,
+                                    iv0->base, bound);
+          if (integer_zerop (assumption))
+@@ -969,13 +982,13 @@
+ /* Determines number of iterations of loop whose ending condition
+    is IV0 < IV1.  TYPE is the type of the iv.  The number of
+    iterations is stored to NITER.  BNDS bounds the difference
+-   IV1->base - IV0->base.  */
++   IV1->base - IV0->base.  EXIT_MUST_BE_TAKEN is true if we know
++   that the exit must be taken eventually.  */
+ 
+ static bool
+ number_of_iterations_lt (tree type, affine_iv *iv0, affine_iv *iv1,
+                         struct tree_niter_desc *niter,
+-                        bool never_infinite ATTRIBUTE_UNUSED,
+-                        bounds *bnds)
++                        bool exit_must_be_taken, bounds *bnds)
+ {
+   tree niter_type = unsigned_type_for (type);
+   tree delta, step, s;
+@@ -1034,7 +1047,7 @@
+      transform the condition to != comparison.  In particular, this will be
+      the case if DELTA is constant.  */
+   if (number_of_iterations_lt_to_ne (type, iv0, iv1, niter, &delta, step,
+-                                    bnds))
++                                    exit_must_be_taken, bnds))
+     {
+       affine_iv zps;
+ 
+@@ -1076,14 +1089,14 @@
+ 
+ /* Determines number of iterations of loop whose ending condition
+    is IV0 <= IV1.  TYPE is the type of the iv.  The number of
+-   iterations is stored to NITER.  NEVER_INFINITE is true if
++   iterations is stored to NITER.  EXIT_MUST_BE_TAKEN is true if
+    we know that this condition must eventually become false (we derived this
+    earlier, and possibly set NITER->assumptions to make sure this
+    is the case).  BNDS bounds the difference IV1->base - IV0->base.  */
+ 
+ static bool
+ number_of_iterations_le (tree type, affine_iv *iv0, affine_iv *iv1,
+-                        struct tree_niter_desc *niter, bool never_infinite,
++                        struct tree_niter_desc *niter, bool exit_must_be_taken,
+                         bounds *bnds)
+ {
+   tree assumption;
+@@ -1094,9 +1107,13 @@
+   /* Say that IV0 is the control variable.  Then IV0 <= IV1 iff
+      IV0 < IV1 + 1, assuming that IV1 is not equal to the greatest
+      value of the type.  This we must know anyway, since if it is
+-     equal to this value, the loop rolls forever.  */
++     equal to this value, the loop rolls forever.  We do not check
++     this condition for pointer type ivs, as the code cannot rely on 
++     the object to that the pointer points being placed at the end of
++     the address space (and more pragmatically, TYPE_{MIN,MAX}_VALUE is
++     not defined for pointers).  */
+ 
+-  if (!never_infinite)
++  if (!exit_must_be_taken && !POINTER_TYPE_P (type))
+     {
+       if (integer_nonzerop (iv0->step))
+        assumption = fold_build2 (NE_EXPR, boolean_type_node,
+@@ -1131,7 +1148,8 @@
+ 
+   bounds_add (bnds, double_int_one, type1);
+ 
+-  return number_of_iterations_lt (type, iv0, iv1, niter, never_infinite, bnds);
++  return number_of_iterations_lt (type, iv0, iv1, niter, exit_must_be_taken,
++                                 bnds);
+ }
+ 
+ /* Dumps description of affine induction variable IV to FILE.  */
+@@ -1177,7 +1195,7 @@
+                           affine_iv *iv1, struct tree_niter_desc *niter,
+                           bool only_exit)
+ {
+-  bool never_infinite, ret;
++  bool exit_must_be_taken = false, ret;
+   bounds bnds;
+ 
+   /* The meaning of these assumptions is this:
+@@ -1202,42 +1220,27 @@
+       code = swap_tree_comparison (code);
+     }
+ 
+-  if (!only_exit)
+-    {
+-      /* If this is not the only possible exit from the loop, the information
+-        that the induction variables cannot overflow as derived from
+-        signedness analysis cannot be relied upon.  We use them e.g. in the
+-        following way:  given loop for (i = 0; i <= n; i++), if i is
+-        signed, it cannot overflow, thus this loop is equivalent to
+-        for (i = 0; i < n + 1; i++);  however, if n == MAX, but the loop
+-        is exited in some other way before i overflows, this transformation
+-        is incorrect (the new loop exits immediately).  */
+-      iv0->no_overflow = false;
+-      iv1->no_overflow = false;
+-    }
+-
+   if (POINTER_TYPE_P (type))
+     {
+       /* Comparison of pointers is undefined unless both iv0 and iv1 point
+         to the same object.  If they do, the control variable cannot wrap
+         (as wrap around the bounds of memory will never return a pointer
+         that would be guaranteed to point to the same object, even if we
+-        avoid undefined behavior by casting to size_t and back).  The
+-        restrictions on pointer arithmetics and comparisons of pointers
+-        ensure that using the no-overflow assumptions is correct in this
+-        case even if ONLY_EXIT is false.  */
++        avoid undefined behavior by casting to size_t and back).  */
+       iv0->no_overflow = true;
+       iv1->no_overflow = true;
+     }
+ 
+-  /* If the control induction variable does not overflow, the loop obviously
+-     cannot be infinite.  */
+-  if (!integer_zerop (iv0->step) && iv0->no_overflow)
+-    never_infinite = true;
+-  else if (!integer_zerop (iv1->step) && iv1->no_overflow)
+-    never_infinite = true;
+-  else
+-    never_infinite = false;
++  /* If the control induction variable does not overflow and the only exit
++     from the loop is the one that we analyze, we know it must be taken
++     eventually.  */
++  if (only_exit)
++    {
++      if (!integer_zerop (iv0->step) && iv0->no_overflow)
++       exit_must_be_taken = true;
++      else if (!integer_zerop (iv1->step) && iv1->no_overflow)
++       exit_must_be_taken = true;
++    }
+ 
+   /* We can handle the case when neither of the sides of the comparison is
+      invariant, provided that the test is NE_EXPR.  This rarely occurs in
+@@ -1308,16 +1311,16 @@
+     case NE_EXPR:
+       gcc_assert (integer_zerop (iv1->step));
+       ret = number_of_iterations_ne (type, iv0, iv1->base, niter,
+-                                    never_infinite, &bnds);
++                                    exit_must_be_taken, &bnds);
+       break;
+ 
+     case LT_EXPR:
+-      ret = number_of_iterations_lt (type, iv0, iv1, niter, never_infinite,
++      ret = number_of_iterations_lt (type, iv0, iv1, niter, exit_must_be_taken,
+                                     &bnds);
+       break;
+ 
+     case LE_EXPR:
+-      ret = number_of_iterations_le (type, iv0, iv1, niter, never_infinite,
++      ret = number_of_iterations_le (type, iv0, iv1, niter, exit_must_be_taken,
+                                     &bnds);
+       break;
+ 
+diff -Naur gcc-4.4.0.orig/gcc/tree-ssa-phiprop.c gcc-4.4.0/gcc/tree-ssa-phiprop.c
+--- gcc-4.4.0.orig/gcc/tree-ssa-phiprop.c       2008-09-11 14:48:11.000000000 -0700
++++ gcc-4.4.0/gcc/tree-ssa-phiprop.c    2009-05-06 01:32:24.000000000 -0700
+@@ -119,8 +119,7 @@
+       FOR_EACH_IMM_USE_STMT (use_stmt, ui2, vuse)
+        {
+          /* If BB does not dominate a VDEF, the value is invalid.  */
+-         if (((is_gimple_assign (use_stmt)
+-               && !ZERO_SSA_OPERANDS (use_stmt, SSA_OP_VDEF))
++         if ((!ZERO_SSA_OPERANDS (use_stmt, SSA_OP_VDEF)
+               || gimple_code (use_stmt) == GIMPLE_PHI)
+              && !dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), bb))
+            {
+diff -Naur gcc-4.4.0.orig/gcc/tree-ssa-sccvn.c gcc-4.4.0/gcc/tree-ssa-sccvn.c
+--- gcc-4.4.0.orig/gcc/tree-ssa-sccvn.c 2009-04-11 00:42:52.000000000 -0700
++++ gcc-4.4.0/gcc/tree-ssa-sccvn.c      2009-05-18 03:13:43.000000000 -0700
+@@ -1293,7 +1293,7 @@
+     *vnresult = NULL;
+   vno1.opcode = gimple_assign_rhs_code (stmt);
+   vno1.length = gimple_num_ops (stmt) - 1;
+-  vno1.type = TREE_TYPE (gimple_assign_lhs (stmt));
++  vno1.type = gimple_expr_type (stmt);
+   for (i = 0; i < vno1.length; ++i)
+     vno1.op[i] = gimple_op (stmt, i + 1);
+   if (vno1.opcode == REALPART_EXPR
+@@ -1401,7 +1401,7 @@
+   vno1->value_id = VN_INFO (result)->value_id;
+   vno1->opcode = gimple_assign_rhs_code (stmt);
+   vno1->length = length;
+-  vno1->type = TREE_TYPE (gimple_assign_lhs (stmt));
++  vno1->type = gimple_expr_type (stmt);
+   for (i = 0; i < vno1->length; ++i)
+     vno1->op[i] = gimple_op (stmt, i + 1);
+   if (vno1->opcode == REALPART_EXPR
+@@ -2142,7 +2142,7 @@
+   fold_defer_overflow_warnings ();
+ 
+   result = fold_binary (gimple_assign_rhs_code (stmt),
+-                       TREE_TYPE (gimple_get_lhs (stmt)), op0, op1);
++                       gimple_expr_type (stmt), op0, op1);
+   if (result)
+     STRIP_USELESS_TYPE_CONVERSION (result);
+ 
+diff -Naur gcc-4.4.0.orig/gcc/tree-vect-analyze.c gcc-4.4.0/gcc/tree-vect-analyze.c
+--- gcc-4.4.0.orig/gcc/tree-vect-analyze.c      2009-04-02 11:08:10.000000000 -0700
++++ gcc-4.4.0/gcc/tree-vect-analyze.c   2009-05-11 06:55:36.000000000 -0700
+@@ -2187,7 +2187,7 @@
+       tree next_step;
+       tree prev_init = DR_INIT (data_ref);
+       gimple prev = stmt;
+-      HOST_WIDE_INT diff, count_in_bytes;
++      HOST_WIDE_INT diff, count_in_bytes, gaps = 0;
+ 
+       while (next)
+         {
+@@ -2249,6 +2249,8 @@
+                    fprintf (vect_dump, "interleaved store with gaps");
+                  return false;
+                }
++
++              gaps += diff - 1;
+            }
+ 
+           /* Store the gap from the previous member of the group. If there is no
+@@ -2265,8 +2267,9 @@
+          the type to get COUNT_IN_BYTES.  */
+       count_in_bytes = type_size * count;
+ 
+-      /* Check that the size of the interleaving is not greater than STEP.  */
+-      if (dr_step < count_in_bytes)
++      /* Check that the size of the interleaving (including gaps) is not greater
++         than STEP.  */
++      if (dr_step && dr_step < count_in_bytes + gaps * type_size)
+         {
+           if (vect_print_dump_info (REPORT_DETAILS))
+             {
 diff -Naur gcc-4.4.0.orig/gcc/version.c gcc-4.4.0/gcc/version.c
 --- gcc-4.4.0.orig/gcc/version.c        2007-08-21 08:35:30.000000000 -0700
-+++ gcc-4.4.0/gcc/version.c     2009-04-29 14:17:15.000000000 -0700
++++ gcc-4.4.0/gcc/version.c     2009-06-05 09:55:18.000000000 -0700
 @@ -14,4 +14,4 @@
     Makefile.  */
@@ -14434 +19076 @@
  const char version_string[] = BASEVER DATESTAMP DEVPHASE REVISION;
 -const char pkgversion_string[] = PKGVERSION;
-+const char pkgversion_string[] = "(GCC for Cross-LFS 4.4.0.20090429) ";
-diff -Naur gcc-4.4.0.orig/libcpp/po/ChangeLog gcc-4.4.0/libcpp/po/ChangeLog
---- gcc-4.4.0.orig/libcpp/po/ChangeLog  2009-04-21 01:47:21.000000000 -0700
-+++ gcc-4.4.0/libcpp/po/ChangeLog       2009-04-22 09:35:05.000000000 -0700
-@@ -1,3 +1,7 @@
-+2009-04-22  Joseph Myers  <joseph@codesourcery.com>
-+
-+       * cpplib.pot: Regenerate.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
++const char pkgversion_string[] = "(GCC for Cross-LFS 4.4.0.20090605) ";
+diff -Naur gcc-4.4.0.orig/gnattools/Makefile.in gcc-4.4.0/gnattools/Makefile.in
+--- gcc-4.4.0.orig/gnattools/Makefile.in        2009-04-09 16:23:07.000000000 -0700
++++ gcc-4.4.0/gnattools/Makefile.in     2009-05-18 00:41:14.000000000 -0700
+@@ -164,7 +164,7 @@
+        -(cd $(GCC_DIR)/ada/tools; $(LN_S) ../sdefault.adb .)
+        -$(foreach PAIR,$(TOOLS_TARGET_PAIRS), \
+                  rm -f $(GCC_DIR)/ada/tools/$(word 1,$(subst <, ,$(PAIR)));\
+-                 $(LN_S) $(fsrcdir)/$(word 2,$(subst <, ,$(PAIR))) \
++                 $(LN_S) $(fsrcdir)/ada/$(word 2,$(subst <, ,$(PAIR))) \
+                        $(GCC_DIR)/ada/tools/$(word 1,$(subst <, ,$(PAIR)));)
+        touch $(GCC_DIR)/stamp-tools
+ 
 diff -Naur gcc-4.4.0.orig/libcpp/po/cpplib.pot gcc-4.4.0/libcpp/po/cpplib.pot
 --- gcc-4.4.0.orig/libcpp/po/cpplib.pot 2009-03-28 00:26:17.000000000 -0700
@@ -14978 +19621 @@
  msgid "syntax error in macro parameter list"
  msgstr ""
-diff -Naur gcc-4.4.0.orig/libjava/ChangeLog gcc-4.4.0/libjava/ChangeLog
---- gcc-4.4.0.orig/libjava/ChangeLog    2009-04-21 01:48:20.000000000 -0700
-+++ gcc-4.4.0/libjava/ChangeLog 2009-04-28 05:51:10.000000000 -0700
-@@ -1,3 +1,27 @@
-+2009-04-28  Andrew Haley  <aph@redhat.com>
-+
-+       PR libgcj/39899
-+       * Makefile.am (libgcj_tools_la_LDFLAGS): Add
-+       -fno-bootstrap-classes to libgcj_tools_la_GCJFLAGS.
-+       * Makefile.in: Regenerate.
-+
-+2009-04-26  Matthias Klose <doko@ubuntu.com>
-+
-+       * contrib/aot-compile.in: Print diagnostics for malformed or invalid
-+       class files.
-+       * contrib/generate-cacerts.pl.in: New.
-+       * configure.ac (AC_CONFIG_FILES): Add generate-cacerts.pl.
-+
-+2009-04-24  Matthias Klose  <doko@ubuntu.com>
-+
-+       * configure.ac: Create missing directory gnu/java/security/jce/prng.
-+       * configure: Regenerate.
-+
-+2009-04-23  Matthias Klose  <doko@ubuntu.com>
-+
-+       * Makefile.am (install-data-local): Fix symlinks to header files.
-+       * Makefile.in: Regenerate.
-+
- 2009-04-21  Release Manager
- 
-        * GCC 4.4.0 released.
+diff -Naur gcc-4.4.0.orig/libgfortran/gfortran.map gcc-4.4.0/libgfortran/gfortran.map
+--- gcc-4.4.0.orig/libgfortran/gfortran.map     2008-07-27 03:45:44.000000000 -0700
++++ gcc-4.4.0/libgfortran/gfortran.map  2009-06-03 12:39:09.000000000 -0700
+@@ -1090,6 +1090,13 @@
+     _gfortran_unpack1_char4;
+ } GFORTRAN_1.0; 
+ 
++
++GFORTRAN_1.2 {
++  global:
++    _gfortran_clz128;
++    _gfortran_ctz128;
++} GFORTRAN_1.1; 
++
+ F2C_1.0 {
+   global:
+     _gfortran_f2c_specific__abs_c4;
+diff -Naur gcc-4.4.0.orig/libgfortran/intrinsics/bit_intrinsics.c gcc-4.4.0/libgfortran/intrinsics/bit_intrinsics.c
+--- gcc-4.4.0.orig/libgfortran/intrinsics/bit_intrinsics.c      1969-12-31 16:00:00.000000000 -0800
++++ gcc-4.4.0/libgfortran/intrinsics/bit_intrinsics.c   2009-06-03 12:39:09.000000000 -0700
+@@ -0,0 +1,138 @@
++/* Implementation of the bit intrinsics not implemented as GCC builtins.
++   Copyright (C) 2009 Free Software Foundation, Inc.
++
++This file is part of the GNU Fortran runtime library (libgfortran).
++
++Libgfortran is free software; you can redistribute it and/or
++modify it under the terms of the GNU General Public
++License as published by the Free Software Foundation; either
++version 3 of the License, or (at your option) any later version.
++
++Libgfortran is distributed in the hope that it will be useful,
++but WITHOUT ANY WARRANTY; without even the implied warranty of
++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++GNU General Public License for more details.
++
++Under Section 7 of GPL version 3, you are granted additional
++permissions described in the GCC Runtime Library Exception, version
++3.1, as published by the Free Software Foundation.
++
++You should have received a copy of the GNU General Public License and
++a copy of the GCC Runtime Library Exception along with this program;
++see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
++<http://www.gnu.org/licenses/>.  */
++
++#include "libgfortran.h"
++
++
++#ifdef HAVE_GFC_INTEGER_16
++extern int clz128 (GFC_INTEGER_16);
++export_proto(clz128);
++
++int
++clz128 (GFC_INTEGER_16 x)
++{
++  int res = 127;
++
++  // We can't write 0xFFFFFFFFFFFFFFFF0000000000000000, so we work around it
++  if (x & ((__uint128_t) 0xFFFFFFFFFFFFFFFF << 64))
++    {
++      res -= 64;
++      x >>= 64;
++    }
++
++  if (x & 0xFFFFFFFF00000000)
++    {
++      res -= 32;
++      x >>= 32;
++    }
++
++  if (x & 0xFFFF0000)
++    {
++      res -= 16;
++      x >>= 16;
++    }
++
++  if (x & 0xFF00)
++    {
++      res -= 8;
++      x >>= 8;
++    }
++
++  if (x & 0xF0)
++    {
++      res -= 4;
++      x >>= 4;
++    }
++
++  if (x & 0xC)
++    {
++      res -= 2;
++      x >>= 2;
++    }
++
++  if (x & 0x2)
++    {
++      res -= 1;
++      x >>= 1;
++    }
++
++  return res;
++}
++#endif
++
++
++#ifdef HAVE_GFC_INTEGER_16
++extern int ctz128 (GFC_INTEGER_16);
++export_proto(ctz128);
++
++int
++ctz128 (GFC_INTEGER_16 x)
++{
++  int res = 0;
++
++  if ((x & 0xFFFFFFFFFFFFFFFF) == 0)
++    {
++      res += 64;
++      x >>= 64;
++    }
++
++  if ((x & 0xFFFFFFFF) == 0)
++    {
++      res += 32;
++      x >>= 32;
++    }
++
++  if ((x & 0xFFFF) == 0)
++    {
++      res += 16;
++      x >>= 16;
++    }
++
++  if ((x & 0xFF) == 0)
++    {
++      res += 8;
++      x >>= 8;
++    }
++
++  if ((x & 0xF) == 0)
++    {
++      res += 4;
++      x >>= 4;
++    }
++
++  if ((x & 0x3) == 0)
++    {
++      res += 2;
++      x >>= 2;
++    }
++
++  if ((x & 0x1) == 0)
++    {
++      res += 1;
++      x >>= 1;
++    }
++
++  return res;
++}
++#endif
+diff -Naur gcc-4.4.0.orig/libgfortran/io/fbuf.c gcc-4.4.0/libgfortran/io/fbuf.c
+--- gcc-4.4.0.orig/libgfortran/io/fbuf.c        2009-04-09 16:23:07.000000000 -0700
++++ gcc-4.4.0/libgfortran/io/fbuf.c     2009-05-26 18:21:22.000000000 -0700
+@@ -28,8 +28,11 @@
+ #include <stdlib.h>
+ 
+ 
++//#define FBUF_DEBUG
++
++
+ void
+-fbuf_init (gfc_unit * u, size_t len)
++fbuf_init (gfc_unit * u, int len)
+ {
+   if (len == 0)
+     len = 512;                 /* Default size.  */
+@@ -37,14 +40,7 @@
+   u->fbuf = get_mem (sizeof (fbuf));
+   u->fbuf->buf = get_mem (len);
+   u->fbuf->len = len;
+-  u->fbuf->act = u->fbuf->flushed = u->fbuf->pos = 0;
+-}
+-
+-
+-void
+-fbuf_reset (gfc_unit * u)
+-{
+-  u->fbuf->act = u->fbuf->flushed = u->fbuf->pos = 0;
++  u->fbuf->act = u->fbuf->pos = 0;
+ }
+ 
+ 
+@@ -56,58 +52,79 @@
+   if (u->fbuf->buf)
+     free_mem (u->fbuf->buf);
+   free_mem (u->fbuf);
++  u->fbuf = NULL;
++}
++
++
++static void
++#ifdef FBUF_DEBUG
++fbuf_debug (gfc_unit * u, const char * format, ...)
++{
++  va_list args;
++  va_start(args, format);
++  vfprintf(stderr, format, args);
++  va_end(args);
++  fprintf (stderr, "fbuf_debug pos: %d, act: %d, buf: ''", 
++           u->fbuf->pos, u->fbuf->act);
++  for (int ii = 0; ii < u->fbuf->act; ii++)
++    {
++      putc (u->fbuf->buf[ii], stderr);
++    }
++  fprintf (stderr, "''\n");
++}
++#else
++fbuf_debug (gfc_unit * u __attribute__ ((unused)),
++            const char * format __attribute__ ((unused)),
++            ...) {}
++#endif
++
++  
++
++/* You should probably call this before doing a physical seek on the
++   underlying device.  Returns how much the physical position was
++   modified.  */
++
++int
++fbuf_reset (gfc_unit * u)
++{
++  int seekval = 0;
++
++  if (!u->fbuf)
++    return 0;
++
++  fbuf_debug (u, "fbuf_reset: ");
++  fbuf_flush (u, u->mode);
++  /* If we read past the current position, seek the underlying device
++     back.  */
++  if (u->mode == READING && u->fbuf->act > u->fbuf->pos)
++    {
++      seekval = - (u->fbuf->act - u->fbuf->pos);
++      fbuf_debug (u, "fbuf_reset seekval %d, ", seekval);
++    }
++  u->fbuf->act = u->fbuf->pos = 0;
++  return seekval;
+ }
+ 
+ 
+ /* Return a pointer to the current position in the buffer, and increase
+    the pointer by len. Makes sure that the buffer is big enough, 
+-   reallocating if necessary. If the buffer is not big enough, there are
+-   three cases to consider:
+-   1. If we haven't flushed anything, realloc
+-   2. If we have flushed enough that by discarding the flushed bytes
+-      the request fits into the buffer, do that.
+-   3. Else allocate a new buffer, memcpy unflushed active bytes from old
+-      buffer. */
++   reallocating if necessary.  */
+ 
+ char *
+-fbuf_alloc (gfc_unit * u, size_t len)
++fbuf_alloc (gfc_unit * u, int len)
+ {
+-  size_t newlen;
++  int newlen;
+   char *dest;
++  fbuf_debug (u, "fbuf_alloc len %d, ", len);
+   if (u->fbuf->pos + len > u->fbuf->len)
+     {
+-      if (u->fbuf->flushed == 0)
+-       {
+-         /* Round up to nearest multiple of the current buffer length.  */
+-         newlen = ((u->fbuf->pos + len) / u->fbuf->len + 1) * u->fbuf->len;
+-         dest = realloc (u->fbuf->buf, newlen);
+-         if (dest == NULL)
+-           return NULL;
+-         u->fbuf->buf = dest;
+-         u->fbuf->len = newlen;
+-       }
+-      else if (u->fbuf->act - u->fbuf->flushed + len < u->fbuf->len)
+-       {
+-         memmove (u->fbuf->buf, u->fbuf->buf + u->fbuf->flushed,
+-                  u->fbuf->act - u->fbuf->flushed);
+-         u->fbuf->act -= u->fbuf->flushed;
+-         u->fbuf->pos -= u->fbuf->flushed;
+-         u->fbuf->flushed = 0;
+-       }
+-      else
+-       {
+-         /* Most general case, flushed != 0, request doesn't fit.  */
+-         newlen = ((u->fbuf->pos - u->fbuf->flushed + len)
+-                   / u->fbuf->len + 1) * u->fbuf->len;
+-         dest = get_mem (newlen);
+-         memcpy (dest, u->fbuf->buf + u->fbuf->flushed,
+-                 u->fbuf->act - u->fbuf->flushed);
+-         u->fbuf->act -= u->fbuf->flushed;
+-         u->fbuf->pos -= u->fbuf->flushed;
+-         u->fbuf->flushed = 0;
+-         u->fbuf->buf = dest;
+-         u->fbuf->len = newlen;
+-       }
++      /* Round up to nearest multiple of the current buffer length.  */
++      newlen = ((u->fbuf->pos + len) / u->fbuf->len + 1) * u->fbuf->len;
++      dest = realloc (u->fbuf->buf, newlen);
++      if (dest == NULL)
++       return NULL;
++      u->fbuf->buf = dest;
++      u->fbuf->len = newlen;
+     }
+ 
+   dest = u->fbuf->buf + u->fbuf->pos;
+@@ -118,42 +135,134 @@
+ }
+ 
+ 
+-
++/* mode argument is WRITING for write mode and READING for read
++   mode. Return value is 0 for success, -1 on failure.  */
+ 
+ int
+-fbuf_flush (gfc_unit * u, int record_done)
++fbuf_flush (gfc_unit * u, unit_mode mode)
+ {
+-  int status;
+-  size_t nbytes;
++  int nwritten;
+ 
+   if (!u->fbuf)
+     return 0;
+-  if (u->fbuf->act - u->fbuf->flushed != 0)
++
++  fbuf_debug (u, "fbuf_flush with mode %d: ", mode);
++
++  if (mode == WRITING)
+     {
+-      if (record_done)
+-        nbytes = u->fbuf->act - u->fbuf->flushed;
+-      else     
+-        nbytes = u->fbuf->pos - u->fbuf->flushed;      
+-      status = swrite (u->s, u->fbuf->buf + u->fbuf->flushed, &nbytes);
+-      u->fbuf->flushed += nbytes;
++      if (u->fbuf->pos > 0)
++       {
++         nwritten = swrite (u->s, u->fbuf->buf, u->fbuf->pos);
++         if (nwritten < 0)
++           return -1;
++       }
+     }
+-  else
+-    status = 0;
+-  if (record_done)
+-    fbuf_reset (u);
+-  return status;
++  /* Salvage remaining bytes for both reading and writing. This
++     happens with the combination of advance='no' and T edit
++     descriptors leaving the final position somewhere not at the end
++     of the record. For reading, this also happens if we sread() past
++     the record boundary.  */ 
++  if (u->fbuf->act > u->fbuf->pos && u->fbuf->pos > 0)
++    memmove (u->fbuf->buf, u->fbuf->buf + u->fbuf->pos, 
++             u->fbuf->act - u->fbuf->pos);
++
++  u->fbuf->act -= u->fbuf->pos;
++  u->fbuf->pos = 0;
++
++  return 0;
+ }
+ 
+ 
+ int
+-fbuf_seek (gfc_unit * u, gfc_offset off)
++fbuf_seek (gfc_unit * u, int off, int whence)
+ {
+-  gfc_offset pos = u->fbuf->pos + off;
+-  /* Moving to the left past the flushed marked would imply moving past
+-     the left tab limit, which is never allowed. So return error if
+-     that is attempted.  */
+-  if (pos < (gfc_offset) u->fbuf->flushed)
++  if (!u->fbuf)
+     return -1;
+-  u->fbuf->pos = pos;
+-  return 0;
++
++  switch (whence)
++    {
++    case SEEK_SET:
++      break;
++    case SEEK_CUR:
++      off += u->fbuf->pos;
++      break;
++    case SEEK_END:
++      off += u->fbuf->act;
++      break;
++    default:
++      return -1;
++    }
++
++  fbuf_debug (u, "fbuf_seek, off %d ", off);
++  /* The start of the buffer is always equal to the left tab
++     limit. Moving to the left past the buffer is illegal in C and
++     would also imply moving past the left tab limit, which is never
++     allowed in Fortran. Similarly, seeking past the end of the buffer
++     is not possible, in that case the user must make sure to allocate
++     space with fbuf_alloc().  So return error if that is
++     attempted.  */
++  if (off < 0 || off > u->fbuf->act)
++    return -1;
++  u->fbuf->pos = off;
++  return off;
++}
++
++
++/* Fill the buffer with bytes for reading.  Returns a pointer to start
++   reading from. If we hit EOF, returns a short read count. If any
++   other error occurs, return NULL.  After reading, the caller is
++   expected to call fbuf_seek to update the position with the number
++   of bytes actually processed. */
++
++char *
++fbuf_read (gfc_unit * u, int * len)
++{
++  char *ptr;
++  int oldact, oldpos;
++  int readlen = 0;
++
++  fbuf_debug (u, "fbuf_read, len %d: ", *len);
++  oldact = u->fbuf->act;
++  oldpos = u->fbuf->pos;
++  ptr = fbuf_alloc (u, *len);
++  u->fbuf->pos = oldpos;
++  if (oldpos + *len > oldact)
++    {
++      fbuf_debug (u, "reading %d bytes starting at %d ", 
++                  oldpos + *len - oldact, oldact);
++      readlen = sread (u->s, u->fbuf->buf + oldact, oldpos + *len - oldact);
++      if (readlen < 0)
++       return NULL;
++      *len = oldact - oldpos + readlen;
++    }
++  u->fbuf->act = oldact + readlen;
++  fbuf_debug (u, "fbuf_read done: ");
++  return ptr;
++}
++
++
++/* When the fbuf_getc() inline function runs out of buffer space, it
++   calls this function to fill the buffer with bytes for
++   reading. Never call this function directly.  */
++
++int
++fbuf_getc_refill (gfc_unit * u)
++{
++  int nread;
++  char *p;
++
++  fbuf_debug (u, "fbuf_getc_refill ");
++
++  /* Read 80 bytes (average line length?).  This is a compromise
++     between not needing to call the read() syscall all the time and
++     not having to memmove unnecessary stuff when switching to the
++     next record.  */
++  nread = 80;
++
++  p = fbuf_read (u, &nread);
++
++  if (p && nread > 0)
++    return (unsigned char) u->fbuf->buf[u->fbuf->pos++];
++  else
++    return EOF;
+ }
+diff -Naur gcc-4.4.0.orig/libgfortran/io/file_pos.c gcc-4.4.0/libgfortran/io/file_pos.c
+--- gcc-4.4.0.orig/libgfortran/io/file_pos.c    2009-04-09 16:23:07.000000000 -0700
++++ gcc-4.4.0/libgfortran/io/file_pos.c 2009-05-26 18:21:22.000000000 -0700
+@@ -41,17 +41,17 @@
+ {
+   gfc_offset base;
+   char p[READ_CHUNK];
+-  size_t n;
++  ssize_t n;
+ 
+-  base = file_position (u->s) - 1;
++  base = stell (u->s) - 1;
+ 
+   do
+     {
+       n = (base < READ_CHUNK) ? base : READ_CHUNK;
+       base -= n;
+-      if (sseek (u->s, base) == FAILURE)
++      if (sseek (u->s, base, SEEK_SET) < 0)
+         goto io_error;
+-      if (sread (u->s, p, &n) != 0)
++      if (sread (u->s, p, n) != n)
+        goto io_error;
+ 
+       /* We have moved backwards from the current position, it should
+@@ -76,7 +76,7 @@
+ 
+   /* base is the new pointer.  Seek to it exactly.  */
+  done:
+-  if (sseek (u->s, base) == FAILURE)
++  if (sseek (u->s, base, SEEK_SET) < 0)
+     goto io_error;
+   u->last_record--;
+   u->endfile = NO_ENDFILE;
+@@ -95,10 +95,10 @@
+ static void
+ unformatted_backspace (st_parameter_filepos *fpp, gfc_unit *u)
+ {
+-  gfc_offset m, new;
++  gfc_offset m, slen;
+   GFC_INTEGER_4 m4;
+   GFC_INTEGER_8 m8;
+-  size_t length;
++  ssize_t length;
+   int continued;
+   char p[sizeof (GFC_INTEGER_8)];
+ 
+@@ -109,9 +109,10 @@
+ 
+   do
+     {
+-      if (sseek (u->s, file_position (u->s) - length) == FAILURE)