* cgen.c: Whitespace fixes.

	(weak_operand_overflow_check): Formatting fix.

diff --git a/gas/ChangeLog b/gas/ChangeLog
index 9a5b9e223cfd85dbd91b6a9db4995e8817de836f..f06125009a964b7753998f0de36a746ffc49ee6e 100644 (file)
--- a/gas/ChangeLog
+++ b/gas/ChangeLog
@@ -1,3 +1,8 @@
+2010-02-25  Doug Evans  <dje@sebabeach.org>
+
+       * cgen.c: Whitespace fixes.
+       (weak_operand_overflow_check): Formatting fix.
+
 2010-02-25  H.J. Lu  <hongjiu.lu@intel.com>
 
        * config/tc-i386.c (match_template): Update error messages.

diff --git a/gas/cgen.c b/gas/cgen.c
index 59c7e561adc4e0c3c90ccc55402069deafa1234c..410ba55c55721f247cb1375064a755e2731aa1d5 100644 (file)
--- a/gas/cgen.c
+++ b/gas/cgen.c
@@ -410,7 +410,7 @@ gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP)
 
 #ifdef TC_CGEN_PARSE_FIX_EXP
   opinfo_1 = TC_CGEN_PARSE_FIX_EXP (opinfo_1, & exp);
-#endif 
+#endif
 
   /* FIXME: Need to check `want'.  */
 
@@ -466,15 +466,15 @@ gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP)
              stmp = symbol_create (FAKE_LABEL_NAME, expr_section, 0,
                                    & zero_address_frag);
              symbol_set_value_expression (stmp, & exp);
-           } 
-         else 
+           }
+         else
            stmp = make_expr_symbol (& exp);
 
          /* If this is a pc-relative RELC operand, we
-            need to subtract "." from the expression.  */        
+            need to subtract "." from the expression.  */
          if (reloc_type == BFD_RELOC_RELC
              && CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR))
-           stmp = expr_build_binary (O_subtract, stmp, expr_build_dot ()); 
+           stmp = expr_build_binary (O_subtract, stmp, expr_build_dot ());
 
          /* FIXME: this is not a perfect heuristic for figuring out
             whether an operand is signed: it only works when the operand
@@ -482,7 +482,7 @@ gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP)
             values will be signed relocs, but it's possible. */
          if (operand && (operand->hw_type == HW_H_SINT))
            signed_p = 1;
-         
+
          if (stmp->bsym && (stmp->bsym->section == expr_section))
            {
              if (signed_p)
@@ -490,16 +490,16 @@ gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP)
              else
                stmp->bsym->flags |= BSF_RELC;
            }
-         
+
          /* Now package it all up for the fixup emitter.  */
          exp.X_op = O_symbol;
          exp.X_op_symbol = 0;
          exp.X_add_symbol = stmp;
          exp.X_add_number = 0;
-             
+
          /* Re-init rightshift quantity, just in case.  */
          rightshift = operand->length;
-         queue_fixup_recursively (opindex, opinfo_1, & exp,  
+         queue_fixup_recursively (opindex, opinfo_1, & exp,
                                   (reloc_type == BFD_RELOC_RELC) ?
                                   & (operand->index_fields) : 0,
                                   signed_p, -1);
@@ -512,7 +512,7 @@ gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP)
       queue_fixup (opindex, opinfo_1, &exp);
       *valueP = 0;
       *resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED;
-#endif      
+#endif
       break;
     }
 
@@ -710,9 +710,9 @@ queue_fixup_recursively (const int                      opindex,
   if (field && field->count)
     {
       int i;
-  
+
       for (i = 0; i < field->count; ++ i)
-       queue_fixup_recursively (opindex, opinfo, expP, 
+       queue_fixup_recursively (opindex, opinfo, expP,
                                 & (field->val.multi[i]), signed_p, i);
     }
   else
@@ -731,20 +731,20 @@ queue_fixup_recursively (const int                      opindex,
          /* Shift reloc value by number of bits remaining after this
             field.  */
          if (rightshift)
-           new_exp = make_right_shifted_expr (expP, rightshift, signed_p);       
+           new_exp = make_right_shifted_expr (expP, rightshift, signed_p);
        }
-      
+
       /* Truncate reloc values to length, *after* leftmost one.  */
       fixups[num_fixups].msb_field_p = (part_of_multi <= 0);
       fixups[num_fixups].field = (CGEN_MAYBE_MULTI_IFLD *) field;
-      
+
       queue_fixup (opindex, opinfo, new_exp);
     }
 }
 
 /* Encode the self-describing RELC reloc format's addend.  */
 
-static unsigned long 
+static unsigned long
 gas_cgen_encode_addend (const unsigned long start,    /* in bits */
                        const unsigned long len,      /* in bits */
                        const unsigned long oplen,    /* in bits */
@@ -774,7 +774,7 @@ gas_cgen_encode_addend (const unsigned long start,    /* in bits */
    parse. when these %operators are translated to expressions by the macro
    expander, the ambiguity returns. we attempt to disambiguate by field
    size.
-   
+
    Method: check to see if the expression's top node is an O_and operator,
    and the mask is larger than the operand length. This would be an
    overflow, so signal it by returning an error string. Any other case is
@@ -794,23 +794,23 @@ weak_operand_overflow_check (const expressionS *  exp,
   if (exp->X_op != O_bit_and)
     {
       /* Check for implicit overflow flag.  */
-      if (CGEN_OPERAND_ATTR_VALUE 
+      if (CGEN_OPERAND_ATTR_VALUE
          (operand, CGEN_OPERAND_RELOC_IMPLIES_OVERFLOW))
        return _("a reloc on this operand implies an overflow");
       return NULL;
     }
-  
+
   mask = exp->X_add_number;
 
-  if (exp->X_add_symbol &&
-      exp->X_add_symbol->sy_value.X_op == O_constant)
+  if (exp->X_add_symbol
+      && exp->X_add_symbol->sy_value.X_op == O_constant)
     mask |= exp->X_add_symbol->sy_value.X_add_number;
 
-  if (exp->X_op_symbol &&
-      exp->X_op_symbol->sy_value.X_op == O_constant)
+  if (exp->X_op_symbol
+      && exp->X_op_symbol->sy_value.X_op == O_constant)
     mask |= exp->X_op_symbol->sy_value.X_add_number;
 
-  /* Want to know if mask covers more bits than opmask. 
+  /* Want to know if mask covers more bits than opmask.
      this is the same as asking if mask has any bits not in opmask,
      or whether (mask & ~opmask) is nonzero.  */
   if (mask && (mask & ~opmask))
@@ -822,10 +822,9 @@ weak_operand_overflow_check (const expressionS *  exp,
       return _("operand mask overflow");
     }
 
-  return NULL;  
+  return NULL;
 }
 
-
 static expressionS *
 make_right_shifted_expr (expressionS * exp,
                         const int     amount,
@@ -834,15 +833,15 @@ make_right_shifted_expr (expressionS * exp,
   symbolS * stmp = 0;
   expressionS * new_exp;
 
-  stmp = expr_build_binary (O_right_shift, 
+  stmp = expr_build_binary (O_right_shift,
                            make_expr_symbol (exp),
                            expr_build_uconstant (amount));
-  
+
   if (signed_p)
     stmp->bsym->flags |= BSF_SRELC;
   else
     stmp->bsym->flags |= BSF_RELC;
-  
+
   /* Then wrap that in a "symbol expr" for good measure.  */
   new_exp = xmalloc (sizeof (expressionS));
   memset (new_exp, 0, sizeof (expressionS));
@@ -850,10 +849,12 @@ make_right_shifted_expr (expressionS * exp,
   new_exp->X_op_symbol = 0;
   new_exp->X_add_symbol = stmp;
   new_exp->X_add_number = 0;
-  
+
   return new_exp;
 }
+
 #endif
+
 /* Apply a fixup to the object code.  This is called for all the
    fixups we generated by the call to fix_new_exp, above.  In the call
    above we used a reloc code which was the largest legal reloc code
@@ -897,7 +898,7 @@ gas_cgen_md_apply_fix (fixP, valP, seg)
       int signed_p = 0;
 
       if (fixP->fx_cgen.field)
-       {             
+       {
          /* Use the twisty little pointer path
             back to the ifield if it exists.  */
          start = fixP->fx_cgen.field->val.leaf->start;
@@ -964,9 +965,9 @@ gas_cgen_md_apply_fix (fixP, valP, seg)
          /* Change addend to "self-describing" form,
             for BFD to handle in the linker.  */
          value = gas_cgen_encode_addend (start, operand->length,
-                                         length, fixP->fx_size, 
-                                         cd->insn_chunk_bitsize / 8, 
-                                         signed_p, 
+                                         length, fixP->fx_size,
+                                         cd->insn_chunk_bitsize / 8,
+                                         signed_p,
                                          ! (fixP->fx_cgen.msb_field_p));
        }
 #endif