gas more enum casts

Remove more unnecessary enum casts.

diff --git a/gas/cond.c b/gas/cond.c
index c14399dc545be96a458d0d3229833e299b591080..27898df5dfa891b8af94967a692e652ea0707781 100644 (file)
--- a/gas/cond.c
+++ b/gas/cond.c
@@ -348,7 +348,7 @@ s_elseif (int arg)
       if (operand.X_op != O_constant)
        as_bad (_("non-constant expression in \".elseif\" statement"));
 
-      switch ((operatorT) arg)
+      switch (arg)
        {
        case O_eq: t = operand.X_add_number == 0; break;
        case O_ne: t = operand.X_add_number != 0; break;

diff --git a/gas/config/obj-macho.c b/gas/config/obj-macho.c
index d0cd3af958eaedfe4137a15979676462b17d252e..ae26d670b18386382b2aff2c2752f1c158825f51 100644 (file)
--- a/gas/config/obj-macho.c
+++ b/gas/config/obj-macho.c
@@ -960,7 +960,7 @@ obj_mach_o_fileprop (int prop)
   if (prop < 0 || prop >= OBJ_MACH_O_FILE_PROP_MAX)
     as_fatal (_("internal error: bad file property ID %d"), prop);
 
-  switch ((obj_mach_o_file_properties) prop)
+  switch (prop)
     {
       case OBJ_MACH_O_FILE_PROP_SUBSECTS_VIA_SYMS:
         obj_mach_o_subsections_by_symbols = 1;
@@ -1023,7 +1023,7 @@ obj_mach_o_set_symbol_qualifier (symbolS *sym, int type)
   if (sec != NULL)
     sectype = sec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
 
-  switch ((obj_mach_o_symbol_type) type)
+  switch (type)
     {
       case OBJ_MACH_O_SYM_LOCAL:
        /* This is an extension over the system tools.  */

diff --git a/gas/config/tc-alpha.c b/gas/config/tc-alpha.c
index 2d66986560f0d1b2795774742b0d6c1a8edead55..bfdf338615d8bb15b6c4333d3c0fa2707ec494c1 100644 (file)
--- a/gas/config/tc-alpha.c
+++ b/gas/config/tc-alpha.c
@@ -442,7 +442,7 @@ static int alpha_flag_show_after_trunc = 0;         /* -H */
 #define ALPHA_RELOC_TABLE(op)                                          \
 (&alpha_reloc_op[ ((!USER_RELOC_P (op))                                        \
                  ? (abort (), 0)                                       \
-                 : (int) (op) - (int) O_literal) ])
+                 : (op) - O_literal) ])
 
 #define DEF(NAME, RELOC, REQ, ALLOW) \
  { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}

diff --git a/gas/config/tc-arc.c b/gas/config/tc-arc.c
index ff14e91f8a461a0c83e5f32aee0ba3247d695fb4..391ff6f6f9ec5647f22d220fc8ba73fd20615ab5 100644 (file)
--- a/gas/config/tc-arc.c
+++ b/gas/config/tc-arc.c
@@ -522,7 +522,7 @@ static unsigned cl_features = 0;
 #define ARC_RELOC_TABLE(op)                            \
   (&arc_reloc_op[ ((!USER_RELOC_P (op))                        \
                   ? (abort (), 0)                      \
-                  : (int) (op) - (int) O_gotoff) ])
+                  : (op) - O_gotoff) ])
 
 #define DEF(NAME, RELOC, REQ)                          \
   { #NAME, sizeof (#NAME)-1, O_##NAME, RELOC, REQ}
@@ -1444,7 +1444,7 @@ apply_fixups (struct arc_insn *insn, fragS *fragP, int fix)
        offset = insn->len;
 
       /* Some fixups are only used internally, thus no howto.  */
-      if ((int) fixup->reloc == 0)
+      if (fixup->reloc == 0)
        as_fatal (_("Unhandled reloc type"));
 
       if ((int) fixup->reloc < 0)

diff --git a/gas/config/tc-hppa.c b/gas/config/tc-hppa.c
index 5018dfc1e998b11a338971afee1377cf120ecf4a..3240e8d1a7a50721a22477d5bc174320de1954cb 100644 (file)
--- a/gas/config/tc-hppa.c
+++ b/gas/config/tc-hppa.c
@@ -1447,7 +1447,7 @@ tc_gen_reloc (asection *section, fixS *fixp)
                                            (bfd_reloc_code_real_type) code);
       reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
 
-      gas_assert (reloc->howto && (unsigned int) code == reloc->howto->type);
+      gas_assert (reloc->howto && code == reloc->howto->type);
       break;
     }
 #else /* OBJ_SOM */

diff --git a/gas/config/tc-spu.c b/gas/config/tc-spu.c
index 1c8f7c5f8957fe2fbc14d23264cb4d617bb46051..82e0eb1df311af4c9fe24ae79ad3e580437a035f 100644 (file)
--- a/gas/config/tc-spu.c
+++ b/gas/config/tc-spu.c
@@ -298,7 +298,7 @@ md_assemble (char *op)
          insn.reloc[i] = BFD_RELOC_NONE;
        }
       insn.opcode = format->opcode;
-      insn.tag = (enum spu_insns) (format - spu_opcodes);
+      insn.tag = format - spu_opcodes;
 
       syntax_error_arg = 0;
       syntax_error_param = 0;

diff --git a/gas/config/tc-xtensa.c b/gas/config/tc-xtensa.c
index 18896080fbbfc0fb2e5b23832d22a1c815578b43..040e3977a81adb38eea6ae151162da583edb1874 100644 (file)
--- a/gas/config/tc-xtensa.c
+++ b/gas/config/tc-xtensa.c
@@ -1312,7 +1312,7 @@ get_directive (directiveE *directive, bool *negated)
       if (strncmp (directive_string, directive_info[i].name, len) == 0)
        {
          input_line_pointer += len;
-         *directive = (directiveE) i;
+         *directive = i;
          if (*negated && !directive_info[i].can_be_negated)
            as_bad (_("directive %s cannot be negated"),
                    directive_info[i].name);
@@ -1321,7 +1321,7 @@ get_directive (directiveE *directive, bool *negated)
     }
 
   as_bad (_("unknown directive"));
-  *directive = (directiveE) XTENSA_UNDEFINED;
+  *directive = XTENSA_UNDEFINED;
 }
 
 
@@ -10321,7 +10321,7 @@ relax_frag_immed (segT segP,
                                 min_steps, stretch);
   gas_assert (num_steps >= min_steps && num_steps <= RELAX_IMMED_MAXSTEPS);
 
-  fragP->tc_frag_data.slot_subtypes[slot] = (int) RELAX_IMMED + num_steps;
+  fragP->tc_frag_data.slot_subtypes[slot] = RELAX_IMMED + num_steps;
 
   /* Figure out the number of bytes needed.  */
   num_literal_bytes = get_num_stack_literal_bytes (&istack);
@@ -10350,8 +10350,7 @@ relax_frag_immed (segT segP,
                                         min_steps, stretch + old_size);
          gas_assert (num_steps >= min_steps && num_steps <= RELAX_IMMED_MAXSTEPS);
 
-         fragP->tc_frag_data.slot_subtypes[slot]
-           = (int) RELAX_IMMED + num_steps;
+         fragP->tc_frag_data.slot_subtypes[slot] = RELAX_IMMED + num_steps;
 
          num_literal_bytes = get_num_stack_literal_bytes (&istack);
          literal_diff

diff --git a/gas/ecoff.c b/gas/ecoff.c
index c84d0a8b755680a5067fc664ad87883b705f06ff..360127b53b34f795e846f020a44bdd7b0aad395a 100644 (file)
--- a/gas/ecoff.c
+++ b/gas/ecoff.c
@@ -1379,7 +1379,7 @@ static const st_t map_coff_sym_type[] = {
 };
 
 /* Keep track of different sized allocation requests.  */
-static alloc_info_t alloc_counts[(int) alloc_type_last];
+static alloc_info_t alloc_counts[alloc_type_last];
 \f
 /* Record whether we have seen any debugging information.  */
 int ecoff_debugging_seen = 0;
@@ -1529,8 +1529,8 @@ add_varray_page (varray_t *vp /* varray to add page to */)
 #endif
     new_links->datum = allocate_page ();
 
-  alloc_counts[(int) alloc_type_varray].total_alloc++;
-  alloc_counts[(int) alloc_type_varray].total_pages++;
+  alloc_counts[alloc_type_varray].total_alloc++;
+  alloc_counts[alloc_type_varray].total_pages++;
 
   new_links->start_index = vp->num_allocated;
   vp->objects_last_page = 0;
@@ -1635,8 +1635,8 @@ add_ecoff_symbol (const char *str,        /* symbol name */
   psym->sym_index = -1;
   memset (&psym->ecoff_sym, 0, sizeof (EXTR));
   psym->ecoff_sym.asym.value = value;
-  psym->ecoff_sym.asym.st = (unsigned) type;
-  psym->ecoff_sym.asym.sc = (unsigned) storage;
+  psym->ecoff_sym.asym.st = type;
+  psym->ecoff_sym.asym.sc = storage;
   psym->ecoff_sym.asym.index = indx;
 
   /* If there is an associated symbol, we wait until the end of the
@@ -1700,7 +1700,7 @@ add_ecoff_symbol (const char *str,        /* symbol name */
        as_fatal (_("too many st_End's"));
       else
        {
-         st_t begin_type = (st_t) pscope->lsym->ecoff_sym.asym.st;
+         st_t begin_type = pscope->lsym->ecoff_sym.asym.st;
 
          psym->begin_ptr = pscope->lsym;
 
@@ -1861,16 +1861,16 @@ add_aux_sym_tir (type_info_t *t,        /* current type information */
   vp = &cur_file_ptr->aux_syms;
 
   memset (&aux, 0, sizeof (aux));
-  aux.ti.bt = (int) t->basic_type;
+  aux.ti.bt = t->basic_type;
   aux.ti.continued = 0;
   aux.ti.fBitfield = t->bitfield;
 
-  aux.ti.tq0 = (int) t->type_qualifiers[0];
-  aux.ti.tq1 = (int) t->type_qualifiers[1];
-  aux.ti.tq2 = (int) t->type_qualifiers[2];
-  aux.ti.tq3 = (int) t->type_qualifiers[3];
-  aux.ti.tq4 = (int) t->type_qualifiers[4];
-  aux.ti.tq5 = (int) t->type_qualifiers[5];
+  aux.ti.tq0 = t->type_qualifiers[0];
+  aux.ti.tq1 = t->type_qualifiers[1];
+  aux.ti.tq2 = t->type_qualifiers[2];
+  aux.ti.tq3 = t->type_qualifiers[3];
+  aux.ti.tq4 = t->type_qualifiers[4];
+  aux.ti.tq5 = t->type_qualifiers[5];
 
   /* For anything that adds additional information, we must not hash,
      so check here, and reset our state.  */
@@ -3909,8 +3909,8 @@ ecoff_build_symbols (const struct ecoff_debug_swap *backend,
                         we must offset it by the vma of the section,
                         just as BFD does, because BFD will not see
                         this value).  */
-                     if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
-                         && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
+                     if (sym_ptr->ecoff_sym.asym.st == st_Block
+                         && sym_ptr->ecoff_sym.asym.sc == sc_Text)
                        {
                          symbolS *begin_sym;
 
@@ -4021,8 +4021,8 @@ ecoff_build_symbols (const struct ecoff_debug_swap *backend,
                              sc = sc_Data;
                            }
 
-                         sym_ptr->ecoff_sym.asym.st = (int) st;
-                         sym_ptr->ecoff_sym.asym.sc = (int) sc;
+                         sym_ptr->ecoff_sym.asym.st = st;
+                         sym_ptr->ecoff_sym.asym.sc = sc;
                        }
 
                      /* This is just an external symbol if it is
@@ -4035,7 +4035,7 @@ ecoff_build_symbols (const struct ecoff_debug_swap *backend,
                           || S_IS_WEAK (as_sym)
                           || ! S_IS_DEFINED (as_sym))
                          && sym_ptr->proc_ptr == (proc_t *) NULL
-                         && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
+                         && sym_ptr->ecoff_sym.asym.st != st_Nil
                          && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
                        local = 0;
 
@@ -4070,7 +4070,7 @@ ecoff_build_symbols (const struct ecoff_debug_swap *backend,
                      begin_ptr = sym_ptr->begin_ptr;
                      know (begin_ptr->sym_index != -1);
                      sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
-                     if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
+                     if (sym_ptr->ecoff_sym.asym.sc != sc_Info)
                        sym_ptr->ecoff_sym.asym.iss =
                          begin_ptr->ecoff_sym.asym.iss;
 
@@ -4122,7 +4122,7 @@ ecoff_build_symbols (const struct ecoff_debug_swap *backend,
 #endif
                        }
                      else if (begin_type == st_Block
-                              && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
+                              && sym_ptr->ecoff_sym.asym.sc != sc_Info)
                        {
                          symbolS *begin_sym;
 
@@ -4545,8 +4545,8 @@ ecoff_setup_ext (void)
 
          lsym = symbol_get_obj (sym)->ecoff_symbol;
          lsym->ecoff_sym.asym.value = 0;
-         lsym->ecoff_sym.asym.st = (int) st_Nil;
-         lsym->ecoff_sym.asym.sc = (int) sc_Nil;
+         lsym->ecoff_sym.asym.st = st_Nil;
+         lsym->ecoff_sym.asym.sc = sc_Nil;
          lsym->ecoff_sym.asym.index = indexNil;
        }
 
@@ -4773,23 +4773,23 @@ allocate_scope (void)
 
 #ifndef MALLOC_CHECK
 
-  ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
+  ptr = alloc_counts[alloc_type_scope].free_list.f_scope;
   if (ptr != (scope_t *) NULL)
-    alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free;
+    alloc_counts[alloc_type_scope].free_list.f_scope = ptr->free;
   else
     {
-      int unallocated  = alloc_counts[(int) alloc_type_scope].unallocated;
-      page_type *cur_page      = alloc_counts[(int) alloc_type_scope].cur_page;
+      int unallocated = alloc_counts[alloc_type_scope].unallocated;
+      page_type *cur_page = alloc_counts[alloc_type_scope].cur_page;
 
       if (unallocated == 0)
        {
          unallocated = PAGE_SIZE / sizeof (scope_t);
-         alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page ();
-         alloc_counts[(int) alloc_type_scope].total_pages++;
+         alloc_counts[alloc_type_scope].cur_page = cur_page = allocate_page ();
+         alloc_counts[alloc_type_scope].total_pages++;
        }
 
       ptr = &cur_page->scope[--unallocated];
-      alloc_counts[(int) alloc_type_scope].unallocated = unallocated;
+      alloc_counts[alloc_type_scope].unallocated = unallocated;
     }
 
 #else
@@ -4798,7 +4798,7 @@ allocate_scope (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_scope].total_alloc++;
+  alloc_counts[alloc_type_scope].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }
@@ -4808,13 +4808,13 @@ allocate_scope (void)
 static void
 free_scope (scope_t *ptr)
 {
-  alloc_counts[(int) alloc_type_scope].total_free++;
+  alloc_counts[alloc_type_scope].total_free++;
 
 #ifndef MALLOC_CHECK
-  ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
-  alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
+  ptr->free = alloc_counts[alloc_type_scope].free_list.f_scope;
+  alloc_counts[alloc_type_scope].free_list.f_scope = ptr;
 #else
-  free ((void *) ptr);
+  free (ptr);
 #endif
 }
 \f
@@ -4827,18 +4827,18 @@ allocate_vlinks (void)
 
 #ifndef MALLOC_CHECK
 
-  int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
-  page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
+  int unallocated = alloc_counts[alloc_type_vlinks].unallocated;
+  page_type *cur_page = alloc_counts[alloc_type_vlinks].cur_page;
 
   if (unallocated == 0)
     {
       unallocated = PAGE_SIZE / sizeof (vlinks_t);
-      alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page ();
-      alloc_counts[(int) alloc_type_vlinks].total_pages++;
+      alloc_counts[alloc_type_vlinks].cur_page = cur_page = allocate_page ();
+      alloc_counts[alloc_type_vlinks].total_pages++;
     }
 
   ptr = &cur_page->vlinks[--unallocated];
-  alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated;
+  alloc_counts[alloc_type_vlinks].unallocated = unallocated;
 
 #else
 
@@ -4846,7 +4846,7 @@ allocate_vlinks (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_vlinks].total_alloc++;
+  alloc_counts[alloc_type_vlinks].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }
@@ -4860,18 +4860,18 @@ allocate_shash (void)
 
 #ifndef MALLOC_CHECK
 
-  int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
-  page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
+  int unallocated = alloc_counts[alloc_type_shash].unallocated;
+  page_type *cur_page = alloc_counts[alloc_type_shash].cur_page;
 
   if (unallocated == 0)
     {
       unallocated = PAGE_SIZE / sizeof (shash_t);
-      alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page ();
-      alloc_counts[(int) alloc_type_shash].total_pages++;
+      alloc_counts[alloc_type_shash].cur_page = cur_page = allocate_page ();
+      alloc_counts[alloc_type_shash].total_pages++;
     }
 
   ptr = &cur_page->shash[--unallocated];
-  alloc_counts[(int) alloc_type_shash].unallocated = unallocated;
+  alloc_counts[alloc_type_shash].unallocated = unallocated;
 
 #else
 
@@ -4879,7 +4879,7 @@ allocate_shash (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_shash].total_alloc++;
+  alloc_counts[alloc_type_shash].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }
@@ -4893,18 +4893,18 @@ allocate_thash (void)
 
 #ifndef MALLOC_CHECK
 
-  int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
-  page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
+  int unallocated = alloc_counts[alloc_type_thash].unallocated;
+  page_type *cur_page = alloc_counts[alloc_type_thash].cur_page;
 
   if (unallocated == 0)
     {
       unallocated = PAGE_SIZE / sizeof (thash_t);
-      alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page ();
-      alloc_counts[(int) alloc_type_thash].total_pages++;
+      alloc_counts[alloc_type_thash].cur_page = cur_page = allocate_page ();
+      alloc_counts[alloc_type_thash].total_pages++;
     }
 
   ptr = &cur_page->thash[--unallocated];
-  alloc_counts[(int) alloc_type_thash].unallocated = unallocated;
+  alloc_counts[alloc_type_thash].unallocated = unallocated;
 
 #else
 
@@ -4912,7 +4912,7 @@ allocate_thash (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_thash].total_alloc++;
+  alloc_counts[alloc_type_thash].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }
@@ -4926,23 +4926,23 @@ allocate_tag (void)
 
 #ifndef MALLOC_CHECK
 
-  ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
+  ptr = alloc_counts[alloc_type_tag].free_list.f_tag;
   if (ptr != (tag_t *) NULL)
-    alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free;
+    alloc_counts[alloc_type_tag].free_list.f_tag = ptr->free;
   else
     {
-      int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
-      page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
+      int unallocated = alloc_counts[alloc_type_tag].unallocated;
+      page_type *cur_page = alloc_counts[alloc_type_tag].cur_page;
 
       if (unallocated == 0)
        {
          unallocated = PAGE_SIZE / sizeof (tag_t);
-         alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page ();
-         alloc_counts[(int) alloc_type_tag].total_pages++;
+         alloc_counts[alloc_type_tag].cur_page = cur_page = allocate_page ();
+         alloc_counts[alloc_type_tag].total_pages++;
        }
 
       ptr = &cur_page->tag[--unallocated];
-      alloc_counts[(int) alloc_type_tag].unallocated = unallocated;
+      alloc_counts[alloc_type_tag].unallocated = unallocated;
     }
 
 #else
@@ -4951,7 +4951,7 @@ allocate_tag (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_tag].total_alloc++;
+  alloc_counts[alloc_type_tag].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }
@@ -4961,11 +4961,11 @@ allocate_tag (void)
 static void
 free_tag (tag_t *ptr)
 {
-  alloc_counts[(int) alloc_type_tag].total_free++;
+  alloc_counts[alloc_type_tag].total_free++;
 
 #ifndef MALLOC_CHECK
-  ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
-  alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr;
+  ptr->free = alloc_counts[alloc_type_tag].free_list.f_tag;
+  alloc_counts[alloc_type_tag].free_list.f_tag = ptr;
 #else
   free ((PTR_T) ptr);
 #endif
@@ -4980,18 +4980,18 @@ allocate_forward (void)
 
 #ifndef MALLOC_CHECK
 
-  int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
-  page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
+  int unallocated = alloc_counts[alloc_type_forward].unallocated;
+  page_type *cur_page = alloc_counts[alloc_type_forward].cur_page;
 
   if (unallocated == 0)
     {
       unallocated = PAGE_SIZE / sizeof (forward_t);
-      alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page ();
-      alloc_counts[(int) alloc_type_forward].total_pages++;
+      alloc_counts[alloc_type_forward].cur_page = cur_page = allocate_page ();
+      alloc_counts[alloc_type_forward].total_pages++;
     }
 
   ptr = &cur_page->forward[--unallocated];
-  alloc_counts[(int) alloc_type_forward].unallocated = unallocated;
+  alloc_counts[alloc_type_forward].unallocated = unallocated;
 
 #else
 
@@ -4999,7 +4999,7 @@ allocate_forward (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_forward].total_alloc++;
+  alloc_counts[alloc_type_forward].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }
@@ -5013,23 +5013,23 @@ allocate_thead (void)
 
 #ifndef MALLOC_CHECK
 
-  ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead;
-  if (ptr != (thead_t *) NULL)
-    alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free;
+  ptr = alloc_counts[alloc_type_thead].free_list.f_thead;
+  if (ptr != NULL)
+    alloc_counts[alloc_type_thead].free_list.f_thead = ptr->free;
   else
     {
-      int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
-      page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
+      int unallocated = alloc_counts[alloc_type_thead].unallocated;
+      page_type *cur_page = alloc_counts[alloc_type_thead].cur_page;
 
       if (unallocated == 0)
        {
          unallocated = PAGE_SIZE / sizeof (thead_t);
-         alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page ();
-         alloc_counts[(int) alloc_type_thead].total_pages++;
+         alloc_counts[alloc_type_thead].cur_page = cur_page = allocate_page ();
+         alloc_counts[alloc_type_thead].total_pages++;
        }
 
       ptr = &cur_page->thead[--unallocated];
-      alloc_counts[(int) alloc_type_thead].unallocated = unallocated;
+      alloc_counts[alloc_type_thead].unallocated = unallocated;
     }
 
 #else
@@ -5038,7 +5038,7 @@ allocate_thead (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_thead].total_alloc++;
+  alloc_counts[alloc_type_thead].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }
@@ -5048,11 +5048,11 @@ allocate_thead (void)
 static void
 free_thead (thead_t *ptr)
 {
-  alloc_counts[(int) alloc_type_thead].total_free++;
+  alloc_counts[alloc_type_thead].total_free++;
 
 #ifndef MALLOC_CHECK
-  ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead;
-  alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr;
+  ptr->free = (thead_t *) alloc_counts[alloc_type_thead].free_list.f_thead;
+  alloc_counts[alloc_type_thead].free_list.f_thead = ptr;
 #else
   free ((PTR_T) ptr);
 #endif
@@ -5065,18 +5065,18 @@ allocate_lineno_list (void)
 
 #ifndef MALLOC_CHECK
 
-  int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
-  page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
+  int unallocated = alloc_counts[alloc_type_lineno].unallocated;
+  page_type *cur_page = alloc_counts[alloc_type_lineno].cur_page;
 
   if (unallocated == 0)
     {
       unallocated = PAGE_SIZE / sizeof (lineno_list_t);
-      alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page ();
-      alloc_counts[(int) alloc_type_lineno].total_pages++;
+      alloc_counts[alloc_type_lineno].cur_page = cur_page = allocate_page ();
+      alloc_counts[alloc_type_lineno].total_pages++;
     }
 
   ptr = &cur_page->lineno[--unallocated];
-  alloc_counts[(int) alloc_type_lineno].unallocated = unallocated;
+  alloc_counts[alloc_type_lineno].unallocated = unallocated;
 
 #else
 
@@ -5084,7 +5084,7 @@ allocate_lineno_list (void)
 
 #endif
 
-  alloc_counts[(int) alloc_type_lineno].total_alloc++;
+  alloc_counts[alloc_type_lineno].total_alloc++;
   memset (ptr, 0, sizeof (*ptr));
   return ptr;
 }

diff --git a/gas/ehopt.c b/gas/ehopt.c
index ab976ba5e6d5628335472183bda4729190c6d41b..88528204a026e0064c8c0b8d20f006ee186102a9 100644 (file)
--- a/gas/ehopt.c
+++ b/gas/ehopt.c
@@ -334,7 +334,7 @@ check_eh_frame (expressionS *exp, unsigned int *pnbytes)
        /* Stop scanning if we don't see the expected FDE fields.  */
        d->state = state_error;
       else
-       d->state = (enum frame_state) (d->state + 1);
+       d->state++;
       break;
 
     case state_saw_pc_begin:

diff --git a/gas/expr.c b/gas/expr.c
index 78a247cde097d78579236e9495d540fb6758876b..c16e96b535ab0262d8a7765807518b080283632b 100644 (file)
--- a/gas/expr.c
+++ b/gas/expr.c
@@ -1880,7 +1880,7 @@ expr (int rankarg,                /* Larger # is higher rank.  */
   know (!is_whitespace (*input_line_pointer));
 
   op_left = operatorf (&op_chars);
-  while (op_left != O_illegal && op_rank[(int) op_left] > rank)
+  while (op_left != O_illegal && op_rank[op_left] > rank)
     {
       segT rightseg;
       bool is_unsigned;
@@ -1889,7 +1889,7 @@ expr (int rankarg,                /* Larger # is higher rank.  */
       input_line_pointer += op_chars;  /* -> after operator.  */
 
       right.X_md = 0;
-      rightseg = expr (op_rank[(int) op_left], &right, mode);
+      rightseg = expr (op_rank[op_left], &right, mode);
       if (right.X_op == O_absent)
        {
          as_warn (_("missing operand; zero assumed"));
@@ -1915,12 +1915,12 @@ expr (int rankarg,              /* Larger # is higher rank.  */
       op_right = operatorf (&op_chars);
 
       know (op_right == O_illegal || op_left == O_index
-           || op_rank[(int) op_right] <= op_rank[(int) op_left]);
-      know ((int) op_left >= (int) O_multiply);
+           || op_rank[op_right] <= op_rank[op_left]);
+      know (op_left >= O_multiply);
 #ifndef md_operator
-      know ((int) op_left <= (int) O_index);
+      know (op_left <= O_index);
 #else
-      know ((int) op_left < (int) O_max);
+      know (op_left < O_max);
 #endif
 
       /* input_line_pointer->after right-hand quantity.  */