← Back to branch summary

~ubuntu-branches/debian/squeeze/binutils/squeeze

« back to all changes in this revision

Viewing changes to gas/config/tc-tic4x.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-09-10 17:05:30 UTC
  • mfrom: (1.4.5 upstream) (6.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090910170530-wa6gpju9pq5c56on
Tags: 2.19.91.20090910-1
* Snapshot, taken from the 2.20 release branch 20090910, corresponding
  to the 2.19.90 upstream snapshot.
* Fix Thumb-2 shared libraries (Daniel Jacobowitz), patch taken
  from the trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gas/config/tc-tic4x.c
1
1
/* tc-tic4x.c -- Assemble for the Texas Instruments TMS320C[34]x.
2
 
   Copyright (C) 1997,1998, 2002, 2003, 2005, 2006, 2007, 2008
 
2
   Copyright (C) 1997,1998, 2002, 2003, 2005, 2006, 2007, 2008, 2009
3
3
   Free Software Foundation. Inc.
4
4
 
5
5
   Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
396
396
      || flonum.sign == 0) /* = NaN */
397
397
    {
398
398
      if(flonum.sign == 0)
399
 
        as_bad ("Nan, using zero.");
 
399
        as_bad (_("Nan, using zero."));
400
400
      words[0] = 0x8000;
401
401
      return return_value;
402
402
    }
518
518
    }
519
519
 
520
520
  if (abs (exponent) >= (1 << (exponent_bits - 1)))
521
 
    as_bad ("Cannot represent exponent in %d bits", exponent_bits);
 
521
    as_bad (_("Cannot represent exponent in %d bits"), exponent_bits);
522
522
 
523
523
  /* Force exponent to fit in desired field width.  */
524
524
  exponent &= (1 << (exponent_bits)) - 1;
601
601
      break;
602
602
 
603
603
    default:
604
 
      as_bad ("Invalid floating point number");
 
604
      as_bad (_("Invalid floating point number"));
605
605
      return (NULL);
606
606
    }
607
607
 
611
611
  if (atof_generic (&return_value, ".", EXP_CHARS,
612
612
                    &generic_floating_point_number))
613
613
    {
614
 
      as_bad ("Invalid floating point number");
 
614
      as_bad (_("Invalid floating point number"));
615
615
      return (NULL);
616
616
    }
617
617
 
731
731
    input_line_pointer++;
732
732
  if (*input_line_pointer != ',')
733
733
    {
734
 
      as_bad ("Comma expected\n");
 
734
      as_bad (_("Comma expected\n"));
735
735
      return;
736
736
    }
737
737
  *input_line_pointer++ = '\0';
771
771
  c = get_symbol_end ();        /* Get terminator.  */
772
772
  if (c != ',')
773
773
    {
774
 
      as_bad (".bss size argument missing\n");
 
774
      as_bad (_(".bss size argument missing\n"));
775
775
      return;
776
776
    }
777
777
 
779
779
    tic4x_expression_abs (++input_line_pointer, &size);
780
780
  if (size < 0)
781
781
    {
782
 
      as_bad (".bss size %ld < 0!", (long) size);
 
782
      as_bad (_(".bss size %ld < 0!"), (long) size);
783
783
      return;
784
784
    }
785
785
  subseg_set (bss_section, 0);
913
913
          input_line_pointer = tic4x_expression (input_line_pointer, &exp);
914
914
          if (exp.X_op != O_constant)
915
915
            {
916
 
              as_bad("Non-constant symbols not allowed\n");
 
916
              as_bad (_("Non-constant symbols not allowed\n"));
917
917
              return;
918
918
            }
919
919
          exp.X_add_number &= 255; /* Limit numeber to 8-bit */
944
944
    tic4x_expression_abs (input_line_pointer, &value);
945
945
  if (*input_line_pointer++ != ',')
946
946
    {
947
 
      as_bad ("Symbol missing\n");
 
947
      as_bad (_("Symbol missing\n"));
948
948
      return;
949
949
    }
950
950
  name = input_line_pointer;
991
991
      subsection_name = input_line_pointer;
992
992
      c = get_symbol_end ();    /* Get terminator.  */
993
993
      input_line_pointer++;     /* Skip null symbol terminator.  */
994
 
      as_warn (".sect: subsection name ignored");
 
994
      as_warn (_(".sect: subsection name ignored"));
995
995
    }
996
996
 
997
997
  /* We might still have a '"' to discard, but the character after a
1019
1019
  if (bfd_get_section_flags (stdoutput, seg) == SEC_NO_FLAGS)
1020
1020
    {
1021
1021
      if (!bfd_set_section_flags (stdoutput, seg, SEC_DATA))
1022
 
        as_warn ("Error setting flags for \"%s\": %s", name,
 
1022
        as_warn (_("Error setting flags for \"%s\": %s"), name,
1023
1023
                 bfd_errmsg (bfd_get_error ()));
1024
1024
    }
1025
1025
 
1050
1050
      c = get_symbol_end ();    /* Get terminator.  */
1051
1051
      if (c != ',')
1052
1052
        {
1053
 
          as_bad (".set syntax invalid\n");
 
1053
          as_bad (_(".set syntax invalid\n"));
1054
1054
          ignore_rest_of_line ();
1055
1055
          return;
1056
1056
        }
1108
1108
  else
1109
1109
    alignment_flag = 0;
1110
1110
  if (alignment_flag)
1111
 
    as_warn (".usect: non-zero alignment flag ignored");
 
1111
    as_warn (_(".usect: non-zero alignment flag ignored"));
1112
1112
 
1113
1113
  seg = subseg_new (name, 0);
1114
1114
  if (line_label != NULL)
1119
1119
    }
1120
1120
  seg_info (seg)->bss = 1;      /* Uninitialised data.  */
1121
1121
  if (!bfd_set_section_flags (stdoutput, seg, SEC_ALLOC))
1122
 
    as_warn ("Error setting flags for \"%s\": %s", name,
 
1122
    as_warn (_("Error setting flags for \"%s\": %s"), name,
1123
1123
             bfd_errmsg (bfd_get_error ()));
1124
1124
  tic4x_seg_alloc (name, seg, size, line_label);
1125
1125
 
1139
1139
  input_line_pointer =
1140
1140
    tic4x_expression_abs (input_line_pointer, &temp);
1141
1141
  if (!IS_CPU_TIC3X (temp) && !IS_CPU_TIC4X (temp))
1142
 
    as_bad ("This assembler does not support processor generation %ld",
 
1142
    as_bad (_("This assembler does not support processor generation %ld"),
1143
1143
            (long) temp);
1144
1144
 
1145
1145
  if (tic4x_cpu && temp != (offsetT) tic4x_cpu)
1146
 
    as_warn ("Changing processor generation on fly not supported...");
 
1146
    as_warn (_("Changing processor generation on fly not supported..."));
1147
1147
  tic4x_cpu = temp;
1148
1148
  demand_empty_rest_of_line ();
1149
1149
}
1285
1285
  d = name;
1286
1286
 
1287
1287
  /* We do not care about INSNs that is not a part of our
1288
 
     oplevel setting */
1289
 
  if (!insts->oplevel & tic4x_oplevel)
 
1288
     oplevel setting.  */
 
1289
  if ((insts->oplevel & tic4x_oplevel) == 0)
1290
1290
    return ok;
1291
1291
 
1292
1292
  while (1)
1442
1442
          if (operand->aregno >= REG_AR0 && operand->aregno <= REG_AR7)
1443
1443
            break;
1444
1444
 
1445
 
          as_bad ("Auxiliary register AR0--AR7 required for indirect");
 
1445
          as_bad (_("Auxiliary register AR0--AR7 required for indirect"));
1446
1446
          return -1;
1447
1447
 
1448
1448
        case 'd':               /* Need to match constant for disp.  */
1456
1456
          operand->disp = operand->expr.X_add_number;
1457
1457
          if (operand->disp < 0 || operand->disp > 255)
1458
1458
            {
1459
 
              as_bad ("Bad displacement %d (require 0--255)\n",
 
1459
              as_bad (_("Bad displacement %d (require 0--255)\n"),
1460
1460
                      operand->disp);
1461
1461
              return -1;
1462
1462
            }
1474
1474
          if (operand->expr.X_add_number != REG_IR0
1475
1475
              && operand->expr.X_add_number != REG_IR1)
1476
1476
            {
1477
 
              as_bad ("Index register IR0,IR1 required for displacement");
 
1477
              as_bad (_("Index register IR0,IR1 required for displacement"));
1478
1478
              return -1;
1479
1479
            }
1480
1480
 
1516
1516
  expressionS *exp = &operand->expr;
1517
1517
  char *save = input_line_pointer;
1518
1518
  char *str;
1519
 
  char *new;
 
1519
  char *new_pointer;
1520
1520
  struct hash_entry *entry = NULL;
1521
1521
 
1522
1522
  input_line_pointer = s;
1524
1524
 
1525
1525
  str = input_line_pointer;
1526
1526
  c = get_symbol_end ();        /* Get terminator.  */
1527
 
  new = input_line_pointer;
 
1527
  new_pointer = input_line_pointer;
1528
1528
  if (strlen (str) && (entry = hash_find (tic4x_asg_hash, str)) != NULL)
1529
1529
    {
1530
1530
      *input_line_pointer = c;
1543
1543
    case '%':
1544
1544
      input_line_pointer = tic4x_expression (++input_line_pointer, exp);
1545
1545
      if (exp->X_op != O_register)
1546
 
        as_bad ("Expecting a register name");
 
1546
        as_bad (_("Expecting a register name"));
1547
1547
      operand->mode = M_REGISTER;
1548
1548
      break;
1549
1549
 
1555
1555
      else if (exp->X_op == O_big)
1556
1556
        {
1557
1557
          if (exp->X_add_number)
1558
 
            as_bad ("Number too large");        /* bignum required */
 
1558
            as_bad (_("Number too large"));     /* bignum required */
1559
1559
          else
1560
1560
            {
1561
1561
              tic4x_gen_to_words (generic_floating_point_number,
1578
1578
      else if (exp->X_op == O_big)
1579
1579
        {
1580
1580
          if (exp->X_add_number > 0)
1581
 
            as_bad ("Number too large");        /* bignum required.  */
 
1581
            as_bad (_("Number too large"));     /* bignum required.  */
1582
1582
          else
1583
1583
            {
1584
1584
              tic4x_gen_to_words (generic_floating_point_number,
1595
1595
        }
1596
1596
 
1597
1597
      else
1598
 
        as_bad ("Expecting a constant value");
 
1598
        as_bad (_("Expecting a constant value"));
1599
1599
      break;
1600
1600
    case '\\':
1601
1601
#endif
1602
1602
    case '@':
1603
1603
      input_line_pointer = tic4x_expression (++input_line_pointer, exp);
1604
1604
      if (exp->X_op != O_constant && exp->X_op != O_symbol)
1605
 
        as_bad ("Bad direct addressing construct %s", s);
 
1605
        as_bad (_("Bad direct addressing construct %s"), s);
1606
1606
      if (exp->X_op == O_constant)
1607
1607
        {
1608
1608
          if (exp->X_add_number < 0)
1609
 
            as_bad ("Direct value of %ld is not suitable",
 
1609
            as_bad (_("Direct value of %ld is not suitable"),
1610
1610
                    (long) exp->X_add_number);
1611
1611
        }
1612
1612
      operand->mode = M_DIRECT;
1630
1630
            operand->expr.X_add_number = 0x18;
1631
1631
        }
1632
1632
      else
1633
 
        as_bad ("Unknown indirect addressing mode");
 
1633
        as_bad (_("Unknown indirect addressing mode"));
1634
1634
      break;
1635
1635
 
1636
1636
    default:
1647
1647
      else if (exp->X_op == O_big)
1648
1648
        {
1649
1649
          if (exp->X_add_number > 0)
1650
 
            as_bad ("Number too large");        /* bignum required.  */
 
1650
            as_bad (_("Number too large"));     /* bignum required.  */
1651
1651
          else
1652
1652
            {
1653
1653
              tic4x_gen_to_words (generic_floating_point_number,
1666
1666
#endif
1667
1667
    }
1668
1668
  if (entry == NULL)
1669
 
    new = input_line_pointer;
 
1669
    new_pointer = input_line_pointer;
1670
1670
  input_line_pointer = save;
1671
 
  return new;
 
1671
  return new_pointer;
1672
1672
}
1673
1673
 
1674
1674
static int 
1727
1727
              else
1728
1728
                {
1729
1729
                  if (!check)
1730
 
                    as_bad ("Immediate value of %ld is too large for ldf",
 
1730
                    as_bad (_("Immediate value of %ld is too large for ldf"),
1731
1731
                            (long) exp->X_add_number);
1732
1732
                  ret = -1;
1733
1733
                  continue;
1767
1767
          else
1768
1768
            {
1769
1769
              if (!check)
1770
 
                as_bad ("Destination register must be ARn");
 
1770
                as_bad (_("Destination register must be ARn"));
1771
1771
              ret = -1;
1772
1772
            }
1773
1773
          continue;
1786
1786
              else
1787
1787
                {
1788
1788
                  if (!check)
1789
 
                    as_bad ("Immediate value of %ld is too large",
 
1789
                    as_bad (_("Immediate value of %ld is too large"),
1790
1790
                            (long) exp->X_add_number);
1791
1791
                  ret = -1;
1792
1792
                  continue;
1815
1815
              && operand->expr.X_add_number != 0x18)
1816
1816
            {
1817
1817
              if (!check)
1818
 
                as_bad ("Invalid indirect addressing mode");
 
1818
                as_bad (_("Invalid indirect addressing mode"));
1819
1819
              ret = -1;
1820
1820
              continue;
1821
1821
            }
1839
1839
          else
1840
1840
            {
1841
1841
              if (!check)
1842
 
                as_bad ("Register must be Rn");
 
1842
                as_bad (_("Register must be Rn"));
1843
1843
              ret = -1;
1844
1844
            }
1845
1845
          continue;
1879
1879
          else
1880
1880
            {
1881
1881
              if (!check)
1882
 
                as_bad ("Register must be Rn");
 
1882
                as_bad (_("Register must be Rn"));
1883
1883
              ret = -1;
1884
1884
            }
1885
1885
          continue;
1893
1893
          else
1894
1894
            {
1895
1895
              if (!check)
1896
 
                as_bad ("Register must be R0--R7");
 
1896
                as_bad (_("Register must be R0--R7"));
1897
1897
              ret = -1;
1898
1898
            }
1899
1899
          continue;
1917
1917
              if (IS_CPU_TIC4X (tic4x_cpu))
1918
1918
                break;
1919
1919
              if (!check)
1920
 
                as_bad ("Invalid indirect addressing mode displacement %d",
 
1920
                as_bad (_("Invalid indirect addressing mode displacement %d"),
1921
1921
                        operand->disp);
1922
1922
              ret = -1;
1923
1923
              continue;
1945
1945
              if (IS_CPU_TIC4X (tic4x_cpu))
1946
1946
                break;
1947
1947
              if (!check)
1948
 
                as_bad ("Invalid indirect addressing mode displacement %d",
 
1948
                as_bad (_("Invalid indirect addressing mode displacement %d"),
1949
1949
                        operand->disp);
1950
1950
              ret = -1;
1951
1951
              continue;
1963
1963
          else
1964
1964
            {
1965
1965
              if (!check)
1966
 
                as_bad ("Register must be R0--R7");
 
1966
                as_bad (_("Register must be R0--R7"));
1967
1967
              ret = -1;
1968
1968
            }
1969
1969
          continue;
1977
1977
          else
1978
1978
            {
1979
1979
              if (!check)
1980
 
                as_bad ("Register must be R0--R7");
 
1980
                as_bad (_("Register must be R0--R7"));
1981
1981
              ret = -1;
1982
1982
            }
1983
1983
          continue;
1991
1991
          else
1992
1992
            {
1993
1993
              if (!check)
1994
 
                as_bad ("Destination register must be R2 or R3");
 
1994
                as_bad (_("Destination register must be R2 or R3"));
1995
1995
              ret = -1;
1996
1996
            }
1997
1997
          continue;
2005
2005
          else
2006
2006
            {
2007
2007
              if (!check)
2008
 
                as_bad ("Destination register must be R0 or R1");
 
2008
                as_bad (_("Destination register must be R0 or R1"));
2009
2009
              ret = -1;
2010
2010
            }
2011
2011
          continue;
2020
2020
              && operand->expr.X_add_number != 0x18)
2021
2021
            {
2022
2022
              if (!check)
2023
 
                as_bad ("Invalid indirect addressing mode");
 
2023
                as_bad (_("Invalid indirect addressing mode"));
2024
2024
              ret = -1;
2025
2025
              continue;
2026
2026
            }
2042
2042
              else
2043
2043
                {
2044
2044
                  if (!check)
2045
 
                    as_bad ("Displacement value of %ld is too large",
 
2045
                    as_bad (_("Displacement value of %ld is too large"),
2046
2046
                            (long) exp->X_add_number);
2047
2047
                  ret = -1;
2048
2048
                  continue;
2070
2070
          else
2071
2071
            {
2072
2072
              if (!check)
2073
 
                as_bad ("Register must be Rn");
 
2073
                as_bad (_("Register must be Rn"));
2074
2074
              ret = -1;
2075
2075
            }
2076
2076
          continue;
2092
2092
          else
2093
2093
            {
2094
2094
              if (!check)
2095
 
                as_bad ("Register must be Rn");
 
2095
                as_bad (_("Register must be Rn"));
2096
2096
              ret = -1;
2097
2097
            }
2098
2098
          continue;
2103
2103
          if (exp->X_op == O_big)
2104
2104
            {
2105
2105
              if (!check)
2106
 
                as_bad ("Floating point number not valid in expression");
 
2106
                as_bad (_("Floating point number not valid in expression"));
2107
2107
              ret = -1;
2108
2108
              continue;
2109
2109
            }
2117
2117
              else
2118
2118
                {
2119
2119
                  if (!check)
2120
 
                    as_bad ("Signed immediate value %ld too large",
 
2120
                    as_bad (_("Signed immediate value %ld too large"),
2121
2121
                            (long) exp->X_add_number);
2122
2122
                  ret = -1;
2123
2123
                  continue;
2159
2159
              else
2160
2160
                {
2161
2161
                  if (!check)
2162
 
                    as_bad ("Immediate value of %ld is too large",
 
2162
                    as_bad (_("Immediate value of %ld is too large"),
2163
2163
                            (long) exp->X_add_number);
2164
2164
                  ret = -1;
2165
2165
                  continue;
2180
2180
              else
2181
2181
                {
2182
2182
                  if (!check)
2183
 
                    as_bad ("Unsigned immediate value %ld too large",
 
2183
                    as_bad (_("Unsigned immediate value %ld too large"),
2184
2184
                            (long) exp->X_add_number);
2185
2185
                  ret = -1;
2186
2186
                  continue;
2218
2218
              else
2219
2219
                {
2220
2220
                  if (!check)
2221
 
                    as_bad ("Immediate value of %ld is too large",
 
2221
                    as_bad (_("Immediate value of %ld is too large"),
2222
2222
                            (long) exp->X_add_number);
2223
2223
                  ret = -1;
2224
2224
                  continue;
2234
2234
          if (exp->X_op == O_big)
2235
2235
            {
2236
2236
              if (!check)
2237
 
                as_bad ("Floating point number not valid in expression");
 
2237
                as_bad (_("Floating point number not valid in expression"));
2238
2238
              ret = -1;
2239
2239
              continue;
2240
2240
            }
2248
2248
              else
2249
2249
                {
2250
2250
                  if (!check)
2251
 
                    as_bad ("Immediate value %ld too large",
 
2251
                    as_bad (_("Immediate value %ld too large"),
2252
2252
                            (long) exp->X_add_number);
2253
2253
                  ret = -1;
2254
2254
                  continue;
2267
2267
          else
2268
2268
            {
2269
2269
              if (!check)
2270
 
                as_bad ("Register must be ivtp or tvtp");
 
2270
                as_bad (_("Register must be ivtp or tvtp"));
2271
2271
              ret = -1;
2272
2272
            }
2273
2273
          continue;
2281
2281
          else
2282
2282
            {
2283
2283
              if (!check)
2284
 
                as_bad ("Register must be address register");
 
2284
                as_bad (_("Register must be address register"));
2285
2285
              ret = -1;
2286
2286
            }
2287
2287
          continue;
2295
2295
          else
2296
2296
            {
2297
2297
              if (!check)
2298
 
                as_bad ("Register must be ivtp or tvtp");
 
2298
                as_bad (_("Register must be ivtp or tvtp"));
2299
2299
              ret = -1;
2300
2300
            }
2301
2301
          continue;
2354
2354
      if ( insn->operands[0].mode == M_REGISTER
2355
2355
           && insn->operands[1].mode == M_REGISTER
2356
2356
           && insn->operands[0].expr.X_add_number == insn->operands[1].expr.X_add_number )
2357
 
        as_bad ("Source and destination register should not be equal");
 
2357
        as_bad (_("Source and destination register should not be equal"));
2358
2358
    }
2359
2359
  else if( !strcmp(insn->name, "ldi_ldi")
2360
2360
           || !strcmp(insn->name, "ldi1_ldi2")
2369
2369
      if ( insn->operands[1].mode == M_REGISTER
2370
2370
           && insn->operands[insn->num_operands-1].mode == M_REGISTER
2371
2371
           && insn->operands[1].expr.X_add_number == insn->operands[insn->num_operands-1].expr.X_add_number )
2372
 
        as_warn ("Equal parallell destination registers, one result will be discarded");
 
2372
        as_warn (_("Equal parallell destination registers, one result will be discarded"));
2373
2373
    }
2374
2374
}
2375
2375
 
2410
2410
 
2411
2411
  if (num_operands > TIC4X_OPERANDS_MAX)
2412
2412
    {
2413
 
      as_bad ("Too many operands scanned");
 
2413
      as_bad (_("Too many operands scanned"));
2414
2414
      return -1;
2415
2415
    }
2416
2416
  return num_operands;
2440
2440
        {
2441
2441
          if(insn->parallel)
2442
2442
            {
2443
 
              as_bad ("Parallel opcode cannot contain more than two instructions");
 
2443
              as_bad (_("Parallel opcode cannot contain more than two instructions"));
2444
2444
              insn->parallel = 0;
2445
2445
              insn->in_use = 0;
2446
2446
              return;
2485
2485
      if ((insn->inst = (struct tic4x_inst *)
2486
2486
           hash_find (tic4x_op_hash, insn->name)) == NULL)
2487
2487
        {
2488
 
          as_bad ("Unknown opcode `%s'.", insn->name);
 
2488
          as_bad (_("Unknown opcode `%s'."), insn->name);
2489
2489
          insn->parallel = 0;
2490
2490
          insn->in_use = 0;
2491
2491
          return;
2513
2513
        {
2514
2514
          if (first_inst)
2515
2515
            tic4x_operands_match (first_inst, insn, 0);
2516
 
          as_bad ("Invalid operands for %s", insn->name);
 
2516
          as_bad (_("Invalid operands for %s"), insn->name);
2517
2517
        }
2518
2518
      else
2519
 
        as_bad ("Invalid instruction %s", insn->name);
 
2519
        as_bad (_("Invalid instruction %s"), insn->name);
2520
2520
    }
2521
2521
 
2522
2522
  if (str && !parsed)
2665
2665
 
2666
2666
    case NO_RELOC:
2667
2667
    default:
2668
 
      as_bad ("Bad relocation type: 0x%02x", fixP->fx_r_type);
 
2668
      as_bad (_("Bad relocation type: 0x%02x"), fixP->fx_r_type);
2669
2669
      break;
2670
2670
    }
2671
2671
 
2723
2723
        arg++;
2724
2724
      tic4x_cpu = atoi (arg);
2725
2725
      if (!IS_CPU_TIC3X (tic4x_cpu) && !IS_CPU_TIC4X (tic4x_cpu))
2726
 
        as_warn ("Unsupported processor generation %d", tic4x_cpu);
 
2726
        as_warn (_("Unsupported processor generation %d"), tic4x_cpu);
2727
2727
      break;
2728
2728
 
2729
2729
    case OPTION_REV:             /* cpu revision */
2731
2731
      break;
2732
2732
 
2733
2733
    case 'b':
2734
 
      as_warn ("Option -b is depreciated, please use -mbig");
 
2734
      as_warn (_("Option -b is depreciated, please use -mbig"));
2735
2735
    case OPTION_BIG:             /* big model */
2736
2736
      tic4x_big_model = 1;
2737
2737
      break;
2738
2738
 
2739
2739
    case 'p':
2740
 
      as_warn ("Option -p is depreciated, please use -mmemparm");
 
2740
      as_warn (_("Option -p is depreciated, please use -mmemparm"));
2741
2741
    case OPTION_MEMPARM:         /* push args */
2742
2742
      tic4x_reg_args = 0;
2743
2743
      break;
2744
2744
 
2745
2745
    case 'r':                   
2746
 
      as_warn ("Option -r is depreciated, please use -mregparm");
 
2746
      as_warn (_("Option -r is depreciated, please use -mregparm"));
2747
2747
    case OPTION_REGPARM:        /* register args */
2748
2748
      tic4x_reg_args = 1;
2749
2749
      break;
2750
2750
 
2751
2751
    case 's':
2752
 
      as_warn ("Option -s is depreciated, please use -msmall");
 
2752
      as_warn (_("Option -s is depreciated, please use -msmall"));
2753
2753
    case OPTION_SMALL:          /* small model */
2754
2754
      tic4x_big_model = 0;
2755
2755
      break;
2822
2822
 
2823
2823
  if (dollar_label_defined (lab))
2824
2824
    {
2825
 
      as_bad ("Label \"$%d\" redefined", lab);
 
2825
      as_bad (_("Label \"$%d\" redefined"), lab);
2826
2826
      return 0;
2827
2827
    }
2828
2828
 
3030
3030
  if (reloc->howto == (reloc_howto_type *) NULL)
3031
3031
    {
3032
3032
      as_bad_where (fixP->fx_file, fixP->fx_line,
3033
 
                    "Reloc %d not supported by object file format",
 
3033
                    _("Reloc %d not supported by object file format"),
3034
3034
                    (int) fixP->fx_r_type);
3035
3035
      return NULL;
3036
3036
    }