diff -urp src.head/gas/app.c src.gas/gas/app.c
--- src.head/gas/app.c	2009-09-07 13:21:22.488585000 -0700
+++ src.gas/gas/app.c	2009-09-10 09:50:01.390884000 -0700
@@ -258,7 +258,7 @@ app_push (void)
     saved->saved_input = NULL;
   else
     {
-      saved->saved_input = xmalloc (saved_input_len);
+      saved->saved_input = (char *) xmalloc (saved_input_len);
       memcpy (saved->saved_input, saved_input, saved_input_len);
       saved->saved_input_len = saved_input_len;
     }
diff -urp src.head/gas/as.c src.gas/gas/as.c
--- src.head/gas/as.c	2009-09-07 13:21:22.509595000 -0700
+++ src.gas/gas/as.c	2009-09-10 09:51:18.067745000 -0700
@@ -506,7 +506,8 @@ parse_args (int * pargc, char *** pargv)
      dependent list.  Include space for an extra NULL option and
      always NULL terminate.  */
   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
-  longopts = xmalloc (sizeof (std_longopts) + md_longopts_size + sizeof (struct option));
+  longopts = (struct option *) xmalloc (sizeof (std_longopts)
+                                        + md_longopts_size + sizeof (struct option));
   memcpy (longopts, std_longopts, sizeof (std_longopts));
   memcpy (((char *) longopts) + sizeof (std_longopts), md_longopts, md_longopts_size);
   memset (((char *) longopts) + sizeof (std_longopts) + md_longopts_size,
@@ -517,7 +518,7 @@ parse_args (int * pargc, char *** pargv)
   old_argv = *pargv;
 
   /* Initialize a new argv that contains no options.  */
-  new_argv = xmalloc (sizeof (char *) * (old_argc + 1));
+  new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1));
   new_argv[0] = old_argv[0];
   new_argc = 1;
   new_argv[new_argc] = NULL;
@@ -646,7 +647,7 @@ This program has absolutely no warranty.
 	      as_fatal (_("bad defsym; format is --defsym name=value"));
 	    *s++ = '\0';
 	    i = bfd_scan_vma (s, (const char **) NULL, 0);
-	    n = xmalloc (sizeof *n);
+	    n = (struct defsym_list *) xmalloc (sizeof *n);
 	    n->next = defsyms;
 	    n->name = optarg;
 	    n->value = i;
diff -urp src.head/gas/config/obj-elf.c src.gas/gas/config/obj-elf.c
--- src.head/gas/config/obj-elf.c	2009-09-07 13:21:23.923315000 -0700
+++ src.gas/gas/config/obj-elf.c	2009-09-10 10:12:49.832540000 -0700
@@ -269,7 +269,7 @@ elf_file_symbol (const char *s, int appf
       if (name_length > strlen (S_GET_NAME (sym)))
 	{
 	  obstack_grow (&notes, s, name_length + 1);
-	  S_SET_NAME (sym, obstack_finish (&notes));
+	  S_SET_NAME (sym, (const char *) obstack_finish (&notes));
 	}
       else
 	strcpy ((char *) S_GET_NAME (sym), s);
@@ -505,7 +505,7 @@ static struct section_stack *section_sta
 static bfd_boolean
 get_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
 {
-  const char *gname = inf;
+  const char *gname = (const char *) inf;
   const char *group_name = elf_group_name (sec);
 
   return (group_name == gname
@@ -555,7 +555,7 @@ obj_elf_change_section (const char *name
   if (push)
     {
       struct section_stack *elt;
-      elt = xmalloc (sizeof (struct section_stack));
+      elt = (struct section_stack *) xmalloc (sizeof (struct section_stack));
       elt->next = section_stack;
       elt->seg = now_seg;
       elt->prev_seg = previous_section;
@@ -885,7 +885,7 @@ obj_elf_section_name (void)
 	  return NULL;
 	}
 
-      name = xmalloc (end - input_line_pointer + 1);
+      name = (char *) xmalloc (end - input_line_pointer + 1);
       memcpy (name, input_line_pointer, end - input_line_pointer);
       name[end - input_line_pointer] = '\0';
 #ifdef tc_canonicalize_section_name
@@ -1441,7 +1441,7 @@ elf_copy_symbol_attributes (symbolS *des
   if (srcelf->size)
     {
       if (destelf->size == NULL)
-	destelf->size = xmalloc (sizeof (expressionS));
+	destelf->size = (expressionS *) xmalloc (sizeof (expressionS));
       *destelf->size = *srcelf->size;
     }
   else
@@ -1558,7 +1558,8 @@ obj_elf_size (int ignore ATTRIBUTE_UNUSE
     }
   else
     {
-      symbol_get_obj (sym)->size = xmalloc (sizeof (expressionS));
+      symbol_get_obj (sym)->size =
+          (expressionS *) xmalloc (sizeof (expressionS));
       *symbol_get_obj (sym)->size = exp;
     }
   demand_empty_rest_of_line ();
@@ -1609,7 +1610,7 @@ obj_elf_type (int ignore ATTRIBUTE_UNUSE
   char *name;
   char c;
   int type;
-  const char *typename;
+  const char *type_name;
   symbolS *sym;
   elf_symbol_type *elfsym;
 
@@ -1630,28 +1631,28 @@ obj_elf_type (int ignore ATTRIBUTE_UNUSE
       || *input_line_pointer == '%')
     ++input_line_pointer;
 
-  typename = obj_elf_type_name (& c);
+  type_name = obj_elf_type_name (& c);
 
   type = 0;
-  if (strcmp (typename, "function") == 0
-      || strcmp (typename, "2") == 0
-      || strcmp (typename, "STT_FUNC") == 0)
+  if (strcmp (type_name, "function") == 0
+      || strcmp (type_name, "2") == 0
+      || strcmp (type_name, "STT_FUNC") == 0)
     type = BSF_FUNCTION;
-  else if (strcmp (typename, "object") == 0
-	   || strcmp (typename, "1") == 0
-	   || strcmp (typename, "STT_OBJECT") == 0)
+  else if (strcmp (type_name, "object") == 0
+	   || strcmp (type_name, "1") == 0
+	   || strcmp (type_name, "STT_OBJECT") == 0)
     type = BSF_OBJECT;
-  else if (strcmp (typename, "tls_object") == 0
-	   || strcmp (typename, "6") == 0
-	   || strcmp (typename, "STT_TLS") == 0)
+  else if (strcmp (type_name, "tls_object") == 0
+	   || strcmp (type_name, "6") == 0
+	   || strcmp (type_name, "STT_TLS") == 0)
     type = BSF_OBJECT | BSF_THREAD_LOCAL;
-  else if (strcmp (typename, "notype") == 0
-	   || strcmp (typename, "0") == 0
-	   || strcmp (typename, "STT_NOTYPE") == 0)
+  else if (strcmp (type_name, "notype") == 0
+	   || strcmp (type_name, "0") == 0
+	   || strcmp (type_name, "STT_NOTYPE") == 0)
     ;
-  else if (strcmp (typename, "common") == 0
-	   || strcmp (typename, "5") == 0
-	   || strcmp (typename, "STT_COMMON") == 0)
+  else if (strcmp (type_name, "common") == 0
+	   || strcmp (type_name, "5") == 0
+	   || strcmp (type_name, "STT_COMMON") == 0)
     {
       type = BSF_OBJECT;
 
@@ -1677,9 +1678,9 @@ obj_elf_type (int ignore ATTRIBUTE_UNUSE
 	    }
 	}
     }
-  else if (strcmp (typename, "gnu_indirect_function") == 0
-	   || strcmp (typename, "10") == 0
-	   || strcmp (typename, "STT_GNU_IFUNC") == 0)
+  else if (strcmp (type_name, "gnu_indirect_function") == 0
+	   || strcmp (type_name, "10") == 0
+	   || strcmp (type_name, "STT_GNU_IFUNC") == 0)
     {
       const struct elf_backend_data *bed;
 
@@ -1688,10 +1689,10 @@ obj_elf_type (int ignore ATTRIBUTE_UNUSE
 	    /* GNU/Linux is still using the default value 0.  */
 	    || bed->elf_osabi == ELFOSABI_NONE))
 	as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
-		typename);
+		type_name);
       type = BSF_FUNCTION | BSF_GNU_INDIRECT_FUNCTION;
     }
-  else if (strcmp (typename, "gnu_unique_object") == 0)
+  else if (strcmp (type_name, "gnu_unique_object") == 0)
     {
       struct elf_backend_data *bed;
 
@@ -1700,17 +1701,17 @@ obj_elf_type (int ignore ATTRIBUTE_UNUSE
 	    /* GNU/Linux is still using the default value 0.  */
 	    || bed->elf_osabi == ELFOSABI_NONE))
 	as_bad (_("symbol type \"%s\" is supported only by GNU targets"),
-		typename);
+		type_name);
       type = BSF_OBJECT | BSF_GNU_UNIQUE;
       /* PR 10549: Always set OSABI field to LINUX for objects containing unique symbols.  */
       bed->elf_osabi = ELFOSABI_LINUX;
     }
 #ifdef md_elf_symbol_type
-  else if ((type = md_elf_symbol_type (typename, sym, elfsym)) != -1)
+  else if ((type = md_elf_symbol_type (type_name, sym, elfsym)) != -1)
     ;
 #endif
   else
-    as_bad (_("unrecognized symbol type \"%s\""), typename);
+    as_bad (_("unrecognized symbol type \"%s\""), type_name);
 
   *input_line_pointer = c;
 
@@ -1774,7 +1775,7 @@ obj_elf_init_stab_section (segT seg)
   /* Zero it out.  */
   memset (p, 0, 12);
   as_where (&file, NULL);
-  stabstr_name = xmalloc (strlen (segment_name (seg)) + 4);
+  stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4);
   strcpy (stabstr_name, segment_name (seg));
   strcat (stabstr_name, "str");
   stroff = get_stab_string_offset (file, stabstr_name);
@@ -1800,7 +1801,7 @@ adjust_stab_sections (bfd *abfd, asectio
   if (!strcmp ("str", sec->name + strlen (sec->name) - 3))
     return;
 
-  name = alloca (strlen (sec->name) + 4);
+  name = (char *) alloca (strlen (sec->name) + 4);
   strcpy (name, sec->name);
   strcat (name, "str");
   strsec = bfd_get_section_by_name (abfd, name);
@@ -2016,7 +2017,7 @@ struct group_list
 static void
 build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
 {
-  struct group_list *list = inf;
+  struct group_list *list = (struct group_list *) inf;
   const char *group_name = elf_group_name (sec);
   unsigned int i;
 
@@ -2042,9 +2043,10 @@ build_group_lists (bfd *abfd ATTRIBUTE_U
   if ((i & 127) == 0)
     {
       unsigned int newsize = i + 128;
-      list->head = xrealloc (list->head, newsize * sizeof (*list->head));
-      list->elt_count = xrealloc (list->elt_count,
-				  newsize * sizeof (*list->elt_count));
+      list->head = (asection **) xrealloc (list->head,
+                                           newsize * sizeof (*list->head));
+      list->elt_count = (unsigned int *)
+          xrealloc (list->elt_count, newsize * sizeof (*list->elt_count));
     }
   list->head[i] = sec;
   list->elt_count[i] = 1;
diff -urp src.head/gas/config/tc-i386-intel.c src.gas/gas/config/tc-i386-intel.c
--- src.head/gas/config/tc-i386-intel.c	2009-08-14 10:59:51.486195000 -0700
+++ src.gas/gas/config/tc-i386-intel.c	2009-09-10 10:10:45.915481000 -0700
@@ -65,7 +65,7 @@ intel_state;
 static struct
   {
     const char *name;
-    operatorT operator;
+    operatorT op;
     unsigned int operands;
   }
 const i386_operators[] =
@@ -91,7 +91,7 @@ const i386_operators[] =
 static struct
   {
     const char *name;
-    operatorT operator;
+    operatorT op;
     unsigned short sz[3];
   }
 const i386_types[] =
@@ -158,7 +158,7 @@ operatorT i386_operator (const char *nam
 	if (i386_operators[j].operands
 	    && i386_operators[j].operands != operands)
 	  return O_illegal;
-	return i386_operators[j].operator;
+	return i386_operators[j].op;
       }
 
   for (j = 0; i386_types[j].name; ++j)
@@ -175,7 +175,7 @@ operatorT i386_operator (const char *nam
 	  *pc = c;
 	  if (intel_syntax > 0 || operands != 1)
 	    return O_illegal;
-	  return i386_types[j].operator;
+	  return i386_types[j].op;
 	}
 
       *input_line_pointer = c;
diff -urp src.head/gas/config/tc-i386.c src.gas/gas/config/tc-i386.c
--- src.head/gas/config/tc-i386.c	2009-09-09 15:43:05.098177000 -0700
+++ src.gas/gas/config/tc-i386.c	2009-09-10 10:10:10.282723000 -0700
@@ -1851,7 +1851,7 @@ add_prefix (unsigned int prefix)
 static void
 set_code_flag (int value)
 {
-  flag_code = value;
+  flag_code = (enum flag_code) value;
   if (flag_code == CODE_64BIT)
     {
       cpu_arch_flags.bitfield.cpu64 = 1;
@@ -1876,7 +1876,7 @@ set_code_flag (int value)
 static void
 set_16bit_gcc_code_flag (int new_code_flag)
 {
-  flag_code = new_code_flag;
+  flag_code = (enum flag_code) new_code_flag;
   if (flag_code != CODE_16BIT)
     abort ();
   cpu_arch_flags.bitfield.cpu64 = 0;
@@ -1961,7 +1961,7 @@ set_sse_check (int dummy ATTRIBUTE_UNUSE
 
 static void
 check_cpu_arch_compatible (const char *name ATTRIBUTE_UNUSED,
-			   i386_cpu_flags new ATTRIBUTE_UNUSED)
+			   i386_cpu_flags new_flag ATTRIBUTE_UNUSED)
 {
 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
   static const char *arch;
@@ -1981,7 +1981,7 @@ check_cpu_arch_compatible (const char *n
 
   /* If we are targeting Intel L1OM, we must enable it.  */
   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_L1OM
-      || new.bitfield.cpul1om)
+      || new_flag.bitfield.cpul1om)
     return;
   
   as_bad (_("`%s' is not supported on `%s'"), name, arch);
@@ -6019,28 +6019,28 @@ lex_got (enum bfd_reloc_code_real *reloc
     const enum bfd_reloc_code_real rel[2];
     const i386_operand_type types64;
   } gotrel[] = {
-    { "PLTOFF",   { 0,
+    { "PLTOFF",   { _dummy_first_bfd_reloc_code_real,
 		    BFD_RELOC_X86_64_PLTOFF64 },
       OPERAND_TYPE_IMM64 },
     { "PLT",      { BFD_RELOC_386_PLT32,
 		    BFD_RELOC_X86_64_PLT32    },
       OPERAND_TYPE_IMM32_32S_DISP32 },
-    { "GOTPLT",   { 0,
+    { "GOTPLT",   { _dummy_first_bfd_reloc_code_real,
 		    BFD_RELOC_X86_64_GOTPLT64 },
       OPERAND_TYPE_IMM64_DISP64 },
     { "GOTOFF",   { BFD_RELOC_386_GOTOFF,
 		    BFD_RELOC_X86_64_GOTOFF64 },
       OPERAND_TYPE_IMM64_DISP64 },
-    { "GOTPCREL", { 0,
+    { "GOTPCREL", { _dummy_first_bfd_reloc_code_real,
 		    BFD_RELOC_X86_64_GOTPCREL },
       OPERAND_TYPE_IMM32_32S_DISP32 },
     { "TLSGD",    { BFD_RELOC_386_TLS_GD,
 		    BFD_RELOC_X86_64_TLSGD    },
       OPERAND_TYPE_IMM32_32S_DISP32 },
     { "TLSLDM",   { BFD_RELOC_386_TLS_LDM,
-		    0                         },
+		    _dummy_first_bfd_reloc_code_real },
       OPERAND_TYPE_NONE },
-    { "TLSLD",    { 0,
+    { "TLSLD",    { _dummy_first_bfd_reloc_code_real,
 		    BFD_RELOC_X86_64_TLSLD    },
       OPERAND_TYPE_IMM32_32S_DISP32 },
     { "GOTTPOFF", { BFD_RELOC_386_TLS_IE_32,
@@ -6050,17 +6050,17 @@ lex_got (enum bfd_reloc_code_real *reloc
 		    BFD_RELOC_X86_64_TPOFF32  },
       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
     { "NTPOFF",   { BFD_RELOC_386_TLS_LE,
-		    0                         },
+		    _dummy_first_bfd_reloc_code_real },
       OPERAND_TYPE_NONE },
     { "DTPOFF",   { BFD_RELOC_386_TLS_LDO_32,
 		    BFD_RELOC_X86_64_DTPOFF32 },
 
       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
     { "GOTNTPOFF",{ BFD_RELOC_386_TLS_GOTIE,
-		    0                         },
+		    _dummy_first_bfd_reloc_code_real },
       OPERAND_TYPE_NONE },
     { "INDNTPOFF",{ BFD_RELOC_386_TLS_IE,
-		    0                         },
+		    _dummy_first_bfd_reloc_code_real },
       OPERAND_TYPE_NONE },
     { "GOT",      { BFD_RELOC_386_GOT32,
 		    BFD_RELOC_X86_64_GOT32    },
@@ -6125,7 +6125,7 @@ lex_got (enum bfd_reloc_code_real *reloc
 
 	      /* Allocate and copy string.  The trailing NUL shouldn't
 		 be necessary, but be safe.  */
-	      tmpbuf = xmalloc (first + second + 2);
+	      tmpbuf = (char *) xmalloc (first + second + 2);
 	      memcpy (tmpbuf, input_line_pointer, first);
 	      if (second != 0 && *past_reloc != ' ')
 		/* Replace the relocation token with ' ', so that
@@ -7104,7 +7104,7 @@ md_estimate_size_before_relax (fragP, se
       int old_fr_fix;
 
       if (fragP->fr_var != NO_RELOC)
-	reloc_type = fragP->fr_var;
+	reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
       else if (size == 2)
 	reloc_type = BFD_RELOC_16_PCREL;
       else
@@ -7553,7 +7553,7 @@ parse_real_register (char *reg_string, c
 	      if (*s == ')')
 		{
 		  *end_op = s + 1;
-		  r = hash_find (reg_hash, "st(0)");
+		  r = (const reg_entry *) hash_find (reg_hash, "st(0)");
 		  know (r);
 		  return r + fpr;
 		}
diff -urp src.head/gas/dw2gencfi.c src.gas/gas/dw2gencfi.c
--- src.head/gas/dw2gencfi.c	2009-08-14 10:59:45.685081000 -0700
+++ src.gas/gas/dw2gencfi.c	2009-09-10 09:54:14.665201000 -0700
@@ -63,6 +63,10 @@
 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
 #endif
 
+struct cfi_escape_data {
+  struct cfi_escape_data *next;
+  expressionS exp;
+};
 
 struct cfi_insn_data
 {
@@ -87,10 +91,7 @@ struct cfi_insn_data
       symbolS *lab2;
     } ll;
 
-    struct cfi_escape_data {
-      struct cfi_escape_data *next;
-      expressionS exp;
-    } *esc;
+    struct cfi_escape_data *esc;
 
     struct {
       unsigned reg, encoding;
@@ -155,9 +156,11 @@ struct frch_cfi_data
 static struct fde_entry *
 alloc_fde_entry (void)
 {
-  struct fde_entry *fde = xcalloc (1, sizeof (struct fde_entry));
+  struct fde_entry *fde = (struct fde_entry *)
+      xcalloc (1, sizeof (struct fde_entry));
 
-  frchain_now->frch_cfi_data = xcalloc (1, sizeof (struct frch_cfi_data));
+  frchain_now->frch_cfi_data = (struct frch_cfi_data *)
+      xcalloc (1, sizeof (struct frch_cfi_data));
   frchain_now->frch_cfi_data->cur_fde_data = fde;
   *last_fde_data = fde;
   last_fde_data = &fde->next;
@@ -179,7 +182,8 @@ alloc_fde_entry (void)
 static struct cfi_insn_data *
 alloc_cfi_insn_data (void)
 {
-  struct cfi_insn_data *insn = xcalloc (1, sizeof (struct cfi_insn_data));
+  struct cfi_insn_data *insn = (struct cfi_insn_data *)
+      xcalloc (1, sizeof (struct cfi_insn_data));
   struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
 
   *cur_fde_data->last = insn;
@@ -353,7 +357,7 @@ cfi_add_CFA_remember_state (void)
 
   cfi_add_CFA_insn (DW_CFA_remember_state);
 
-  p = xmalloc (sizeof (*p));
+  p = (struct cfa_save_data *) xmalloc (sizeof (*p));
   p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
   p->next = frchain_now->frch_cfi_data->cfa_save_stack;
   frchain_now->frch_cfi_data->cfa_save_stack = p;
@@ -637,7 +641,7 @@ dot_cfi_escape (int ignored ATTRIBUTE_UN
   tail = &head;
   do
     {
-      e = xmalloc (sizeof (*e));
+      e = (struct cfi_escape_data *) xmalloc (sizeof (*e));
       do_parse_cons_expression (&e->exp, 1);
       *tail = e;
       tail = &e->next;
@@ -1454,7 +1458,7 @@ select_cie_for_fde (struct fde_entry *fd
     fail:;
     }
 
-  cie = xmalloc (sizeof (struct cie_entry));
+  cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
   cie->next = cie_root;
   cie_root = cie;
   cie->return_column = fde->return_column;
diff -urp src.head/gas/dwarf2dbg.c src.gas/gas/dwarf2dbg.c
--- src.head/gas/dwarf2dbg.c	2009-09-07 13:21:22.777508000 -0700
+++ src.gas/gas/dwarf2dbg.c	2009-09-10 09:51:56.871064000 -0700
@@ -467,7 +467,7 @@ get_filenum (const char *filename, unsig
 		     xrealloc (dirs, (dir + 32) * sizeof (const char *));
 	    }
 
-	  dirs[dir] = xmalloc (dir_len + 1);
+	  dirs[dir] = (char *) xmalloc (dir_len + 1);
 	  memcpy (dirs[dir], filename, dir_len);
 	  dirs[dir][dir_len] = '\0';
 	  dirs_in_use = dir + 1;
diff -urp src.head/gas/dwarf2dbg.h src.gas/gas/dwarf2dbg.h
--- src.head/gas/dwarf2dbg.h	2009-09-07 13:21:22.797478000 -0700
+++ src.gas/gas/dwarf2dbg.h	2009-09-10 09:51:42.901065000 -0700
@@ -83,7 +83,7 @@ extern void dwarf2_emit_label (symbolS *
 
 /* True when we've seen a .loc directive recently.  Used to avoid
    doing work when there's nothing to do.  */
-bfd_boolean dwarf2_loc_directive_seen;
+extern bfd_boolean dwarf2_loc_directive_seen;
 
 /* True when we're supposed to set the basic block mark whenever a label
    is seen.  Unless the target is doing Something Weird, just call 
diff -urp src.head/gas/ehopt.c src.gas/gas/ehopt.c
--- src.head/gas/ehopt.c	2009-09-07 13:21:22.853442000 -0700
+++ src.gas/gas/ehopt.c	2009-09-10 09:55:26.653728000 -0700
@@ -227,6 +227,19 @@ get_cie_info (struct cie_info *info)
   return 1;
 }
 
+enum frame_state
+{
+  state_idle,
+  state_saw_size,
+  state_saw_cie_offset,
+  state_saw_pc_begin,
+  state_seeing_aug_size,
+  state_skipping_aug,
+  state_wait_loc4,
+  state_saw_loc4,
+  state_error,
+};
+
 /* This function is called from emit_expr.  It looks for cases which
    we can optimize.
 
@@ -245,18 +258,7 @@ check_eh_frame (expressionS *exp, unsign
 {
   struct frame_data
   {
-    enum frame_state
-    {
-      state_idle,
-      state_saw_size,
-      state_saw_cie_offset,
-      state_saw_pc_begin,
-      state_seeing_aug_size,
-      state_skipping_aug,
-      state_wait_loc4,
-      state_saw_loc4,
-      state_error,
-    } state;
+    enum frame_state state;
 
     int cie_info_ok;
     struct cie_info cie_info;
@@ -324,7 +326,7 @@ check_eh_frame (expressionS *exp, unsign
     case state_saw_size:
     case state_saw_cie_offset:
       /* Assume whatever form it appears in, it appears atomically.  */
-      d->state += 1;
+      d->state = (enum frame_state) (d->state + 1);
       break;
 
     case state_saw_pc_begin:
diff -urp src.head/gas/expr.c src.gas/gas/expr.c
--- src.head/gas/expr.c	2009-09-07 13:21:22.893473000 -0700
+++ src.gas/gas/expr.c	2009-09-10 09:57:02.300815000 -0700
@@ -48,7 +48,7 @@ static void mri_char_constant (expressio
 static void current_location (expressionS *);
 static void clean_up_expression (expressionS * expressionP);
 static segT operand (expressionS *, enum expr_mode);
-static operatorT operator (int *);
+static operatorT operatorf (int *);
 
 extern const char EXP_CHARS[], FLT_CHARS[];
 
@@ -1228,9 +1228,9 @@ operand (expressionS *expressionP, enum 
 
 #ifdef md_operator
 	  {
-	    operatorT operator = md_operator (name, 1, &c);
+	    operatorT op = md_operator (name, 1, &c);
 
-	    switch (operator)
+	    switch (op)
 	      {
 	      case O_uminus:
 		*input_line_pointer = c;
@@ -1250,14 +1250,14 @@ operand (expressionS *expressionP, enum 
 	      default:
 		break;
 	      }
-	    if (operator != O_absent && operator != O_illegal)
+	    if (op != O_absent && op != O_illegal)
 	      {
 		*input_line_pointer = c;
 		expr (9, expressionP, mode);
 		expressionP->X_add_symbol = make_expr_symbol (expressionP);
 		expressionP->X_op_symbol = NULL;
 		expressionP->X_add_number = 0;
-		expressionP->X_op = operator;
+		expressionP->X_op = op;
 		break;
 	      }
 	  }
@@ -1546,10 +1546,10 @@ expr_set_precedence (void)
 }
 
 void
-expr_set_rank (operatorT operator, operator_rankT rank)
+expr_set_rank (operatorT op, operator_rankT rank)
 {
-  gas_assert (operator >= O_md1 && operator < ARRAY_SIZE (op_rank));
-  op_rank[operator] = rank;
+  gas_assert (op >= O_md1 && op < ARRAY_SIZE (op_rank));
+  op_rank[op] = rank;
 }
 
 /* Initialize the expression parser.  */
@@ -1572,7 +1572,7 @@ expr_begin (void)
    Does not advance INPUT_LINE_POINTER.  */
 
 static inline operatorT
-operator (int *num_chars)
+operatorf (int *num_chars)
 {
   int c;
   operatorT ret;
@@ -1732,7 +1732,7 @@ expr (int rankarg,		/* Larger # is highe
   /* operand () gobbles spaces.  */
   know (*input_line_pointer != ' ');
 
-  op_left = operator (&op_chars);
+  op_left = operatorf (&op_chars);
   while (op_left != O_illegal && op_rank[(int) op_left] > rank)
     {
       segT rightseg;
@@ -1763,7 +1763,7 @@ expr (int rankarg,		/* Larger # is highe
 	    }
 	}
 
-      op_right = operator (&op_chars);
+      op_right = operatorf (&op_chars);
 
       know (op_right == O_illegal || op_left == O_index
 	    || op_rank[(int) op_right] <= op_rank[(int) op_left]);
diff -urp src.head/gas/frags.c src.gas/gas/frags.c
--- src.head/gas/frags.c	2009-09-07 13:21:22.969442000 -0700
+++ src.gas/gas/frags.c	2009-09-10 09:58:05.313685000 -0700
@@ -69,7 +69,7 @@ frag_alloc (struct obstack *ob)
   (void) obstack_alloc (ob, 0);
   oalign = obstack_alignment_mask (ob);
   obstack_alignment_mask (ob) = 0;
-  ptr = obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
+  ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
   obstack_alignment_mask (ob) = oalign;
   memset (ptr, 0, SIZEOF_STRUCT_FRAG);
   return ptr;
diff -urp src.head/gas/hash.c src.gas/gas/hash.c
--- src.head/gas/hash.c	2009-06-16 09:07:26.074705000 -0700
+++ src.gas/gas/hash.c	2009-09-10 09:58:38.804898000 -0700
@@ -113,10 +113,10 @@ hash_new (void)
 
   size = get_gas_hash_table_size ();
 
-  ret = xmalloc (sizeof *ret);
+  ret = (struct hash_control *) xmalloc (sizeof *ret);
   obstack_begin (&ret->memory, chunksize);
   alloc = size * sizeof (struct hash_entry *);
-  ret->table = obstack_alloc (&ret->memory, alloc);
+  ret->table = (struct hash_entry **) obstack_alloc (&ret->memory, alloc);
   memset (ret->table, 0, alloc);
   ret->size = size;
 
@@ -237,7 +237,7 @@ hash_insert (struct hash_control *table,
   ++table->insertions;
 #endif
 
-  p = obstack_alloc (&table->memory, sizeof (*p));
+  p = (struct hash_entry *) obstack_alloc (&table->memory, sizeof (*p));
   p->string = key;
   p->hash = hash;
   p->data = value;
@@ -274,7 +274,7 @@ hash_jam (struct hash_control *table, co
       ++table->insertions;
 #endif
 
-      p = obstack_alloc (&table->memory, sizeof (*p));
+      p = (struct hash_entry *) obstack_alloc (&table->memory, sizeof (*p));
       p->string = key;
       p->hash = hash;
       p->data = value;
diff -urp src.head/gas/input-scrub.c src.gas/gas/input-scrub.c
--- src.head/gas/input-scrub.c	2009-09-07 13:21:23.351445000 -0700
+++ src.gas/gas/input-scrub.c	2009-09-10 09:59:08.036637000 -0700
@@ -165,7 +165,8 @@ input_scrub_push (char *saved_position)
   buffer_length = input_file_buffer_size ();
   sb_index = -1;
 
-  buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
+  buffer_start = (char *) xmalloc ((BEFORE_SIZE + buffer_length
+                                    + buffer_length + AFTER_SIZE));
   memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE);
 
   return saved;
@@ -209,7 +210,8 @@ input_scrub_begin (void)
 
   buffer_length = input_file_buffer_size ();
 
-  buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
+  buffer_start = (char *) xmalloc ((BEFORE_SIZE + buffer_length
+                                    + buffer_length + AFTER_SIZE));
   memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE);
 
   /* Line number things.  */
@@ -363,10 +365,10 @@ input_scrub_next_buffer (char **bufp)
 
 	  limoff = limit - buffer_start;
 	  buffer_length += input_file_buffer_size ();
-	  buffer_start = xrealloc (buffer_start,
-				   (BEFORE_SIZE
-				    + 2 * buffer_length
-				    + AFTER_SIZE));
+	  buffer_start = (char *) xrealloc (buffer_start,
+                                            (BEFORE_SIZE
+                                             + 2 * buffer_length
+                                             + AFTER_SIZE));
 	  *bufp = buffer_start + BEFORE_SIZE;
 	  limit = input_file_give_next_buffer (buffer_start + limoff);
 
diff -urp src.head/gas/listing.c src.gas/gas/listing.c
--- src.head/gas/listing.c	2009-09-07 13:21:23.399454000 -0700
+++ src.gas/gas/listing.c	2009-09-10 10:00:43.690762000 -0700
@@ -130,6 +130,18 @@ typedef struct file_info_struct
   int                       at_end;
 } file_info_type;
 
+enum edict_enum
+{
+  EDICT_NONE,
+  EDICT_SBTTL,
+  EDICT_TITLE,
+  EDICT_NOLIST,
+  EDICT_LIST,
+  EDICT_NOLIST_NEXT,
+  EDICT_EJECT
+};
+
+
 /* This structure remembers which line from which file goes into which
    frag.  */
 struct list_info_struct
@@ -160,16 +172,7 @@ struct list_info_struct
   /* Pointer to any error message associated with this line.  */
   char *message;
 
-  enum
-    {
-      EDICT_NONE,
-      EDICT_SBTTL,
-      EDICT_TITLE,
-      EDICT_NOLIST,
-      EDICT_LIST,
-      EDICT_NOLIST_NEXT,
-      EDICT_EJECT
-    } edict;
+  enum edict_enum edict;
   char *edict_arg;
 
   /* Nonzero if this line is to be omitted because it contains
@@ -260,7 +263,7 @@ file_info (const char *file_name)
     }
 
   /* Make new entry.  */
-  p = xmalloc (sizeof (file_info_type));
+  p = (file_info_type *) xmalloc (sizeof (file_info_type));
   p->next = file_info_head;
   file_info_head = p;
   p->filename = xstrdup (file_name);
@@ -352,7 +355,7 @@ listing_newline (char *ps)
 
 	  len = (copy - input_line_pointer) + 2;
 
-	  copy = xmalloc (len);
+	  copy = (char *) xmalloc (len);
 
 	  if (copy != NULL)
 	    {
@@ -1147,8 +1150,8 @@ listing_listing (char *name ATTRIBUTE_UN
   int show_listing = 1;
   unsigned int width;
 
-  buffer = xmalloc (listing_rhs_width);
-  data_buffer = xmalloc (MAX_BYTES);
+  buffer = (char *) xmalloc (listing_rhs_width);
+  data_buffer = (char *) xmalloc (MAX_BYTES);
   eject = 1;
   list = head->next;
 
@@ -1509,7 +1512,7 @@ listing_title (int depth)
 	  if (listing)
 	    {
 	      length = input_line_pointer - start;
-	      ttl = xmalloc (length + 1);
+	      ttl = (char *) xmalloc (length + 1);
 	      memcpy (ttl, start, length);
 	      ttl[length] = 0;
 	      listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
diff -urp src.head/gas/macro.c src.gas/gas/macro.c
--- src.head/gas/macro.c	2009-06-16 09:07:26.133696000 -0700
+++ src.gas/gas/macro.c	2009-09-10 10:02:09.783335000 -0700
@@ -393,7 +393,7 @@ get_any_string (int idx, sb *in, sb *out
 	}
       else
 	{
-	  char *br_buf = xmalloc(1);
+	  char *br_buf = (char *) xmalloc(1);
 	  char *in_br = br_buf;
 
 	  *in_br = '\0';
@@ -424,7 +424,7 @@ get_any_string (int idx, sb *in, sb *out
 		    --in_br;
 		  else
 		    {
-		      br_buf = xmalloc(strlen(in_br) + 2);
+		      br_buf = (char *) xmalloc(strlen(in_br) + 2);
 		      strcpy(br_buf + 1, in_br);
 		      free(in_br);
 		      in_br = br_buf;
@@ -457,7 +457,7 @@ new_formal (void)
 {
   formal_entry *formal;
 
-  formal = xmalloc (sizeof (formal_entry));
+  formal = (formal_entry *) xmalloc (sizeof (formal_entry));
 
   sb_new (&formal->name);
   sb_new (&formal->def);
@@ -1273,7 +1273,7 @@ delete_macro (const char *name)
   /* We can only ask hash_delete to free memory if we are deleting
      macros in reverse order to their definition.
      So just clear out the entry.  */
-  if ((macro = hash_find (macro_hash, copy)) != NULL)
+  if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL)
     {
       hash_jam (macro_hash, copy, NULL);
       free_macro (macro);
diff -urp src.head/gas/macro.h src.gas/gas/macro.h
--- src.head/gas/macro.h	2009-09-07 13:21:23.432440000 -0700
+++ src.gas/gas/macro.h	2009-09-10 10:01:48.939401000 -0700
@@ -34,6 +34,13 @@
    name and its default value.  Each time the macro is expanded, the
    formals get the actual values attached to them.  */
 
+enum formal_type
+  {
+    FORMAL_OPTIONAL,
+    FORMAL_REQUIRED,
+    FORMAL_VARARG
+  };
+
 /* Describe the formal arguments to a macro.  */
 
 typedef struct formal_struct {
@@ -42,12 +49,7 @@ typedef struct formal_struct {
   sb def;			/* The default value.  */
   sb actual;			/* The actual argument (changed on each expansion).  */
   int index;			/* The index of the formal 0..formal_count - 1.  */
-  enum formal_type
-    {
-      FORMAL_OPTIONAL,
-      FORMAL_REQUIRED,
-      FORMAL_VARARG
-    } type;			/* The kind of the formal.  */
+  enum formal_type type;	/* The kind of the formal.  */
 } formal_entry;
 
 /* Other values found in the index field of a formal_entry.  */
diff -urp src.head/gas/read.c src.gas/gas/read.c
--- src.head/gas/read.c	2009-09-09 15:43:04.991145000 -0700
+++ src.gas/gas/read.c	2009-09-10 10:03:19.545210000 -0700
@@ -1034,7 +1034,7 @@ read_a_source_file (char *name)
 		     that goes with this #APP  There is one.  The specs
 		     guarantee it...  */
 		  tmp_len = buffer_limit - s;
-		  tmp_buf = xmalloc (tmp_len + 1);
+		  tmp_buf = (char *) xmalloc (tmp_len + 1);
 		  memcpy (tmp_buf, s, tmp_len);
 		  do
 		    {
@@ -1050,7 +1050,7 @@ read_a_source_file (char *name)
 		      else
 			num = buffer_limit - buffer;
 
-		      tmp_buf = xrealloc (tmp_buf, tmp_len + num);
+		      tmp_buf = (char *) xrealloc (tmp_buf, tmp_len + num);
 		      memcpy (tmp_buf + tmp_len, buffer, num);
 		      tmp_len += num;
 		    }
@@ -1087,7 +1087,7 @@ read_a_source_file (char *name)
 		      break;
 		    }
 
-		  new_buf = xrealloc (new_buf, new_length + 100);
+		  new_buf = (char *) xrealloc (new_buf, new_length + 100);
 		  new_tmp = new_buf + new_length;
 		  new_length += 100;
 		}
@@ -2097,7 +2097,7 @@ s_vendor_attribute (int vendor)
       if (i == 0)
 	goto bad;
 
-      name = alloca (i + 1);
+      name = (char *) alloca (i + 1);
       memcpy (name, s, i);
       name[i] = '\0';
 
@@ -3857,7 +3857,7 @@ s_reloc (int ignore ATTRIBUTE_UNUSED)
   int c;
   struct reloc_list *reloc;
 
-  reloc = xmalloc (sizeof (*reloc));
+  reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
@@ -5407,7 +5407,7 @@ demand_copy_string (int *lenP)
       /* JF this next line is so demand_copy_C_string will return a
 	 null terminated string.  */
       obstack_1grow (&notes, '\0');
-      retval = obstack_finish (&notes);
+      retval = (char *) obstack_finish (&notes);
     }
   else
     {
@@ -5516,7 +5516,7 @@ s_incbin (int x ATTRIBUTE_UNUSED)
     {
       int i;
 
-      path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
+      path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
 
       for (i = 0; i < include_dir_count; i++)
 	{
@@ -5586,7 +5586,7 @@ s_include (int arg ATTRIBUTE_UNUSED)
 {
   char *filename;
   int i;
-  FILE *try;
+  FILE *try_file;
   char *path;
 
   if (!flag_m68k_mri)
@@ -5613,22 +5613,23 @@ s_include (int arg ATTRIBUTE_UNUSED)
 	}
 
       obstack_1grow (&notes, '\0');
-      filename = obstack_finish (&notes);
+      filename = (char *) obstack_finish (&notes);
       while (!is_end_of_line[(unsigned char) *input_line_pointer])
 	++input_line_pointer;
     }
 
   demand_empty_rest_of_line ();
-  path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
+  path = (char *) xmalloc ((unsigned long) i
+                           + include_dir_maxlen + 5 /* slop */ );
 
   for (i = 0; i < include_dir_count; i++)
     {
       strcpy (path, include_dirs[i]);
       strcat (path, "/");
       strcat (path, filename);
-      if (0 != (try = fopen (path, FOPEN_RT)))
+      if (0 != (try_file = fopen (path, FOPEN_RT)))
 	{
-	  fclose (try);
+	  fclose (try_file);
 	  goto gotit;
 	}
     }
diff -urp src.head/gas/remap.c src.gas/gas/remap.c
--- src.head/gas/remap.c	2009-06-16 09:07:26.188659000 -0700
+++ src.gas/gas/remap.c	2009-09-10 10:03:33.976140000 -0700
@@ -52,7 +52,7 @@ add_debug_prefix_map (const char *arg)
       as_fatal (_("invalid argument '%s' to -fdebug-prefix-map"), arg);
       return;
     }
-  map = xmalloc (sizeof (debug_prefix_map));
+  map = (struct debug_prefix_map *) xmalloc (sizeof (debug_prefix_map));
   o = xstrdup (arg);
   map->old_prefix = o;
   map->old_len = p - arg;
diff -urp src.head/gas/stabs.c src.gas/gas/stabs.c
--- src.head/gas/stabs.c	2009-06-16 09:07:26.197662000 -0700
+++ src.gas/gas/stabs.c	2009-09-10 10:03:44.073700000 -0700
@@ -498,7 +498,7 @@ stabs_generate_asm_file (void)
       char *dir2;
 
       dir = remap_debug_filename (getpwd ());
-      dir2 = alloca (strlen (dir) + 2);
+      dir2 = (char *) alloca (strlen (dir) + 2);
       sprintf (dir2, "%s%s", dir, "/");
       generate_asm_file (N_SO, dir2);
     }
@@ -536,7 +536,7 @@ generate_asm_file (int type, char *file)
   /* Allocate enough space for the file name (possibly extended with
      doubled up backslashes), the symbol name, and the other characters
      that make up a stabs file directive.  */
-  bufp = buf = xmalloc (2 * strlen (file) + strlen (sym) + 12);
+  bufp = buf = (char *) xmalloc (2 * strlen (file) + strlen (sym) + 12);
 
   *bufp++ = '"';
 
diff -urp src.head/gas/subsegs.c src.gas/gas/subsegs.c
--- src.head/gas/subsegs.c	2009-09-07 13:21:23.576452000 -0700
+++ src.gas/gas/subsegs.c	2009-09-10 10:04:26.271571000 -0700
@@ -65,7 +65,7 @@ subseg_change (register segT seg, regist
 
   if (! seginfo)
     {
-      seginfo = xcalloc (1, sizeof (*seginfo));
+      seginfo = (segment_info_type *) xcalloc (1, sizeof (*seginfo));
       seginfo->bfd_section = seg;
       bfd_set_section_userdata (stdoutput, seg, seginfo);
     }
@@ -103,7 +103,7 @@ subseg_set_rest (segT seg, subsegT subse
     {
       /* This should be the only code that creates a frchainS.  */
 
-      newP = obstack_alloc (&frchains, sizeof (frchainS));
+      newP = (frchainS *) obstack_alloc (&frchains, sizeof (frchainS));
       newP->frch_subseg = subseg;
       newP->fix_root = NULL;
       newP->fix_tail = NULL;
@@ -167,7 +167,7 @@ subseg_get (const char *segname, int for
   if (! seginfo)
     {
       secptr->output_section = secptr;
-      seginfo = xcalloc (1, sizeof (*seginfo));
+      seginfo = (segment_info_type *) xcalloc (1, sizeof (*seginfo));
       seginfo->bfd_section = secptr;
       bfd_set_section_userdata (stdoutput, secptr, seginfo);
     }
diff -urp src.head/gas/symbols.c src.gas/gas/symbols.c
--- src.head/gas/symbols.c	2009-09-09 15:43:05.007168000 -0700
+++ src.gas/gas/symbols.c	2009-09-10 10:05:33.432776000 -0700
@@ -109,7 +109,7 @@ save_symbol_name (const char *name)
 
   name_length = strlen (name) + 1;	/* +1 for \0.  */
   obstack_grow (&notes, name, name_length);
-  ret = obstack_finish (&notes);
+  ret = (char *) obstack_finish (&notes);
 
 #ifdef tc_canonicalize_symbol_name
   ret = tc_canonicalize_symbol_name (ret);
@@ -137,7 +137,7 @@ symbol_create (const char *name, /* It i
 
   preserved_copy_of_name = save_symbol_name (name);
 
-  symbolP = obstack_alloc (&notes, sizeof (symbolS));
+  symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
 
   /* symbol must be born in some fixed state.  This seems as good as any.  */
   memset (symbolP, 0, sizeof (symbolS));
@@ -197,7 +197,7 @@ local_symbol_make (const char *name, seg
 
   name_copy = save_symbol_name (name);
 
-  ret = obstack_alloc (&notes, sizeof *ret);
+  ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
   ret->lsy_marker = NULL;
   ret->lsy_name = name_copy;
   ret->lsy_section = section;
@@ -563,7 +563,7 @@ symbol_clone (symbolS *orgsymP, int repl
     orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
   bsymorg = orgsymP->bsym;
 
-  newsymP = obstack_alloc (&notes, sizeof (*newsymP));
+  newsymP = (symbolS *) obstack_alloc (&notes, sizeof (*newsymP));
   *newsymP = *orgsymP;
   bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
   if (bsymnew == NULL)
@@ -1453,7 +1453,7 @@ static void
 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
 {
   if (value != NULL)
-    resolve_symbol_value (value);
+    resolve_symbol_value ((symbolS *) value);
 }
 
 /* Resolve all local symbols.  */
@@ -1603,7 +1603,7 @@ define_dollar_label (long label)
     {
       dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
       dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
-      dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
+      dollar_label_defines = (char *) xmalloc (DOLLAR_LABEL_BUMP_BY);
       dollar_label_max = DOLLAR_LABEL_BUMP_BY;
       dollar_label_count = 0;
     }
@@ -1614,7 +1614,7 @@ define_dollar_label (long label)
 					 dollar_label_max * sizeof (long));
       dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
 					  dollar_label_max * sizeof (long));
-      dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
+      dollar_label_defines = (char *) xrealloc (dollar_label_defines, dollar_label_max);
     }				/* if we needed to grow  */
 
   dollar_labels[dollar_label_count] = label;
@@ -1887,7 +1887,7 @@ decode_local_label_name (char *s)
     instance_number = (10 * instance_number) + *p - '0';
 
   message_format = _("\"%d\" (instance number %d of a %s label)");
-  symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
+  symbol_decode = (char *) obstack_alloc (&notes, strlen (message_format) + 30);
   sprintf (symbol_decode, message_format, label_number, instance_number, type);
 
   return symbol_decode;
diff -urp src.head/gas/write.c src.gas/gas/write.c
--- src.head/gas/write.c	2009-09-07 13:21:23.648452000 -0700
+++ src.gas/gas/write.c	2009-09-10 10:06:06.136105000 -0700
@@ -156,7 +156,7 @@ fix_new_internal (fragS *frag,		/* Which
 
   n_fixups++;
 
-  fixP = obstack_alloc (&notes, sizeof (fixS));
+  fixP = (fixS *) obstack_alloc (&notes, sizeof (fixS));
 
   fixP->fx_frag = frag;
   fixP->fx_where = where;
@@ -1170,7 +1170,7 @@ write_relocs (bfd *abfd, asection *sec, 
 	rp = &r->next;
     }
 
-  relocs = xcalloc (n, sizeof (arelent *));
+  relocs = (arelent **) xcalloc (n, sizeof (arelent *));
 
   i = 0;
   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
@@ -1398,7 +1398,7 @@ set_symtab (void)
       int i;
       bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
 
-      asympp = bfd_alloc (stdoutput, amt);
+      asympp = (asymbol **) bfd_alloc (stdoutput, amt);
       symp = symbol_rootP;
       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
 	{
diff -urp src.head/libiberty/regex.c src.gas/libiberty/regex.c
--- src.head/libiberty/regex.c	2009-06-16 09:07:22.690146000 -0700
+++ src.gas/libiberty/regex.c	2009-09-10 09:49:33.190912000 -0700
@@ -5908,22 +5908,24 @@ byte_re_match_2_internal (struct re_patt
              longest match, try backtracking.  */
           if (d != end_match_2)
 	    {
-	      /* 1 if this match ends in the same string (string1 or string2)
-		 as the best previous match.  */
-	      boolean same_str_p = (FIRST_STRING_P (match_end)
-				    == MATCHING_IN_FIRST_STRING);
 	      /* 1 if this match is the best seen so far.  */
 	      boolean best_match_p;
 
-	      /* AIX compiler got confused when this was combined
-		 with the previous declaration.  */
-	      if (same_str_p)
-		best_match_p = d > match_end;
-	      else
-		best_match_p = !MATCHING_IN_FIRST_STRING;
-
-              DEBUG_PRINT1 ("backtracking.\n");
+              {
+                /* 1 if this match ends in the same string (string1 or string2)
+                   as the best previous match.  */
+                boolean same_str_p = (FIRST_STRING_P (match_end)
+                                      == MATCHING_IN_FIRST_STRING);
+
+                /* AIX compiler got confused when this was combined
+                   with the previous declaration.  */
+                if (same_str_p)
+                  best_match_p = d > match_end;
+                else
+                  best_match_p = !MATCHING_IN_FIRST_STRING;
 
+                DEBUG_PRINT1 ("backtracking.\n");
+              }
               if (!FAIL_STACK_EMPTY ())
                 { /* More failure points to try.  */