* config/tc-xtensa.c: Warning fixes throughout.
authorBob Wilson <bob.wilson@acm.org>
Tue, 5 Apr 2005 20:55:40 +0000 (20:55 +0000)
committerBob Wilson <bob.wilson@acm.org>
Tue, 5 Apr 2005 20:55:40 +0000 (20:55 +0000)
(xtensa_fetch_width): Change to unsigned.
(assemble_nop, xtensa_find_unaligned_branch_targets,
xtensa_find_unaligned_loops, xg_assemble_vliw_tokens,
is_narrow_branch_guaranteed_in_range, xtensa_fix_close_loop_end_frags,
min_bytes_to_other_loop_end, unrelaxed_frag_min_size,
unrelaxed_frag_max_size, xtensa_fix_short_loop_frags,
count_insns_to_loop_end, unrelaxed_frag_min_insn_count,
get_text_align_max_fill_size, get_text_align_nop_count,
get_text_align_nth_nop_size, get_noop_aligned_address,
get_aligned_diff, convert_frag_align_next_opcode,
convert_frag_immed_finish_loop, xtensa_create_property_segments,
xtensa_create_xproperty_segments, xt_block_aligned_size): Clean up
types, avoiding size_t and using offsetT and addressT appropriately.
(get_text_align_power): Clean up types.  Avoid incorrect bound.
(get_text_align_fill_size): Clean up types.  Restructure for clarity.

gas/ChangeLog
gas/config/tc-xtensa.c

index 2fac0e8..3fffec7 100644 (file)
@@ -1,3 +1,22 @@
+2005-04-05  Bob Wilson  <bob.wilson@acm.org>
+
+       * config/tc-xtensa.c: Warning fixes throughout.
+       (xtensa_fetch_width): Change to unsigned.
+       (assemble_nop, xtensa_find_unaligned_branch_targets,
+       xtensa_find_unaligned_loops, xg_assemble_vliw_tokens,
+       is_narrow_branch_guaranteed_in_range, xtensa_fix_close_loop_end_frags,
+       min_bytes_to_other_loop_end, unrelaxed_frag_min_size,
+       unrelaxed_frag_max_size, xtensa_fix_short_loop_frags,
+       count_insns_to_loop_end, unrelaxed_frag_min_insn_count,
+       get_text_align_max_fill_size, get_text_align_nop_count,
+       get_text_align_nth_nop_size, get_noop_aligned_address,
+       get_aligned_diff, convert_frag_align_next_opcode,
+       convert_frag_immed_finish_loop, xtensa_create_property_segments,
+       xtensa_create_xproperty_segments, xt_block_aligned_size): Clean up
+       types, avoiding size_t and using offsetT and addressT appropriately.
+       (get_text_align_power): Clean up types.  Avoid incorrect bound.
+       (get_text_align_fill_size): Clean up types.  Restructure for clarity.
+
 2005-04-04  H.J. Lu  <hongjiu.lu@intel.com>
 
        * config/tc-ia64.c (start_unwind_section): Undo the change
index 907029f..cb71425 100644 (file)
@@ -76,7 +76,7 @@ bfd_boolean absolute_literals_supported = XSHAL_USE_ABSOLUTE_LITERALS;
 
 static vliw_insn cur_vinsn;
 
-size_t xtensa_fetch_width = XCHAL_INST_FETCH_WIDTH;
+unsigned xtensa_fetch_width = XCHAL_INST_FETCH_WIDTH;
 
 static enum debug_info_type xt_saved_debug_type = DEBUG_NONE;
 
@@ -446,8 +446,8 @@ static int total_frag_text_expansion (fragS *);
 
 /* Alignment Functions.  */
 
-static size_t get_text_align_power (int);
-static addressT get_text_align_max_fill_size (int, bfd_boolean, bfd_boolean);
+static int get_text_align_power (unsigned);
+static int get_text_align_max_fill_size (int, bfd_boolean, bfd_boolean);
 
 /* Helpers for xtensa_relax_frag().  */
 
@@ -2524,7 +2524,7 @@ get_opcode_from_buf (const char *buf, int slot)
       slotbuf = xtensa_insnbuf_alloc (isa);
     }
 
-  xtensa_insnbuf_from_chars (isa, insnbuf, buf, 0);
+  xtensa_insnbuf_from_chars (isa, insnbuf, (const unsigned char *) buf, 0);
   fmt = xtensa_format_decode (isa, insnbuf);
   if (fmt == XTENSA_UNDEFINED)
     return XTENSA_UNDEFINED;
@@ -4291,7 +4291,8 @@ xg_emit_insn_to_buf (TInsn *tinsn,
        ok = FALSE;
     }
   fragP->tc_frag_data.is_insn = TRUE;
-  xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, buf, 0);
+  xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf,
+                          (unsigned char *) buf, 0);
   return ok;
 }
 
@@ -4468,7 +4469,8 @@ frag_format_size (const fragS *fragP)
   if (fragP == NULL)
     return XTENSA_UNDEFINED;
 
-  xtensa_insnbuf_from_chars (isa, insnbuf, fragP->fr_literal, 0);
+  xtensa_insnbuf_from_chars (isa, insnbuf,
+                            (unsigned char *) fragP->fr_literal, 0);
 
   fmt = xtensa_format_decode (isa, insnbuf);
   if (fmt == XTENSA_UNDEFINED)
@@ -4706,7 +4708,7 @@ build_nop (TInsn *tinsn, int size)
    allocated "buf" with at least "size" bytes.  */
 
 static void
-assemble_nop (size_t size, char *buf)
+assemble_nop (int size, char *buf)
 {
   static xtensa_insnbuf insnbuf = NULL;
   TInsn tinsn;
@@ -4717,7 +4719,8 @@ assemble_nop (size_t size, char *buf)
     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
 
   tinsn_to_insnbuf (&tinsn, insnbuf);
-  xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf, buf, 0);
+  xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf,
+                          (unsigned char *) buf, 0);
 }
 
 
@@ -4866,14 +4869,15 @@ xtensa_find_unaligned_branch_targets (bfd *abfd ATTRIBUTE_UNUSED,
          if (frag->tc_frag_data.is_branch_target)
            {
              int op_size;
-             int frag_addr;
+             addressT frag_addr;
              xtensa_format fmt;
 
-             xtensa_insnbuf_from_chars (isa, insnbuf, frag->fr_literal, 0);
+             xtensa_insnbuf_from_chars
+               (isa, insnbuf, (unsigned char *) frag->fr_literal, 0);
              fmt = xtensa_format_decode (isa, insnbuf);
              op_size = xtensa_format_length (isa, fmt);
              frag_addr = frag->fr_address % xtensa_fetch_width;
-             if (frag_addr + op_size > (int) xtensa_fetch_width)
+             if (frag_addr + op_size > xtensa_fetch_width)
                as_warn_where (frag->fr_file, frag->fr_line,
                               _("unaligned branch target: %d bytes at 0x%lx"),
                               op_size, frag->fr_address);
@@ -4903,15 +4907,16 @@ xtensa_find_unaligned_loops (bfd *abfd ATTRIBUTE_UNUSED,
          if (frag->tc_frag_data.is_first_loop_insn)
            {
              int op_size;
-             int frag_addr;
+             addressT frag_addr;
              xtensa_format fmt;
 
-             xtensa_insnbuf_from_chars (isa, insnbuf, frag->fr_literal, 0);
+             xtensa_insnbuf_from_chars
+               (isa, insnbuf, (unsigned char *) frag->fr_literal, 0);
              fmt = xtensa_format_decode (isa, insnbuf);
              op_size = xtensa_format_length (isa, fmt);
              frag_addr = frag->fr_address % xtensa_fetch_width;
 
-             if (frag_addr + op_size > (signed) xtensa_fetch_width)
+             if (frag_addr + op_size > xtensa_fetch_width)
                as_warn_where (frag->fr_file, frag->fr_line,
                               _("unaligned loop: %d bytes at 0x%lx"),
                               op_size, frag->fr_address);
@@ -4945,7 +4950,7 @@ xg_apply_fix_value (fixS *fixP, valueT val)
       slotbuf = xtensa_insnbuf_alloc (isa);
     }
 
-  xtensa_insnbuf_from_chars (isa, insnbuf, fixpos, 0);
+  xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) fixpos, 0);
   fmt = xtensa_format_decode (isa, insnbuf);
   if (fmt == XTENSA_UNDEFINED)
     as_fatal (_("undecodable fix"));
@@ -4965,7 +4970,7 @@ xg_apply_fix_value (fixS *fixP, valueT val)
                              fixP->fx_file, fixP->fx_line);
 
   xtensa_format_set_slot (isa, fmt, slot, insnbuf, slotbuf);
-  xtensa_insnbuf_to_chars (isa, insnbuf, fixpos, 0);
+  xtensa_insnbuf_to_chars (isa, insnbuf, (unsigned char *) fixpos, 0);
 
   return 1;
 }
@@ -5441,7 +5446,7 @@ md_pcrel_from (fixS *fixP)
     }
 
   insn_p = &fixP->fx_frag->fr_literal[fixP->fx_where];
-  xtensa_insnbuf_from_chars (isa, insnbuf, insn_p, 0);
+  xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) insn_p, 0);
   fmt = xtensa_format_decode (isa, insnbuf);
 
   if (fmt == XTENSA_UNDEFINED)
@@ -6006,7 +6011,7 @@ finish_vinsn (vliw_insn *vinsn)
   IStack slotstack;
   int i;
   char *file_name;
-  int line;
+  unsigned line;
 
   if (find_vinsn_conflicts (vinsn))
     {
@@ -6791,7 +6796,7 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
   /* None of these opcodes are bundle-able.  */
   if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode) == 1)
     {
-      size_t max_fill;
+      int max_fill;
       
       xtensa_set_frag_assembly_state (frag_now);
       frag_now->tc_frag_data.is_insn = TRUE;
@@ -6841,7 +6846,7 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
   /* vinsn_to_insnbuf will produce the error.  */
   if (vinsn->format != XTENSA_UNDEFINED)
     {
-      f = (char *) frag_more (insn_size + extra_space);
+      f = frag_more (insn_size + extra_space);
       xtensa_set_frag_assembly_state (frag_now);
       frag_now->tc_frag_data.is_insn = TRUE;
     }
@@ -6850,7 +6855,7 @@ xg_assemble_vliw_tokens (vliw_insn *vinsn)
   if (vinsn->format == XTENSA_UNDEFINED)
     return;
 
-  xtensa_insnbuf_to_chars (isa, vinsn->insnbuf, f, 0);
+  xtensa_insnbuf_to_chars (isa, vinsn->insnbuf, (unsigned char *) f, 0);
   
   xtensa_dwarf2_emit_insn (insn_size - extra_space, &best_loc);
 
@@ -7148,7 +7153,7 @@ xtensa_mark_narrow_branches (void)
    maximum offset is (4 - 2) + 63 = 65.  */
 #define MAX_IMMED6 65
 
-static size_t unrelaxed_frag_max_size (fragS *);
+static offsetT unrelaxed_frag_max_size (fragS *);
 
 static bfd_boolean
 is_narrow_branch_guaranteed_in_range (fragS *fragP, TInsn *tinsn)
@@ -7156,7 +7161,7 @@ is_narrow_branch_guaranteed_in_range (fragS *fragP, TInsn *tinsn)
   const expressionS *expr = &tinsn->tok[1];
   symbolS *symbolP = expr->X_add_symbol;
   fragS *target_frag = symbol_get_frag (symbolP);
-  size_t max_distance = expr->X_add_number;
+  offsetT max_distance = expr->X_add_number;
   max_distance += (S_GET_VALUE (symbolP) - target_frag->fr_address);
   if (is_branch_jmp_to_next (tinsn, fragP))
     return FALSE;
@@ -7270,7 +7275,8 @@ next_instrs_are_b_retw (fragS *fragP)
     return FALSE;
 
   /* Check for the conditional branch.  */
-  xtensa_insnbuf_from_chars (isa, insnbuf, &next_fragP->fr_literal[offset], 0);
+  xtensa_insnbuf_from_chars
+    (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
   fmt = xtensa_format_decode (isa, insnbuf);
   if (fmt == XTENSA_UNDEFINED)
     return FALSE;
@@ -7298,7 +7304,8 @@ next_instrs_are_b_retw (fragS *fragP)
     return FALSE;
 
   /* Check for the retw/retw.n.  */
-  xtensa_insnbuf_from_chars (isa, insnbuf, &next_fragP->fr_literal[offset], 0);
+  xtensa_insnbuf_from_chars
+    (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
   fmt = xtensa_format_decode (isa, insnbuf);
 
   /* Because RETW[.N] is not bundleable, a VLIW bundle here means that we
@@ -7385,7 +7392,8 @@ next_instr_is_loop_end (fragS *fragP)
    make it at least 12 bytes away.  In any case close it off with a
    .fill 0.  */
 
-static size_t min_bytes_to_other_loop_end (fragS *, fragS *, offsetT, size_t);
+static offsetT min_bytes_to_other_loop_end
+  (fragS *, fragS *, offsetT, offsetT);
 
 static void
 xtensa_fix_close_loop_end_frags (void)
@@ -7430,8 +7438,8 @@ xtensa_fix_close_loop_end_frags (void)
              && fragP->fr_type == rs_machine_dependent
              && fragP->fr_subtype == RELAX_ADD_NOP_IF_CLOSE_LOOP_END)
            {
-             size_t min_bytes;
-             size_t bytes_added = 0;
+             offsetT min_bytes;
+             int bytes_added = 0;
 
 #define REQUIRED_LOOP_DIVIDING_BYTES 12
              /* Max out at 12.  */
@@ -7473,15 +7481,15 @@ xtensa_fix_close_loop_end_frags (void)
 }
 
 
-static size_t unrelaxed_frag_min_size (fragS *);
+static offsetT unrelaxed_frag_min_size (fragS *);
 
-static size_t
+static offsetT
 min_bytes_to_other_loop_end (fragS *fragP,
                             fragS *current_target,
                             offsetT current_offset,
-                            size_t max_size)
+                            offsetT max_size)
 {
-  size_t offset = 0;
+  offsetT offset = 0;
   fragS *current_fragP;
 
   for (current_fragP = fragP;
@@ -7501,12 +7509,12 @@ min_bytes_to_other_loop_end (fragS *fragP,
 }
 
 
-static size_t
+static offsetT
 unrelaxed_frag_min_size (fragS *fragP)
 {
-  size_t size = fragP->fr_fix;
+  offsetT size = fragP->fr_fix;
 
-  /* add fill size */
+  /* Add fill size.  */
   if (fragP->fr_type == rs_fill)
     size += fragP->fr_offset;
 
@@ -7514,10 +7522,10 @@ unrelaxed_frag_min_size (fragS *fragP)
 }
 
 
-static size_t
+static offsetT
 unrelaxed_frag_max_size (fragS *fragP)
 {
-  size_t size = fragP->fr_fix;
+  offsetT size = fragP->fr_fix;
   switch (fragP->fr_type)
     {
     case 0:
@@ -7567,7 +7575,7 @@ unrelaxed_frag_max_size (fragS *fragP)
    then convert this frag (and maybe the next one) to generate a NOP.
    In any case close it off with a .fill 0.  */
 
-static size_t count_insns_to_loop_end (fragS *, bfd_boolean, size_t);
+static int count_insns_to_loop_end (fragS *, bfd_boolean, int);
 static bfd_boolean branch_before_loop_end (fragS *);
 
 static void
@@ -7615,9 +7623,7 @@ xtensa_fix_short_loop_frags (void)
          if (fragP->fr_type == rs_machine_dependent
              && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP)
            {
-             size_t insn_count =
-               count_insns_to_loop_end (fragP->fr_next, TRUE, 3);
-             if (insn_count < 3
+             if (count_insns_to_loop_end (fragP->fr_next, TRUE, 3) < 3
                  && (branch_before_loop_end (fragP->fr_next)
                      || (workaround_all_short_loops
                          && current_opcode != XTENSA_UNDEFINED
@@ -7635,15 +7641,15 @@ xtensa_fix_short_loop_frags (void)
 }
 
 
-static size_t unrelaxed_frag_min_insn_count (fragS *);
+static int unrelaxed_frag_min_insn_count (fragS *);
 
-static size_t
+static int
 count_insns_to_loop_end (fragS *base_fragP,
                         bfd_boolean count_relax_add,
-                        size_t max_count)
+                        int max_count)
 {
   fragS *fragP = NULL;
-  size_t insn_count = 0;
+  int insn_count = 0;
 
   fragP = base_fragP;
 
@@ -7671,12 +7677,12 @@ count_insns_to_loop_end (fragS *base_fragP,
 }
 
 
-static size_t
+static int
 unrelaxed_frag_min_insn_count (fragS *fragP)
 {
   xtensa_isa isa = xtensa_default_isa;
   static xtensa_insnbuf insnbuf = NULL;
-  size_t insn_count = 0;
+  int insn_count = 0;
   int offset = 0;
 
   if (!fragP->tc_frag_data.is_insn)
@@ -7690,7 +7696,8 @@ unrelaxed_frag_min_insn_count (fragS *fragP)
     {
       xtensa_format fmt;
 
-      xtensa_insnbuf_from_chars (isa, insnbuf, fragP->fr_literal + offset, 0);
+      xtensa_insnbuf_from_chars
+       (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
       fmt = xtensa_format_decode (isa, insnbuf);
 
       if (fmt == XTENSA_UNDEFINED)
@@ -7743,7 +7750,8 @@ unrelaxed_frag_has_b_j (fragS *fragP)
       xtensa_format fmt;
       int slot;
 
-      xtensa_insnbuf_from_chars (isa, insnbuf, fragP->fr_literal + offset, 0);
+      xtensa_insnbuf_from_chars
+       (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
       fmt = xtensa_format_decode (isa, insnbuf);
       if (fmt == XTENSA_UNDEFINED)
        return FALSE;
@@ -7771,7 +7779,7 @@ static void
 xtensa_sanity_check (void)
 {
   char *file_name;
-  int line;
+  unsigned line;
 
   frchainS *frchP;
 
@@ -7916,21 +7924,23 @@ is_local_forward_loop (const TInsn *insn, fragS *fragP)
 \f
 /* Alignment Functions.  */
 
-static size_t
-get_text_align_power (int target_size)
+static int
+get_text_align_power (unsigned target_size)
 {
-  size_t i = 0;
-  for (i = 0; i < sizeof (size_t); i++)
+  int i = 0;
+  unsigned power = 1;
+
+  assert (target_size <= INT_MAX);
+  while (target_size > power)
     {
-      if (target_size <= (1 << i))
-       return i;
+      power <<= 1;
+      i += 1;
     }
-  assert (0);
-  return 0;
+  return i;
 }
 
 
-static addressT
+static int
 get_text_align_max_fill_size (int align_pow,
                              bfd_boolean use_nops,
                              bfd_boolean use_no_density)
@@ -7944,106 +7954,52 @@ get_text_align_max_fill_size (int align_pow,
 }
 
 
-/* get_text_align_fill_size ()
-
-   Desired alignments:
-      give the address
-      target_size = size of next instruction
-      align_pow = get_text_align_power (target_size).
-      use_nops = 0
-      use_no_density = 0;
-   Loop alignments:
-      address = current address + loop instruction size;
-      target_size = 3 (for 2 or 3 byte target)
-                  = 4 (for 4 byte target)
-                  = 8 (for 8 byte target)
-      align_pow = get_text_align_power (target_size);
-      use_nops = 1
-      use_no_density = set appropriately
-   Text alignments:
-      address = current address + loop instruction size;
-      target_size = 0
-      align_pow = get_text_align_power (target_size);
-      use_nops = 0
-      use_no_density = 0.  */
+/* Calculate the minimum bytes of fill needed at "address" to align a
+   target instruction of size "target_size" so that it does not cross a
+   power-of-two boundary specified by "align_pow".  If "use_nops" is FALSE,
+   the fill can be an arbitrary number of bytes.  Otherwise, the space must
+   be filled by NOP instructions.  */
 
-static addressT
+static int
 get_text_align_fill_size (addressT address,
                          int align_pow,
                          int target_size,
                          bfd_boolean use_nops,
                          bfd_boolean use_no_density)
 {
-  /* Input arguments:
-
-     align_pow: log2 (required alignment).
+  addressT alignment, fill, fill_limit, fill_step;
+  bfd_boolean skip_one = FALSE;
 
-     target_size: alignment must allow the new_address and
-     new_address+target_size-1.
-
-     use_nops: if TRUE, then we can only use 2- or 3-byte nops.
-
-     use_no_density: if use_nops and use_no_density, we can only use
-     3-byte nops.
-
-     Usually the align_pow is the power of 2 that is greater than 
-     or equal to the target_size.  This handles the 2-byte, 3-byte 
-     and 8-byte instructions.
-
-     Two cases:
-
-     (1) aligning an instruction properly, but without using NOPs.
-       E.G.: a 3-byte instruction can go on any address where address mod 4
-       is zero or one.  The aligner uses this case to find the optimal
-       number of fill bytes for relax_frag_for_align.
-
-     (2) aligning an instruction properly, but where we might need to use
-       extra NOPs.  E.G.: when the aligner couldn't find enough widenings
-       or similar to get the optimal location.  */
-
-  size_t alignment = (1 << align_pow);
-
-  assert (target_size != 0);
+  alignment = (1 << align_pow);
+  assert (target_size > 0 && alignment >= (addressT) target_size);
   
   if (!use_nops)
     {
-      unsigned fill_bytes;
-      for (fill_bytes = 0; fill_bytes < alignment; fill_bytes++)
-       {
-         addressT end_address = address + target_size - 1 + fill_bytes;
-         addressT start_address = address + fill_bytes;
-         if ((end_address >> align_pow) == (start_address >> align_pow))
-           return fill_bytes;
-       }
-      assert (0);
+      fill_limit = alignment;
+      fill_step = 1;
     }
-
-  /* This is the slightly harder case.  */
-  assert ((int) alignment >= target_size);
-  assert (target_size > 0);
-  if (!use_no_density)
+  else if (!use_no_density)
     {
-      size_t i;
-      for (i = 0; i < alignment * 2; i++)
-       {
-         if (i == 1)
-           continue;
-         if ((address + i) >> align_pow
-             == (address + i + target_size - 1) >> align_pow)
-           return i;
-       }
+      /* Combine 2- and 3-byte NOPs to fill anything larger than one.  */
+      fill_limit = alignment * 2;
+      fill_step = 1;
+      skip_one = TRUE;
     }
   else
     {
-      size_t i;
+      /* Fill with 3-byte NOPs -- can only fill multiples of 3.  */
+      fill_limit = alignment * 3;
+      fill_step = 3;
+    }
 
-      /* Can only fill multiples of 3.  */
-      for (i = 0; i <= alignment * 3; i += 3)
-       {
-         if ((address + i) >> align_pow
-             == (address + i + target_size - 1) >> align_pow)
-           return i;
-       }
+  /* Try all fill sizes until finding one that works.  */
+  for (fill = 0; fill < fill_limit; fill += fill_step)
+    {
+      if (skip_one && fill == 1)
+       continue;
+      if ((address + fill) >> align_pow
+         == (address + fill + target_size - 1) >> align_pow)
+       return fill;
     }
   assert (0);
   return 0;
@@ -8052,10 +8008,11 @@ get_text_align_fill_size (addressT address,
 
 /* This will assert if it is not possible.  */
 
-static size_t
-get_text_align_nop_count (size_t fill_size, bfd_boolean use_no_density)
+static int
+get_text_align_nop_count (offsetT fill_size, bfd_boolean use_no_density)
 {
-  size_t count = 0;
+  int count = 0;
+
   if (use_no_density)
     {
       assert (fill_size % 3 == 0);
@@ -8066,7 +8023,7 @@ get_text_align_nop_count (size_t fill_size, bfd_boolean use_no_density)
 
   while (fill_size > 1)
     {
-      size_t insn_size = 3;
+      int insn_size = 3;
       if (fill_size == 2 || fill_size == 4)
        insn_size = 2;
       fill_size -= insn_size;
@@ -8077,21 +8034,21 @@ get_text_align_nop_count (size_t fill_size, bfd_boolean use_no_density)
 }
 
 
-static size_t
-get_text_align_nth_nop_size (size_t fill_size,
-                            size_t n,
+static int
+get_text_align_nth_nop_size (offsetT fill_size,
+                            int n,
                             bfd_boolean use_no_density)
 {
-  size_t count = 0;
-
-  assert (get_text_align_nop_count (fill_size, use_no_density) > n);
+  int count = 0;
 
   if (use_no_density)
     return 3;
 
+  assert (fill_size != 1);     /* Bad argument.  */
+
   while (fill_size > 1)
     {
-      size_t insn_size = 3;
+      int insn_size = 3;
       if (fill_size == 2 || fill_size == 4)
        insn_size = 2;
       fill_size -= insn_size;
@@ -8124,11 +8081,11 @@ get_noop_aligned_address (fragS *fragP, addressT address)
      Note again here that LOOP instructions are not bundleable,
      and this relaxation only applies to LOOP opcodes.  */
   
-  size_t fill_size = 0;
+  int fill_size = 0;
   int first_insn_size;
   int loop_insn_size;
   addressT pre_opcode_bytes;
-  size_t alignment;
+  int align_power;
   fragS *first_insn;
   xtensa_opcode opcode;
   bfd_boolean is_loop;
@@ -8162,15 +8119,12 @@ get_noop_aligned_address (fragS *fragP, addressT address)
     first_insn_size = 3;       /* ISA specifies this */
 
   /* If it was 8, then we'll need a larger alignment for the section.  */
-  alignment = get_text_align_power (first_insn_size);
-
-  /* Is now_seg valid?  */
-  record_alignment (now_seg, alignment);
+  align_power = get_text_align_power (first_insn_size);
+  record_alignment (now_seg, align_power);
   
   fill_size = get_text_align_fill_size
-    (address + pre_opcode_bytes,
-     get_text_align_power (first_insn_size),
-     first_insn_size, TRUE, fragP->tc_frag_data.is_no_density);
+    (address + pre_opcode_bytes, align_power, first_insn_size, TRUE,
+     fragP->tc_frag_data.is_no_density);
 
   return address + fill_size;
 }
@@ -8193,15 +8147,15 @@ get_noop_aligned_address (fragS *fragP, addressT address)
               >=5 : 3-byte instruction + fn (n-3)
    widening - widen previous instructions.  */
 
-static addressT
-get_aligned_diff (fragS *fragP, addressT address, addressT *max_diff)
+static offsetT
+get_aligned_diff (fragS *fragP, addressT address, offsetT *max_diff)
 {
   addressT target_address, loop_insn_offset;
   int target_size;
   xtensa_opcode loop_opcode;
   bfd_boolean is_loop;
-  int text_align_power;
-  addressT opt_diff;
+  int align_power;
+  offsetT opt_diff;
 
   assert (fragP->fr_type == rs_machine_dependent);
   switch (fragP->fr_subtype)
@@ -8210,12 +8164,13 @@ get_aligned_diff (fragS *fragP, addressT address, addressT *max_diff)
       target_size = next_frag_format_size (fragP);
       if (target_size == XTENSA_UNDEFINED)
        target_size = 3;
-      text_align_power = get_text_align_power (xtensa_fetch_width);
-      opt_diff = get_text_align_fill_size (address, text_align_power,
+      align_power = get_text_align_power (xtensa_fetch_width);
+      opt_diff = get_text_align_fill_size (address, align_power,
                                           target_size, FALSE, FALSE);
 
-      *max_diff = opt_diff + xtensa_fetch_width
-       - (target_size + ((address + opt_diff) % xtensa_fetch_width));
+      *max_diff = (opt_diff + xtensa_fetch_width
+                  - (target_size + ((address + opt_diff)
+                                    % xtensa_fetch_width)));
       assert (*max_diff >= opt_diff);
       return opt_diff;
 
@@ -8240,8 +8195,8 @@ get_aligned_diff (fragS *fragP, addressT address, addressT *max_diff)
         will call get_noop_aligned_address.  */
       target_address =
        address + loop_insn_offset + xg_get_single_size (loop_opcode);
-      text_align_power = get_text_align_power (target_size),
-      opt_diff = get_text_align_fill_size (target_address, text_align_power,
+      align_power = get_text_align_power (target_size),
+      opt_diff = get_text_align_fill_size (target_address, align_power,
                                           target_size, FALSE, FALSE);
 
       *max_diff = xtensa_fetch_width
@@ -8276,7 +8231,8 @@ xtensa_relax_frag (fragS *fragP, long stretch, int *stretched_p)
   int unreported = fragP->tc_frag_data.unreported_expansion;
   long new_stretch = 0;
   char *file_name;
-  int line, lit_size;
+  unsigned line;
+  int lit_size;
   static xtensa_insnbuf vbuf = NULL;
   int slot, num_slots;
   xtensa_format fmt;
@@ -8327,7 +8283,8 @@ xtensa_relax_frag (fragS *fragP, long stretch, int *stretched_p)
       if (vbuf == NULL)
        vbuf = xtensa_insnbuf_alloc (isa);
 
-      xtensa_insnbuf_from_chars (isa, vbuf, fragP->fr_opcode, 0);
+      xtensa_insnbuf_from_chars
+       (isa, vbuf, (unsigned char *) fragP->fr_opcode, 0);
       fmt = xtensa_format_decode (isa, vbuf);
       num_slots = xtensa_format_num_slots (isa, fmt);
 
@@ -8619,14 +8576,14 @@ future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
          /* We only use these to determine if we can exit early
             because there will be plenty of ways to align future 
             align frags.  */
-         unsigned int glob_widens = 0;
+         int glob_widens = 0;
          int dnn = 0;
          int dw = 0;
          bfd_boolean glob_pad = 0;
          address = find_address_of_next_align_frag
            (&fragP, &glob_widens, &dnn, &dw, &glob_pad);
          /* If there is a padable portion, then skip.  */
-         if (glob_pad || (glob_widens >= xtensa_fetch_width))
+         if (glob_pad || glob_widens >= (int) xtensa_fetch_width)
            break;
 
          if (address) 
@@ -9022,7 +8979,7 @@ md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec, fragS *fragp)
   int num_slots;
   xtensa_format fmt;
   char *file_name;
-  int line;
+  unsigned line;
 
   as_where (&file_name, &line);
   new_logical_line (fragp->fr_file, fragp->fr_line);
@@ -9046,7 +9003,8 @@ md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec, fragS *fragp)
       if (vbuf == NULL)
        vbuf = xtensa_insnbuf_alloc (isa);
 
-      xtensa_insnbuf_from_chars (isa, vbuf, fragp->fr_opcode, 0);
+      xtensa_insnbuf_from_chars
+       (isa, vbuf, (unsigned char *) fragp->fr_opcode, 0);
       fmt = xtensa_format_decode (isa, vbuf);
       num_slots = xtensa_format_num_slots (isa, fmt);
 
@@ -9131,11 +9089,10 @@ static void
 convert_frag_align_next_opcode (fragS *fragp)
 {
   char *nop_buf;               /* Location for Writing.  */
-  size_t i;
-
   bfd_boolean use_no_density = fragp->tc_frag_data.is_no_density;
   addressT aligned_address;
-  size_t fill_size, nop_count;
+  offsetT fill_size;
+  int nop, nop_count;
 
   aligned_address = get_noop_aligned_address (fragp, fragp->fr_address +
                                              fragp->fr_fix);
@@ -9143,10 +9100,10 @@ convert_frag_align_next_opcode (fragS *fragp)
   nop_count = get_text_align_nop_count (fill_size, use_no_density);
   nop_buf = fragp->fr_literal + fragp->fr_fix;
 
-  for (i = 0; i < nop_count; i++)
+  for (nop = 0; nop < nop_count; nop++)
     {
-      size_t nop_size;
-      nop_size = get_text_align_nth_nop_size (fill_size, i, use_no_density);
+      int nop_size;
+      nop_size = get_text_align_nth_nop_size (fill_size, nop, use_no_density);
 
       assemble_nop (nop_size, nop_buf);
       nop_buf += nop_size;
@@ -9299,7 +9256,8 @@ convert_frag_immed (segT segP,
          fragP->fr_fix += fragP->tc_frag_data.text_expansion[0];
        }
       vinsn_to_insnbuf (&orig_vinsn, fr_opcode, frag_now, FALSE);
-      xtensa_insnbuf_to_chars (isa, orig_vinsn.insnbuf, fr_opcode, 0);
+      xtensa_insnbuf_to_chars
+       (isa, orig_vinsn.insnbuf, (unsigned char *) fr_opcode, 0);
       fragP->fr_var = 0;
     }
   else
@@ -9444,7 +9402,7 @@ convert_frag_immed (segT segP,
                    }
                  vinsn_to_insnbuf (&orig_vinsn, immed_instr, fragP, TRUE);
                  xtensa_insnbuf_to_chars (isa, orig_vinsn.insnbuf,
-                                          immed_instr, 0);
+                                          (unsigned char *) immed_instr, 0);
                  fragP->tc_frag_data.is_insn = TRUE;
                  size = xtensa_format_length (isa, fmt);
                  if (!opcode_fits_format_slot (tinsn->opcode, fmt, slot))
@@ -9573,7 +9531,7 @@ convert_frag_immed_finish_loop (segT segP, fragS *fragP, TInsn *tinsn)
   addressT addi_offset = 9;
   addressT addmi_offset = 12;
   fragS *next_fragP;
-  size_t target_count;
+  int target_count;
 
   if (!insnbuf)
     insnbuf = xtensa_insnbuf_alloc (isa);
@@ -9638,11 +9596,13 @@ convert_frag_immed_finish_loop (segT segP, fragS *fragP, TInsn *tinsn)
   tinsn_to_insnbuf (&addi_insn, insnbuf);
 
   fragP->tc_frag_data.is_insn = TRUE;
-  xtensa_insnbuf_to_chars (isa, insnbuf, fragP->fr_opcode + addi_offset, 0);
+  xtensa_insnbuf_to_chars
+    (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addi_offset, 0);
 
   set_expr_const (&addmi_insn.tok[2], loop_length_hi);
   tinsn_to_insnbuf (&addmi_insn, insnbuf);
-  xtensa_insnbuf_to_chars (isa, insnbuf, fragP->fr_opcode + addmi_offset, 0);
+  xtensa_insnbuf_to_chars
+    (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addmi_offset, 0);
 
   /* Walk through all of the frags from here to the loop end
      and mark them as no_transform to keep them from being modified
@@ -10313,7 +10273,7 @@ xtensa_create_property_segments (frag_predicate property_function,
          xtensa_block_info *cur_block;
          /* This is a section with some data.  */
          int num_recs = 0;
-         size_t rec_size;
+         bfd_size_type rec_size;
 
          for (cur_block = block; cur_block; cur_block = cur_block->next)
            num_recs++;
@@ -10330,7 +10290,7 @@ xtensa_create_property_segments (frag_predicate property_function,
            {
              /* Allocate a fragment and leak it.  */
              fragS *fragP;
-             size_t frag_size;
+             bfd_size_type frag_size;
              fixS *fixes;
              frchainS *frchainP;
              int i;
@@ -10445,7 +10405,7 @@ xtensa_create_xproperty_segments (frag_flags_fn flag_fn,
          xtensa_block_info *cur_block;
          /* This is a section with some data.  */
          int num_recs = 0;
-         size_t rec_size;
+         bfd_size_type rec_size;
 
          for (cur_block = block; cur_block; cur_block = cur_block->next)
            num_recs++;
@@ -10463,7 +10423,7 @@ xtensa_create_xproperty_segments (frag_flags_fn flag_fn,
            {
              /* Allocate a fragment and (unfortunately) leak it.  */
              fragS *fragP;
-             size_t frag_size;
+             bfd_size_type frag_size;
              fixS *fixes;
              frchainS *frchainP;
              int i;
@@ -10827,7 +10787,7 @@ static bfd_vma
 xt_block_aligned_size (const xtensa_block_info *xt_block)
 {
   bfd_vma end_addr;
-  size_t align_bits;
+  unsigned align_bits;
 
   if (!xt_block->flags.is_align)
     return xt_block->size;
@@ -11262,7 +11222,7 @@ tinsn_to_insnbuf (TInsn *tinsn, xtensa_insnbuf insnbuf)
   int i;
   uint32 opnd_value;
   char *file_name;
-  int line;
+  unsigned line;
 
   if (!slotbuf)
     slotbuf = xtensa_insnbuf_alloc (isa);
@@ -11355,7 +11315,8 @@ tinsn_to_slotbuf (xtensa_format fmt,
   for (i = 0; i < noperands; i++)
     {
       expressionS *expr = &tinsn->tok[i];
-      int rc, line;
+      int rc;
+      unsigned line;
       char *file_name;
       uint32 opnd_value;
 
@@ -11719,7 +11680,7 @@ vinsn_from_chars (vliw_insn *vinsn, char *f)
       slotbuf = xtensa_insnbuf_alloc (isa);
     }
 
-  xtensa_insnbuf_from_chars (isa, insnbuf, f, 0);
+  xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) f, 0);
   fmt = xtensa_format_decode (isa, insnbuf);
   if (fmt == XTENSA_UNDEFINED)
     as_fatal (_("cannot decode instruction format"));