opcodes/ia64-opc.c

   1 /* ia64-opc.c -- Functions to access the compacted opcode table
   2    Copyright 1999, 2000, 2003 Free Software Foundation, Inc.
   3    Written by Bob Manson of Cygnus Solutions, <manson@cygnus.com>
   4
   5    This file is part of GDB, GAS, and the GNU binutils.
   6
   7    GDB, GAS, and the GNU binutils are free software; you can redistribute
   8    them and/or modify them under the terms of the GNU General Public
   9    License as published by the Free Software Foundation; either version
  10    2, or (at your option) any later version.
  11
  12    GDB, GAS, and the GNU binutils are distributed in the hope that they
  13    will be useful, but WITHOUT ANY WARRANTY; without even the implied
  14    warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15    the GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this file; see the file COPYING.  If not, write to the
  19    Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 #include "ansidecl.h"
  23 #include "libiberty.h"
  24 #include "sysdep.h"
  25 #include "ia64-asmtab.h"
  26 #include "ia64-asmtab.c"
  27
  28 static void get_opc_prefix (const char **, char *);
  29 static short int find_string_ent (const char *);
  30 static short int find_main_ent (short int);
  31 static short int find_completer (short int, short int, const char *);
  32 static ia64_insn apply_completer (ia64_insn, int);
  33 static int extract_op_bits (int, int, int);
  34 static int extract_op (int, int *, unsigned int *);
  35 static int opcode_verify (ia64_insn, int, enum ia64_insn_type);
  36 static int locate_opcode_ent (ia64_insn, enum ia64_insn_type);
  37 static struct ia64_opcode *make_ia64_opcode
  38   (ia64_insn, const char *, int, int);
  39 static struct ia64_opcode *ia64_find_matching_opcode
  40   (const char *, short int);
  41
  42 const struct ia64_templ_desc ia64_templ_desc[16] =
  43   {
  44     { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" },    /* 0 */
  45     { 2, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" },
  46     { 0, { IA64_UNIT_M, IA64_UNIT_L, IA64_UNIT_X }, "MLX" },
  47     { 0, { 0, },                                    "-3-" },
  48     { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" },    /* 4 */
  49     { 1, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" },
  50     { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_I }, "MFI" },
  51     { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_F }, "MMF" },
  52     { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_B }, "MIB" },    /* 8 */
  53     { 0, { IA64_UNIT_M, IA64_UNIT_B, IA64_UNIT_B }, "MBB" },
  54     { 0, { 0, },                                    "-a-" },
  55     { 0, { IA64_UNIT_B, IA64_UNIT_B, IA64_UNIT_B }, "BBB" },
  56     { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_B }, "MMB" },    /* c */
  57     { 0, { 0, },                                    "-d-" },
  58     { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_B }, "MFB" },
  59     { 0, { 0, },                                    "-f-" },
  60   };
  61
  62
  63 /* Copy the prefix contained in *PTR (up to a '.' or a NUL) to DEST.
  64    PTR will be adjusted to point to the start of the next portion
  65    of the opcode, or at the NUL character. */
  66
  67 static void
  68 get_opc_prefix (const char **ptr, char *dest)
  69 {
  70   char *c = strchr (*ptr, '.');
  71   if (c != NULL)
  72     {
  73       memcpy (dest, *ptr, c - *ptr);
  74       dest[c - *ptr] = '\0';
  75       *ptr = c + 1;
  76     }
  77   else
  78     {
  79       int l = strlen (*ptr);
  80       memcpy (dest, *ptr, l);
  81       dest[l] = '\0';
  82       *ptr += l;
  83     }
  84 }
  85 \f
  86 /* Find the index of the entry in the string table corresponding to
  87    STR; return -1 if one does not exist. */
  88
  89 static short
  90 find_string_ent (const char *str)
  91 {
  92   short start = 0;
  93   short end = sizeof (ia64_strings) / sizeof (const char *);
  94   short i = (start + end) / 2;
  95
  96   if (strcmp (str, ia64_strings[end - 1]) > 0)
  97     {
  98       return -1;
  99     }
 100   while (start <= end)
 101     {
 102       int c = strcmp (str, ia64_strings[i]);
 103       if (c < 0)
 104         {
 105           end = i - 1;
 106         }
 107       else if (c == 0)
 108         {
 109           return i;
 110         }
 111       else
 112         {
 113           start = i + 1;
 114         }
 115       i = (start + end) / 2;
 116     }
 117   return -1;
 118 }
 119 \f
 120 /* Find the opcode in the main opcode table whose name is STRINGINDEX, or
 121    return -1 if one does not exist. */
 122
 123 static short
 124 find_main_ent (short nameindex)
 125 {
 126   short start = 0;
 127   short end = sizeof (main_table) / sizeof (struct ia64_main_table);
 128   short i = (start + end) / 2;
 129
 130   if (nameindex < main_table[0].name_index
 131       || nameindex > main_table[end - 1].name_index)
 132     {
 133       return -1;
 134     }
 135   while (start <= end)
 136     {
 137       if (nameindex < main_table[i].name_index)
 138         {
 139           end = i - 1;
 140         }
 141       else if (nameindex == main_table[i].name_index)
 142         {
 143           while (i > 0 && main_table[i - 1].name_index == nameindex)
 144             {
 145               i--;
 146             }
 147           return i;
 148         }
 149       else
 150         {
 151           start = i + 1;
 152         }
 153       i = (start + end) / 2;
 154     }
 155   return -1;
 156 }
 157 \f
 158 /* Find the index of the entry in the completer table that is part of
 159    MAIN_ENT (starting from PREV_COMPLETER) that matches NAME, or
 160    return -1 if one does not exist. */
 161
 162 static short
 163 find_completer (short main_ent, short prev_completer, const char *name)
 164 {
 165   short name_index = find_string_ent (name);
 166
 167   if (name_index < 0)
 168     {
 169       return -1;
 170     }
 171
 172   if (prev_completer == -1)
 173     {
 174       prev_completer = main_table[main_ent].completers;
 175     }
 176   else
 177     {
 178       prev_completer = completer_table[prev_completer].subentries;
 179     }
 180
 181   while (prev_completer != -1)
 182     {
 183       if (completer_table[prev_completer].name_index == name_index)
 184         {
 185           return prev_completer;
 186         }
 187       prev_completer = completer_table[prev_completer].alternative;
 188     }
 189   return -1;
 190 }
 191 \f
 192 /* Apply the completer referred to by COMPLETER_INDEX to OPCODE, and
 193    return the result. */
 194
 195 static ia64_insn
 196 apply_completer (ia64_insn opcode, int completer_index)
 197 {
 198   ia64_insn mask = completer_table[completer_index].mask;
 199   ia64_insn bits = completer_table[completer_index].bits;
 200   int shiftamt = (completer_table[completer_index].offset & 63);
 201
 202   mask = mask << shiftamt;
 203   bits = bits << shiftamt;
 204   opcode = (opcode & ~mask) | bits;
 205   return opcode;
 206 }
 207 \f
 208 /* Extract BITS number of bits starting from OP_POINTER + BITOFFSET in
 209    the dis_table array, and return its value.  (BITOFFSET is numbered
 210    starting from MSB to LSB, so a BITOFFSET of 0 indicates the MSB of the
 211    first byte in OP_POINTER.) */
 212
 213 static int
 214 extract_op_bits (int op_pointer, int bitoffset, int bits)
 215 {
 216   int res = 0;
 217
 218   op_pointer += (bitoffset / 8);
 219
 220   if (bitoffset % 8)
 221     {
 222       unsigned int op = dis_table[op_pointer++];
 223       int numb = 8 - (bitoffset % 8);
 224       int mask = (1 << numb) - 1;
 225       int bata = (bits < numb) ? bits : numb;
 226       int delta = numb - bata;
 227
 228       res = (res << bata) | ((op & mask) >> delta);
 229       bitoffset += bata;
 230       bits -= bata;
 231     }
 232   while (bits >= 8)
 233     {
 234       res = (res << 8) | (dis_table[op_pointer++] & 255);
 235       bits -= 8;
 236     }
 237   if (bits > 0)
 238     {
 239       unsigned int op = (dis_table[op_pointer++] & 255);
 240       res = (res << bits) | (op >> (8 - bits));
 241     }
 242   return res;
 243 }
 244 \f
 245 /* Examine the state machine entry at OP_POINTER in the dis_table
 246    array, and extract its values into OPVAL and OP.  The length of the
 247    state entry in bits is returned. */
 248
 249 static int
 250 extract_op (int op_pointer, int *opval, unsigned int *op)
 251 {
 252   int oplen = 5;
 253
 254   *op = dis_table[op_pointer];
 255
 256   if ((*op) & 0x40)
 257     {
 258       opval[0] = extract_op_bits (op_pointer, oplen, 5);
 259       oplen += 5;
 260     }
 261   switch ((*op) & 0x30)
 262     {
 263     case 0x10:
 264       {
 265         opval[1] = extract_op_bits (op_pointer, oplen, 8);
 266         oplen += 8;
 267         opval[1] += op_pointer;
 268         break;
 269       }
 270     case 0x20:
 271       {
 272         opval[1] = extract_op_bits (op_pointer, oplen, 16);
 273         if (! (opval[1] & 32768))
 274           {
 275             opval[1] += op_pointer;
 276           }
 277         oplen += 16;
 278         break;
 279       }
 280     case 0x30:
 281       {
 282         oplen--;
 283         opval[2] = extract_op_bits (op_pointer, oplen, 12);
 284         oplen += 12;
 285         opval[2] |= 32768;
 286         break;
 287       }
 288     }
 289   if (((*op) & 0x08) && (((*op) & 0x30) != 0x30))
 290     {
 291       opval[2] = extract_op_bits (op_pointer, oplen, 16);
 292       oplen += 16;
 293       if (! (opval[2] & 32768))
 294         {
 295           opval[2] += op_pointer;
 296         }
 297     }
 298   return oplen;
 299 }
 300 \f
 301 /* Returns a non-zero value if the opcode in the main_table list at
 302    PLACE matches OPCODE and is of type TYPE. */
 303
 304 static int
 305 opcode_verify (ia64_insn opcode, int place, enum ia64_insn_type type)
 306 {
 307   if (main_table[place].opcode_type != type)
 308     {
 309       return 0;
 310     }
 311   if (main_table[place].flags
 312       & (IA64_OPCODE_F2_EQ_F3 | IA64_OPCODE_LEN_EQ_64MCNT))
 313     {
 314       const struct ia64_operand *o1, *o2;
 315       ia64_insn f2, f3;
 316
 317       if (main_table[place].flags & IA64_OPCODE_F2_EQ_F3)
 318         {
 319           o1 = elf64_ia64_operands + IA64_OPND_F2;
 320           o2 = elf64_ia64_operands + IA64_OPND_F3;
 321           (*o1->extract) (o1, opcode, &f2);
 322           (*o2->extract) (o2, opcode, &f3);
 323           if (f2 != f3)
 324             return 0;
 325         }
 326       else
 327         {
 328           ia64_insn len, count;
 329
 330           /* length must equal 64-count: */
 331           o1 = elf64_ia64_operands + IA64_OPND_LEN6;
 332           o2 = elf64_ia64_operands + main_table[place].operands[2];
 333           (*o1->extract) (o1, opcode, &len);
 334           (*o2->extract) (o2, opcode, &count);
 335           if (len != 64 - count)
 336             return 0;
 337         }
 338     }
 339   return 1;
 340 }
 341 \f
 342 /* Find an instruction entry in the ia64_dis_names array that matches
 343    opcode OPCODE and is of type TYPE.  Returns either a positive index
 344    into the array, or a negative value if an entry for OPCODE could
 345    not be found.  Checks all matches and returns the one with the highest
 346    priority. */
 347
 348 static int
 349 locate_opcode_ent (ia64_insn opcode, enum ia64_insn_type type)
 350 {
 351   int currtest[41];
 352   int bitpos[41];
 353   int op_ptr[41];
 354   int currstatenum = 0;
 355   short found_disent = -1;
 356   short found_priority = -1;
 357
 358   currtest[currstatenum] = 0;
 359   op_ptr[currstatenum] = 0;
 360   bitpos[currstatenum] = 40;
 361
 362   while (1)
 363     {
 364       int op_pointer = op_ptr[currstatenum];
 365       unsigned int op;
 366       int currbitnum = bitpos[currstatenum];
 367       int oplen;
 368       int opval[3];
 369       int next_op;
 370       int currbit;
 371
 372       oplen = extract_op (op_pointer, opval, &op);
 373
 374       bitpos[currstatenum] = currbitnum;
 375
 376       /* Skip opval[0] bits in the instruction. */
 377       if (op & 0x40)
 378         {
 379           currbitnum -= opval[0];
 380         }
 381
 382       /* The value of the current bit being tested. */
 383       currbit = opcode & (((ia64_insn) 1) << currbitnum) ? 1 : 0;
 384       next_op = -1;
 385
 386       /* We always perform the tests specified in the current state in
 387          a particular order, falling through to the next test if the
 388          previous one failed. */
 389       switch (currtest[currstatenum])
 390         {
 391         case 0:
 392           currtest[currstatenum]++;
 393           if (currbit == 0 && (op & 0x80))
 394             {
 395               /* Check for a zero bit.  If this test solely checks for
 396                  a zero bit, we can check for up to 8 consecutive zero
 397                  bits (the number to check is specified by the lower 3
 398                  bits in the state code.)
 399
 400                  If the state instruction matches, we go to the very
 401                  next state instruction; otherwise, try the next test. */
 402
 403               if ((op & 0xf8) == 0x80)
 404                 {
 405                   int count = op & 0x7;
 406                   int x;
 407
 408                   for (x = 0; x <= count; x++)
 409                     {
 410                       int i =
 411                         opcode & (((ia64_insn) 1) << (currbitnum - x)) ? 1 : 0;
 412                       if (i)
 413                         {
 414                           break;
 415                         }
 416                     }
 417                   if (x > count)
 418                     {
 419                       next_op = op_pointer + ((oplen + 7) / 8);
 420                       currbitnum -= count;
 421                       break;
 422                     }
 423                 }
 424               else if (! currbit)
 425                 {
 426                   next_op = op_pointer + ((oplen + 7) / 8);
 427                   break;
 428                 }
 429             }
 430           /* FALLTHROUGH */
 431         case 1:
 432           /* If the bit in the instruction is one, go to the state
 433              instruction specified by opval[1]. */
 434           currtest[currstatenum]++;
 435           if (currbit && (op & 0x30) != 0 && ((op & 0x30) != 0x30))
 436             {
 437               next_op = opval[1];
 438               break;
 439             }
 440           /* FALLTHROUGH */
 441         case 2:
 442           /* Don't care.  Skip the current bit and go to the state
 443              instruction specified by opval[2].
 444
 445              An encoding of 0x30 is special; this means that a 12-bit
 446              offset into the ia64_dis_names[] array is specified.  */
 447           currtest[currstatenum]++;
 448           if ((op & 0x08) || ((op & 0x30) == 0x30))
 449             {
 450               next_op = opval[2];
 451               break;
 452             }
 453         }
 454
 455       /* If bit 15 is set in the address of the next state, an offset
 456          in the ia64_dis_names array was specified instead.  We then
 457          check to see if an entry in the list of opcodes matches the
 458          opcode we were given; if so, we have succeeded.  */
 459
 460       if ((next_op >= 0) && (next_op & 32768))
 461         {
 462           short disent = next_op & 32767;
 463           short priority = -1;
 464
 465           if (next_op > 65535)
 466             {
 467               abort ();
 468             }
 469
 470           /* Run through the list of opcodes to check, trying to find
 471              one that matches.  */
 472           while (disent >= 0)
 473             {
 474               int place = ia64_dis_names[disent].insn_index;
 475
 476               priority = ia64_dis_names[disent].priority;
 477
 478               if (opcode_verify (opcode, place, type)
 479                   && priority > found_priority)
 480                 {
 481                   break;
 482                 }
 483               if (ia64_dis_names[disent].next_flag)
 484                 {
 485                   disent++;
 486                 }
 487               else
 488                 {
 489                   disent = -1;
 490                 }
 491             }
 492
 493           if (disent >= 0)
 494             {
 495               found_disent = disent;
 496               found_priority = priority;
 497             }
 498           /* Try the next test in this state, regardless of whether a match
 499              was found. */
 500           next_op = -2;
 501         }
 502
 503       /* next_op == -1 is "back up to the previous state".
 504          next_op == -2 is "stay in this state and try the next test".
 505          Otherwise, transition to the state indicated by next_op. */
 506
 507       if (next_op == -1)
 508         {
 509           currstatenum--;
 510           if (currstatenum < 0)
 511             {
 512               return found_disent;
 513             }
 514         }
 515       else if (next_op >= 0)
 516         {
 517           currstatenum++;
 518           bitpos[currstatenum] = currbitnum - 1;
 519           op_ptr[currstatenum] = next_op;
 520           currtest[currstatenum] = 0;
 521         }
 522     }
 523 }
 524 \f
 525 /* Construct an ia64_opcode entry based on OPCODE, NAME and PLACE. */
 526
 527 static struct ia64_opcode *
 528 make_ia64_opcode (ia64_insn opcode, const char *name, int place, int depind)
 529 {
 530   struct ia64_opcode *res =
 531     (struct ia64_opcode *) xmalloc (sizeof (struct ia64_opcode));
 532   res->name = xstrdup (name);
 533   res->type = main_table[place].opcode_type;
 534   res->num_outputs = main_table[place].num_outputs;
 535   res->opcode = opcode;
 536   res->mask = main_table[place].mask;
 537   res->operands[0] = main_table[place].operands[0];
 538   res->operands[1] = main_table[place].operands[1];
 539   res->operands[2] = main_table[place].operands[2];
 540   res->operands[3] = main_table[place].operands[3];
 541   res->operands[4] = main_table[place].operands[4];
 542   res->flags = main_table[place].flags;
 543   res->ent_index = place;
 544   res->dependencies = &op_dependencies[depind];
 545   return res;
 546 }
 547 \f
 548 /* Determine the ia64_opcode entry for the opcode specified by INSN
 549    and TYPE.  If a valid entry is not found, return NULL. */
 550 struct ia64_opcode *
 551 ia64_dis_opcode (ia64_insn insn, enum ia64_insn_type type)
 552 {
 553   int disent = locate_opcode_ent (insn, type);
 554
 555   if (disent < 0)
 556     {
 557       return NULL;
 558     }
 559   else
 560     {
 561       unsigned int cb = ia64_dis_names[disent].completer_index;
 562       static char name[128];
 563       int place = ia64_dis_names[disent].insn_index;
 564       int ci = main_table[place].completers;
 565       ia64_insn tinsn = main_table[place].opcode;
 566
 567       strcpy (name, ia64_strings [main_table[place].name_index]);
 568
 569       while (cb)
 570         {
 571           if (cb & 1)
 572             {
 573               int cname = completer_table[ci].name_index;
 574
 575               tinsn = apply_completer (tinsn, ci);
 576
 577               if (ia64_strings[cname][0] != '\0')
 578                 {
 579                   strcat (name, ".");
 580                   strcat (name, ia64_strings[cname]);
 581                 }
 582               if (cb != 1)
 583                 {
 584                   ci = completer_table[ci].subentries;
 585                 }
 586             }
 587           else
 588             {
 589               ci = completer_table[ci].alternative;
 590             }
 591           if (ci < 0)
 592             {
 593               abort ();
 594             }
 595           cb = cb >> 1;
 596         }
 597       if (tinsn != (insn & main_table[place].mask))
 598         {
 599           abort ();
 600         }
 601       return make_ia64_opcode (insn, name, place,
 602                                completer_table[ci].dependencies);
 603     }
 604 }
 605 \f
 606 /* Search the main_opcode table starting from PLACE for an opcode that
 607    matches NAME.  Return NULL if one is not found. */
 608
 609 static struct ia64_opcode *
 610 ia64_find_matching_opcode (const char *name, short place)
 611 {
 612   char op[129];
 613   const char *suffix;
 614   short name_index;
 615
 616   if (strlen (name) > 128)
 617     {
 618       return NULL;
 619     }
 620   suffix = name;
 621   get_opc_prefix (&suffix, op);
 622   name_index = find_string_ent (op);
 623   if (name_index < 0)
 624     {
 625       return NULL;
 626     }
 627
 628   while (main_table[place].name_index == name_index)
 629     {
 630       const char *curr_suffix = suffix;
 631       ia64_insn curr_insn = main_table[place].opcode;
 632       short completer = -1;
 633
 634       do {
 635         if (suffix[0] == '\0')
 636           {
 637             completer = find_completer (place, completer, suffix);
 638           }
 639         else
 640           {
 641             get_opc_prefix (&curr_suffix, op);
 642             completer = find_completer (place, completer, op);
 643           }
 644         if (completer != -1)
 645           {
 646             curr_insn = apply_completer (curr_insn, completer);
 647           }
 648       } while (completer != -1 && curr_suffix[0] != '\0');
 649
 650       if (completer != -1 && curr_suffix[0] == '\0'
 651           && completer_table[completer].terminal_completer)
 652         {
 653           int depind = completer_table[completer].dependencies;
 654           return make_ia64_opcode (curr_insn, name, place, depind);
 655         }
 656       else
 657         {
 658           place++;
 659         }
 660     }
 661   return NULL;
 662 }
 663 \f
 664 /* Find the next opcode after PREV_ENT that matches PREV_ENT, or return NULL
 665    if one does not exist.
 666
 667    It is the caller's responsibility to invoke ia64_free_opcode () to
 668    release any resources used by the returned entry. */
 669
 670 struct ia64_opcode *
 671 ia64_find_next_opcode (struct ia64_opcode *prev_ent)
 672 {
 673   return ia64_find_matching_opcode (prev_ent->name,
 674                                     prev_ent->ent_index + 1);
 675 }
 676
 677 /* Find the first opcode that matches NAME, or return NULL if it does
 678    not exist.
 679
 680    It is the caller's responsibility to invoke ia64_free_opcode () to
 681    release any resources used by the returned entry. */
 682
 683 struct ia64_opcode *
 684 ia64_find_opcode (const char *name)
 685 {
 686   char op[129];
 687   const char *suffix;
 688   short place;
 689   short name_index;
 690
 691   if (strlen (name) > 128)
 692     {
 693       return NULL;
 694     }
 695   suffix = name;
 696   get_opc_prefix (&suffix, op);
 697   name_index = find_string_ent (op);
 698   if (name_index < 0)
 699     {
 700       return NULL;
 701     }
 702
 703   place = find_main_ent (name_index);
 704
 705   if (place < 0)
 706     {
 707       return NULL;
 708     }
 709   return ia64_find_matching_opcode (name, place);
 710 }
 711
 712 /* Free any resources used by ENT. */
 713 void
 714 ia64_free_opcode (struct ia64_opcode *ent)
 715 {
 716   free ((void *)ent->name);
 717   free (ent);
 718 }
 719
 720 const struct ia64_dependency *
 721 ia64_find_dependency (int index)
 722 {
 723   index = DEP(index);
 724
 725   if (index < 0
 726       || index >= (int)(sizeof(dependencies) / sizeof(dependencies[0])))
 727     return NULL;
 728
 729   return &dependencies[index];
 730 }