gcc/config/1750a/1750a.c

   1 /* Subroutines for insn-output.c for MIL-STD-1750.
   2    Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   3    Contributed by O.M.Kellogg, DASA (kellogg@space.otn.dasa.de)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 1, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #ifndef FILE
  23 #include <stdio.h>
  24 #endif
  25 #include <string.h>
  26
  27 #define __datalbl
  28 #include "config.h"
  29 #include "rtl.h"
  30 #include "tree.h"
  31 #include "expr.h"
  32 #define HAVE_cc0
  33 #include "conditions.h"
  34 #include "real.h"
  35 #include "regs.h"
  36
  37 struct datalabel_array datalbl[DATALBL_ARRSIZ];
  38 int datalbl_ndx = -1;
  39 struct jumplabel_array jmplbl[JMPLBL_ARRSIZ];
  40 int jmplbl_ndx = -1;
  41 int label_pending = 0, program_counter = 0;
  42 enum section current_section = Normal;
  43 char *sectname[4] =
  44 {"Init", "Normal", "Konst", "Static"};
  45
  46 int
  47 notice_update_cc (exp)
  48      rtx exp;
  49 {
  50   if (GET_CODE (exp) == SET)
  51     {
  52       enum rtx_code src_code = GET_CODE (SET_SRC (exp));
  53       /* Jumps do not alter the cc's.  */
  54       if (SET_DEST (exp) == pc_rtx)
  55         return;
  56       /* Moving a register or constant into memory doesn't alter the cc's. */
  57       if (GET_CODE (SET_DEST (exp)) == MEM
  58           && (src_code == REG || src_code == CONST_INT))
  59         return;
  60       /* Function calls clobber the cc's.  */
  61       if (src_code == CALL)
  62         {
  63           CC_STATUS_INIT;
  64           return;
  65         }
  66       /* Emulated longword bit-ops leave cc's incorrect */
  67       if (GET_MODE (SET_DEST (exp)) == HImode ?
  68                src_code == AND || src_code == IOR ||
  69                src_code == XOR || src_code == NOT : 0)
  70         {
  71           CC_STATUS_INIT;
  72           return;
  73         }
  74       /* Tests and compares set the cc's in predictable ways.  */
  75       if (SET_DEST (exp) == cc0_rtx)
  76         {
  77           CC_STATUS_INIT;
  78           cc_status.value1 = SET_SRC (exp);
  79           return;
  80         }
  81       /* Anything else will set cc_status. */
  82       cc_status.flags = CC_NO_OVERFLOW;
  83       cc_status.value1 = SET_SRC (exp);
  84       cc_status.value2 = SET_DEST (exp);
  85       return;
  86     }
  87   else if (GET_CODE (exp) == PARALLEL
  88            && GET_CODE (XVECEXP (exp, 0, 0)) == SET)
  89     {
  90       if (SET_DEST (XVECEXP (exp, 0, 0)) == pc_rtx)
  91         return;
  92       if (SET_DEST (XVECEXP (exp, 0, 0)) == cc0_rtx)
  93         {
  94           CC_STATUS_INIT;
  95           cc_status.value1 = SET_SRC (XVECEXP (exp, 0, 0));
  96           return;
  97         }
  98       CC_STATUS_INIT;
  99     }
 100   else
 101     {
 102       CC_STATUS_INIT;
 103     }
 104 }
 105
 106
 107 rtx
 108 function_arg (cum, mode, type, named)
 109      int cum;
 110      enum machine_mode mode;
 111      tree type;
 112      int named;
 113 {
 114   int size;
 115
 116   if (MUST_PASS_IN_STACK (mode, type))
 117     return (rtx) 0;
 118   if (mode == BLKmode)
 119     size = int_size_in_bytes (type);
 120   else
 121     size = GET_MODE_SIZE (mode);
 122   if (cum + size < 12)
 123     return gen_rtx (REG, mode, cum);
 124   else
 125     return (rtx) 0;
 126 }
 127
 128
 129 double
 130 get_double (x)
 131      rtx x;
 132 {
 133   union
 134     {
 135       double d;
 136       long i[2];
 137     }
 138   du;
 139
 140   du.i[0] = CONST_DOUBLE_LOW (x);
 141   du.i[1] = CONST_DOUBLE_HIGH (x);
 142   return du.d;
 143 }
 144
 145 char *
 146 float_label (code, value)
 147      char code;
 148      double value;
 149 {
 150   int i = 1;
 151   static char label[32];
 152   char *p;
 153
 154   label[0] = code;
 155   p = label + 1;
 156   sprintf (p, "%lf", value);
 157   while (*p)
 158     {
 159       *p = (*p == '+') ? 'p' :
 160         (*p == '-') ? 'm' : *p;
 161       p++;
 162     }
 163   return xstrdup (label);
 164 }
 165
 166
 167 char *
 168 movcnt_regno_adjust (op)
 169      rtx *op;
 170 {
 171   static char outstr[80];
 172   int op0r = REGNO (op[0]), op1r = REGNO (op[1]), op2r = REGNO (op[2]);
 173 #define dstreg op0r
 174 #define srcreg op1r
 175 #define cntreg op2r
 176 #define cntreg_1750 (op0r + 1)
 177
 178   if (cntreg == cntreg_1750)
 179     sprintf (outstr, "mov r%d,r%d", op0r, op1r);
 180   else if (dstreg + 1 == srcreg && cntreg > srcreg)
 181     sprintf (outstr, "xwr r%d,r%d\n\tmov r%d,r%d", op2r, op1r, op0r, op2r);
 182   else if (dstreg == cntreg + 1)
 183     sprintf (outstr, "xwr r%d,r%d\n\tmov r%d,r%d", op0r, op2r, op2r, op1r);
 184   else if (dstreg == srcreg + 1)
 185     sprintf (outstr, "xwr r%d,r%d\n\txwr r%d,r%d\n\tmov r%d,r%d",
 186              op0r, op1r, op0r, op2r, op1r, op2r);
 187   else if (cntreg + 1 == srcreg)
 188     sprintf (outstr, "xwr r%d,r%d\n\txwr r%d,r%d\n\tmov r%d,r%d",
 189              op2r, op1r, op0r, op2r, op2r, op0r);
 190   else if (cntreg == srcreg + 1)
 191     sprintf (outstr, "xwr r%d,r%d\n\tmov r%d,r%d", op0r, op1r, op1r, op0r);
 192   else
 193     sprintf (outstr, "xwr r%d,r%d\n\tmov r%d,r%d\n\txwr r%d,r%d",
 194              op2r, cntreg_1750, op0r, op1r, op2r, cntreg_1750);
 195   return outstr;
 196 }
 197
 198 char *
 199 mod_regno_adjust (instr, op)
 200      char *instr;
 201      rtx *op;
 202 {
 203   static char outstr[40];
 204   char *r = (!strncmp (instr, "dvr", 3) ? "r" : "");
 205   int modregno_gcc = REGNO (op[3]), modregno_1750 = REGNO (op[0]) + 1;
 206
 207   if (modregno_gcc == modregno_1750
 208       || (reg_renumber != NULL
 209           && reg_renumber[modregno_gcc] >= 0
 210           && reg_renumber[modregno_gcc] == reg_renumber[modregno_1750]))
 211     sprintf (outstr, "%s r%%0,%s%%2", instr, r);
 212   else
 213     sprintf (outstr, "lr r%d,r%d\n\t%s r%%0,%s%%2\n\txwr r%d,r%d",
 214              modregno_gcc, modregno_1750, instr, r, modregno_1750,
 215              modregno_gcc);
 216   return outstr;
 217 }
 218
 219
 220 /* Check if op is a valid memory operand for 1750A Load/Store instructions
 221    (memory indirection permitted.)  */
 222
 223 int
 224 memop_valid (op)
 225      rtx op;
 226 {
 227   static int recurred = 0;
 228   int valid;
 229
 230   if (GET_MODE (op) != Pmode && GET_MODE (op) != VOIDmode
 231       && GET_MODE (op) != QImode)
 232     return 0;
 233   switch (GET_CODE (op))
 234     {
 235     case MEM:
 236       if (!recurred && GET_CODE (XEXP (op, 0)) == REG)
 237         return 1;
 238     case MINUS:
 239     case MULT:
 240     case DIV:
 241       return 0;
 242     case PLUS:
 243       recurred = 1;
 244       valid = memop_valid (XEXP (op, 0));
 245       if (valid)
 246         valid = memop_valid (XEXP (op, 1));
 247        recurred = 0;
 248        return valid;
 249     case REG:
 250       if (REGNO (op) > 0)
 251         return 1;
 252       return 0;
 253     case CONST:
 254     case CONST_INT:
 255     case SYMBOL_REF:
 256     case SUBREG:
 257       return 1;
 258     default:
 259       printf ("memop_valid: code=%d\n", (int) GET_CODE (op));
 260       return 1;
 261     }
 262 }
 263
 264
 265 /* predicate for the MOV instruction: */
 266 int
 267 mov_memory_operand (op, mode)
 268      rtx op;
 269      enum machine_mode mode;
 270 {
 271   return (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == REG);
 272 }
 273
 274 /* predicate for the STC instruction: */
 275 int
 276 small_nonneg_const (op, mode)
 277      rtx op;
 278      enum machine_mode mode;
 279 {
 280   if (GET_CODE (op) == CONST_INT && INTVAL (op) >= 0 && INTVAL (op) <= 15)
 281     return 1;
 282   return 0;
 283 }
 284
 285 /* predicate for constant zero: */
 286 int
 287 zero_operand (op, mode)
 288      rtx op;
 289      enum machine_mode mode;
 290 {
 291   return op == CONST0_RTX (mode);
 292 }
 293
 294
 295 /* predicate for 1750 `B' addressing mode (Base Register with Offset)
 296    memory operand */
 297 int
 298 b_mode_operand (op)
 299      rtx op;
 300 {
 301   if (GET_CODE (op) == MEM)
 302     {
 303       rtx inner = XEXP (op, 0);
 304       if (GET_CODE (inner) == REG && REG_OK_FOR_INDEX_P (inner))
 305         return 1;
 306       if (GET_CODE (inner) == PLUS)
 307         {
 308           rtx plus_op0 = XEXP (inner, 0);
 309           if (GET_CODE (plus_op0) == REG && REG_OK_FOR_INDEX_P (plus_op0))
 310             {
 311               rtx plus_op1 = XEXP (inner, 1);
 312               if (GET_CODE (plus_op1) == CONST_INT
 313                   && INTVAL (plus_op1) >= 0
 314                   && INTVAL (plus_op1) <= 255)
 315                 return 1;
 316             }
 317         }
 318     }
 319   return 0;
 320 }
 321
 322
 323 /* Decide whether to output a conditional jump as a "Jump Conditional"
 324    or as a "Branch Conditional": */
 325
 326 int
 327 find_jmplbl (labelnum)
 328      int labelnum;
 329 {
 330   int i, found = 0;
 331
 332   for (i = 0; i <= jmplbl_ndx; i++)
 333     if (labelnum == jmplbl[i].num)
 334       {
 335         found = 1;
 336         break;
 337       }
 338   if (found)
 339     return i;
 340   return -1;
 341 }
 342
 343 char *
 344 branch_or_jump (condition, targetlabel_number)
 345      char *condition;
 346      int targetlabel_number;
 347 {
 348   static char buf[30];
 349   int index;
 350
 351   if ((index = find_jmplbl (targetlabel_number)) >= 0)
 352     if (program_counter - jmplbl[index].pc < 128)
 353       {
 354         sprintf (buf, "b%s %%l0", condition);
 355         return buf;
 356       }
 357   sprintf (buf, "jc %s,%%l0", condition);
 358   return buf;
 359 }
 360
 361
 362 int
 363 unsigned_comparison_operator (insn)
 364      rtx insn;
 365 {
 366   switch (GET_CODE (insn))
 367     {
 368     case GEU:
 369     case GTU:
 370     case LEU:
 371     case LTU:
 372       return 1;
 373     default:
 374       return 0;
 375     }
 376 }
 377
 378 int
 379 next_cc_user_is_unsigned (insn)
 380      rtx insn;
 381 {
 382   if ( !(insn = next_cc0_user (insn)))
 383     abort ();
 384   else if (GET_CODE (insn) == JUMP_INSN
 385            && GET_CODE (PATTERN (insn)) == SET
 386            && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE)
 387     return unsigned_comparison_operator (XEXP (SET_SRC (PATTERN (insn)), 0));
 388   else if (GET_CODE (insn) == INSN
 389            && GET_CODE (PATTERN (insn)) == SET)
 390     return unsigned_comparison_operator (SET_SRC (PATTERN (insn)));
 391   else
 392     abort ();
 393 }
 394
 395
 396 static int addr_inc;
 397
 398 /* A C compound statement to output to stdio stream STREAM the
 399    assembler syntax for an instruction operand X.  X is an RTL
 400    expression.
 401
 402    CODE is a value that can be used to specify one of several ways
 403    of printing the operand.  It is used when identical operands
 404    must be printed differently depending on the context.  CODE
 405    comes from the `%' specification that was used to request
 406    printing of the operand.  If the specification was just `%DIGIT'
 407    then CODE is 0; if the specification was `%LTR DIGIT' then CODE
 408    is the ASCII code for LTR.
 409
 410    If X is a register, this macro should print the register's name.
 411    The names can be found in an array `reg_names' whose type is
 412    `char *[]'.  `reg_names' is initialized from `REGISTER_NAMES'.
 413
 414    When the machine description has a specification `%PUNCT' (a `%'
 415    followed by a punctuation character), this macro is called with
 416    a null pointer for X and the punctuation character for CODE.
 417
 418    The 1750 specific codes are:
 419    'J' for the negative of a constant
 420    'Q' for printing addresses in B mode syntax
 421    'd' for the second register in a pair
 422    't' for the third register in a triple
 423    'b' for the bit number (using 1750 test bit convention)
 424    'B' for the bit number of the 1's complement (for bit clear)
 425    'w' for int - 16
 426 */
 427
 428 print_operand (file, x, letter)
 429      FILE *file;
 430      rtx x;
 431      int letter;
 432 {
 433   switch (GET_CODE (x))
 434     {
 435     case REG:
 436       if (letter == 'd')
 437         fprintf (file, "%d", REGNO (x) + 1);
 438       else if (letter == 't')
 439         fprintf (file, "%d", REGNO (x) + 2);
 440       else
 441         fprintf (file, "%d", REGNO (x));
 442       break;
 443
 444     case SYMBOL_REF:
 445       fprintf (file, "%s", XSTR (x, 0));
 446       if (letter == 'A')
 447         fprintf (file, "+1");
 448       break;
 449
 450     case LABEL_REF:
 451     case CONST:
 452     case MEM:
 453       if (letter == 'Q')
 454         {
 455           rtx inner = XEXP (x, 0);
 456           switch (GET_CODE (inner))
 457             {
 458             case REG:
 459               fprintf (file, "r%d,0", REGNO (inner));
 460               break;
 461             case PLUS:
 462               fprintf (file, "r%d,%d", REGNO (XEXP (inner, 0)),
 463                        INTVAL (XEXP (inner, 1)));
 464               break;
 465             default:
 466               fprintf (file, "[ill Q code=%d]", GET_CODE (inner));
 467             }
 468         }
 469       else
 470         {
 471           addr_inc = (letter == 'A' ? 1 : 0);
 472           output_address (XEXP (x, 0));
 473         }
 474       break;
 475
 476     case CONST_DOUBLE:
 477 /*    {
 478         double value = get_double (x);
 479         char fltstr[32];
 480         sprintf (fltstr, "%lf", value);
 481
 482         if (letter == 'D' || letter == 'E')
 483           {
 484             int i, found = 0;
 485             for (i = 0; i <= datalbl_ndx; i++)
 486               if (strcmp (fltstr, datalbl[i].value) == 0)
 487                 {
 488                   found = 1;
 489                   break;
 490                 }
 491             if (!found)
 492               {
 493                 strcpy (datalbl[i = ++datalbl_ndx].value, fltstr);
 494                 datalbl[i].name = float_label (letter, value);
 495                 datalbl[i].size = (letter == 'E') ? 3 : 2;
 496                 check_section (Konst);
 497                 fprintf (file, "K%s \tdata%s %s ;p_o\n", datalbl[i].name,
 498                         (letter == 'E' ? "ef" : "f"), fltstr);
 499                 check_section (Normal);
 500               }
 501           }
 502         else if (letter == 'F' || letter == 'G')
 503           {
 504             int i, found = 0;
 505             for (i = 0; i <= datalbl_ndx; i++)
 506               if (strcmp (fltstr, datalbl[i].value) == 0)
 507                 {
 508                   found = 1;
 509                   break;
 510                 }
 511             if (!found)
 512               {
 513                 fprintf (stderr,
 514                    "float value %lfnot found upon label reference\n", value);
 515                 strcpy (datalbl[i = ++datalbl_ndx].value, fltstr);
 516                 datalbl[i].name = float_label (letter, value);
 517                 datalbl[i].size = (letter == 'G') ? 3 : 2;
 518                 check_section (Konst);
 519                 fprintf (file, "K%s \tdata%s %s ;p_o\n", datalbl[i].name,
 520                         (letter == 'G' ? "ef" : "f"), fltstr);
 521                 check_section (Normal);
 522               }
 523             fprintf (file, "%s ;P_O 'F'", datalbl[i].name);
 524           }
 525         else
 526           fprintf (file, " %s  ;P_O cst_dbl ", fltstr);
 527       }
 528  */
 529       fprintf (file, "%lf", get_double (x));
 530       break;
 531
 532     case CONST_INT:
 533       if (letter == 'J')
 534         fprintf (file, "%d", -INTVAL (x));
 535       else if (letter == 'b')
 536         fprintf (file, "%d", which_bit (INTVAL (x)));
 537       else if (letter == 'B')
 538         fprintf (file, "%d", which_bit (~INTVAL (x)));
 539       else if (letter == 'w')
 540         fprintf (file, "%d", INTVAL (x) - 16);
 541       else
 542         fprintf (file, "%d", INTVAL (x));
 543       break;
 544
 545     case CODE_LABEL:
 546       fprintf (file, "L%d", XINT (x, 3));
 547       break;
 548
 549     case CALL:
 550       fprintf (file, "CALL nargs=%d, func is either '%s' or '%s'",
 551        XEXP (x, 1), XSTR (XEXP (XEXP (x, 0), 1), 0), XSTR (XEXP (x, 0), 1));
 552       break;
 553
 554     case PLUS:
 555       {
 556         rtx op0 = XEXP (x, 0), op1 = XEXP (x, 1);
 557         int op0code = GET_CODE (op0), op1code = GET_CODE (op1);
 558         if (op1code == CONST_INT)
 559           switch (op0code)
 560             {
 561             case REG:
 562               fprintf (file, "%d,r%d  ; p_o_PLUS for REG and CONST_INT",
 563                        INTVAL (op1), REGNO (op0));
 564               break;
 565             case SYMBOL_REF:
 566               fprintf (file, "%d+%s", INTVAL (op1), XSTR (op0, 0));
 567               break;
 568             case MEM:
 569               fprintf (file, "%d,[mem:", INTVAL (op1));
 570               output_address (XEXP (op0, 0));
 571               fprintf (file, "] ;P_O plus");
 572               break;
 573             default:
 574               fprintf (file, "p_o_PLUS UFO, code=%d, with CONST=%d",
 575                        (int) op0code, INTVAL (op1));
 576             }
 577         else if (op1code == SYMBOL_REF && op0code == REG)
 578           fprintf (file, "%s,r%d  ; P_O: (plus reg sym)",
 579                    XSTR (op1, 0), REGNO (op0));
 580         else
 581           fprintf (file, "p_o_+: op0code=%d, op1code=%d", op0code, op1code);
 582       }
 583       break;
 584
 585     default:
 586       fprintf (file, "p_o_UFO code=%d", GET_CODE (x));
 587     }
 588
 589   addr_inc = 0;
 590 }
 591
 592 print_operand_address (file, addr)
 593      FILE *file;
 594      rtx addr;
 595 {
 596   switch (GET_CODE (addr))
 597     {
 598     case REG:
 599       fprintf (file, "%d,r%d ; P_O_A", addr_inc, REGNO (addr));
 600       break;
 601     case PLUS:
 602       {
 603         register rtx x = XEXP (addr, 0), y = XEXP (addr, 1);
 604         switch (GET_CODE (x))
 605           {
 606           case REG:
 607             switch (GET_CODE (y))
 608               {
 609               case CONST:
 610                 output_address (XEXP (y, 0));
 611                 fprintf (file, ",r%d ;P_O_A reg + const expr", REGNO (x));
 612                 break;
 613               case CONST_INT:
 614                 fprintf (file, "%d,r%d", INTVAL (y) + addr_inc, REGNO (x));
 615                 break;
 616               case SYMBOL_REF:
 617                 fprintf (file, "%s", XSTR (y, 0));
 618                 if (addr_inc)
 619                   fprintf (file, "+%d", addr_inc);
 620                 fprintf (file, ",r%d  ; P_O_A reg + sym", REGNO (x));
 621                 break;
 622               case LABEL_REF:
 623                 output_address (XEXP (y, 0));
 624                 fprintf (file, ",r%d  ; P_O_A reg + label", REGNO (x));
 625                 break;
 626               default:
 627                 fprintf (file, "[P_O_A reg%d+UFO code=%d]",
 628                          REGNO (x), GET_CODE (y));
 629               }
 630             break;
 631           case LABEL_REF:
 632             output_address (XEXP (x, 0));
 633             break;
 634           case SYMBOL_REF:
 635             switch (GET_CODE (y))
 636               {
 637               case CONST_INT:
 638                 fprintf (file, "%d+%s", INTVAL (y) + addr_inc, XSTR (x, 0));
 639                 break;
 640               case REG:
 641                 fprintf (file, "%s,r%d ;P_O_A sym + reg",
 642                          XSTR (x, 0), REGNO (y));
 643                 break;
 644               default:
 645                 fprintf (file, "P_O_A sym/lab+UFO[sym=%s,code(y)=%d]",
 646                          XSTR (x, 0), GET_CODE (y));
 647               }
 648             break;
 649           case CONST:
 650             output_address (XEXP (x, 0));
 651             if (GET_CODE (y) == REG)
 652               fprintf (file, ",r%d ;P_O_A const + reg", REGNO (x));
 653             else
 654               fprintf (file, "P_O_A const+UFO code(y)=%d]", GET_CODE (y));
 655             break;
 656           case MEM:
 657             output_address (y);
 658             fprintf (file, ",[mem:");
 659             output_address (XEXP (x, 0));
 660             fprintf (file, "] ;P_O_A plus");
 661             break;
 662           default:
 663             fprintf (file, "P_O_A plus op1_UFO[code1=%d,code2=%d]",
 664                      GET_CODE (x), GET_CODE (y));
 665           }
 666       }
 667       break;
 668     case CONST_INT:
 669       if (INTVAL (addr) < 0x10000 && INTVAL (addr) >= -0x10000)
 670         fprintf (file, "%d ; p_o_a const addr?!", INTVAL (addr));
 671       else
 672         {
 673           fprintf (file, "[p_o_a=ILLEGAL_CONST]");
 674           output_addr_const (file, addr);
 675         }
 676       break;
 677     case LABEL_REF:
 678     case SYMBOL_REF:
 679       fprintf (file, "%s", XSTR (addr, 0));
 680       if (addr_inc)
 681         fprintf (file, "+%d", addr_inc);
 682       break;
 683     case MEM:
 684       fprintf (file, "[memUFO:");
 685       output_address (XEXP (addr, 0));
 686       fprintf (file, "]");
 687       break;
 688     case CONST:
 689       output_address (XEXP (addr, 0));
 690       fprintf (file, " ;P_O_A const");
 691       break;
 692     case CODE_LABEL:
 693       fprintf (file, "L%d", XINT (addr, 3));
 694       break;
 695     default:
 696       fprintf (file, " p_o_a UFO, code=%d val=0x%x",
 697                (int) GET_CODE (addr), INTVAL (addr));
 698       break;
 699     }
 700   addr_inc = 0;
 701 }
 702
 703
 704 /*
 705  *  Return non zero if the LS 16 bits of the given value has just one bit set,
 706  *  otherwise return zero. Note this function may be used to detect one
 707  *  bit clear by inverting the param.
 708  */
 709 int
 710 one_bit_set_p (x)
 711      int x;
 712 {
 713   x &= 0xffff;
 714   return x && (x & (x - 1)) == 0;
 715 }
 716
 717
 718 /*
 719  * Return the number of the least significant bit set, using the  same
 720  * convention for bit numbering as in the MIL-STD-1750 sb instruction.
 721  */
 722 int
 723 which_bit (x)
 724      int x;
 725 {
 726   int b = 15;
 727
 728   while (b > 0 && (x & 1) == 0)
 729     {
 730       b--;
 731       x >>= 1;
 732     }
 733
 734   return b;
 735 }
 736
 737