gdb/m68k-pinsn.c

   1 /* Print Motorola 68k instructions for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <stdio.h>
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "opcode/m68k.h"
  25 #include "gdbcore.h"
  26
  27 /* Local function prototypes */
  28
  29 static int
  30 fetch_arg PARAMS ((unsigned char *, int, int));
  31
  32 static void
  33 print_base PARAMS ((int, int, FILE *));
  34
  35 static unsigned char *
  36 print_indexed PARAMS ((int, unsigned char *, CORE_ADDR, FILE *));
  37
  38 static unsigned char *
  39 print_insn_arg PARAMS ((char *, unsigned char *, unsigned char *, CORE_ADDR,
  40                         FILE *));
  41
  42 /* 68k instructions are never longer than this many bytes.  */
  43 #define MAXLEN 22
  44
  45 /* Number of elements in the opcode table.  */
  46 #define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
  47
  48 extern char *reg_names[];
  49 char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
  50                      "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
  51
  52
  53 #define NEXTBYTE(p)  (p += 2, ((char *)p)[-1])
  54
  55 #define NEXTWORD(p)  \
  56   (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
  57
  58 #define NEXTLONG(p)  \
  59   (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
  60
  61 #define NEXTSINGLE(p) \
  62   (p += 4, *((float *)(p - 4)))
  63
  64 #define NEXTDOUBLE(p) \
  65   (p += 8, *((double *)(p - 8)))
  66
  67 #define NEXTEXTEND(p) \
  68   (p += 12, 0.0)        /* Need a function to convert from extended to double
  69                            precision... */
  70
  71 #define NEXTPACKED(p) \
  72   (p += 12, 0.0)        /* Need a function to convert from packed to double
  73                            precision.   Actually, it's easier to print a
  74                            packed number than a double anyway, so maybe
  75                            there should be a special case to handle this... */
  76 \f
  77 /* Print the m68k instruction at address MEMADDR in debugged memory,
  78    on STREAM.  Returns length of the instruction, in bytes.  */
  79
  80 int
  81 print_insn (memaddr, stream)
  82      CORE_ADDR memaddr;
  83      FILE *stream;
  84 {
  85   unsigned char buffer[MAXLEN];
  86   register int i;
  87   register unsigned char *p;
  88   register char *d;
  89   register int bestmask;
  90   int best;
  91
  92   read_memory (memaddr, (char *) buffer, MAXLEN);
  93
  94   bestmask = 0;
  95   best = -1;
  96   for (i = 0; i < NOPCODES; i++)
  97     {
  98       register unsigned int opcode = m68k_opcodes[i].opcode;
  99       register unsigned int match = m68k_opcodes[i].match;
 100       if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
 101           && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
 102           && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
 103           && ((0xff & buffer[3] & match) == (0xff & opcode)))
 104         {
 105           /* Don't use for printout the variants of divul and divsl
 106              that have the same register number in two places.
 107              The more general variants will match instead.  */
 108           for (d = m68k_opcodes[i].args; *d; d += 2)
 109             if (d[1] == 'D')
 110               break;
 111
 112           /* Don't use for printout the variants of most floating
 113              point coprocessor instructions which use the same
 114              register number in two places, as above. */
 115           if (*d == 0)
 116             for (d = m68k_opcodes[i].args; *d; d += 2)
 117               if (d[1] == 't')
 118                 break;
 119
 120           if (*d == 0 && match > bestmask)
 121             {
 122               best = i;
 123               bestmask = match;
 124             }
 125         }
 126     }
 127
 128   /* Handle undefined instructions.  */
 129   if (best < 0)
 130     {
 131       fprintf_filtered (stream, "0%o", (buffer[0] << 8) + buffer[1]);
 132       return 2;
 133     }
 134
 135   fprintf_filtered (stream, "%s", m68k_opcodes[best].name);
 136
 137   /* Point at first word of argument data,
 138      and at descriptor for first argument.  */
 139   p = buffer + 2;
 140
 141   /* Why do this this way? -MelloN */
 142   for (d = m68k_opcodes[best].args; *d; d += 2)
 143     {
 144       if (d[0] == '#')
 145         {
 146           if (d[1] == 'l' && p - buffer < 6)
 147             p = buffer + 6;
 148           else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
 149             p = buffer + 4;
 150         }
 151       if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
 152         p = buffer + 4;
 153       if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
 154         p = buffer + 6;
 155       if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
 156         p = buffer + 4;
 157     }
 158
 159   d = m68k_opcodes[best].args;
 160
 161   if (*d)
 162     fputs_filtered (" ", stream);
 163
 164   while (*d)
 165     {
 166       p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
 167       d += 2;
 168       if (*d && *(d - 2) != 'I' && *d != 'k')
 169         fputs_filtered (",", stream);
 170     }
 171   return p - buffer;
 172 }
 173
 174 static unsigned char *
 175 print_insn_arg (d, buffer, p, addr, stream)
 176      char *d;
 177      unsigned char *buffer;
 178      register unsigned char *p;
 179      CORE_ADDR addr;            /* PC for this arg to be relative to */
 180      FILE *stream;
 181 {
 182   register int val;
 183   register int place = d[1];
 184   int regno;
 185   register char *regname;
 186   register unsigned char *p1;
 187   register double flval;
 188   int flt_p;
 189
 190   switch (*d)
 191     {
 192     case 'C':
 193       fprintf_filtered (stream, "ccr");
 194       break;
 195
 196     case 'S':
 197       fprintf_filtered (stream, "sr");
 198       break;
 199
 200     case 'U':
 201       fprintf_filtered (stream, "usp");
 202       break;
 203
 204     case 'J':
 205       {
 206         static struct { char *name; int value; } names[]
 207           = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
 208              {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
 209              {"msp", 0x803}, {"isp", 0x804}};
 210
 211         val = fetch_arg (buffer, place, 12);
 212         for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
 213           if (names[regno].value == val)
 214             {
 215               fprintf_filtered (stream, names[regno].name);
 216               break;
 217             }
 218         if (regno < 0)
 219           fprintf_filtered (stream, "%d", val);
 220       }
 221       break;
 222
 223     case 'Q':
 224       val = fetch_arg (buffer, place, 3);
 225       /* 0 means 8, except for the bkpt instruction... */
 226       if (val == 0 && d[1] != 's')
 227         val = 8;
 228       fprintf_filtered (stream, "#%d", val);
 229       break;
 230
 231     case 'M':
 232       val = fetch_arg (buffer, place, 8);
 233       if (val & 0x80)
 234         val = val - 0x100;
 235       fprintf_filtered (stream, "#%d", val);
 236       break;
 237
 238     case 'T':
 239       val = fetch_arg (buffer, place, 4);
 240       fprintf_filtered (stream, "#%d", val);
 241       break;
 242
 243     case 'D':
 244       fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
 245       break;
 246
 247     case 'A':
 248       fprintf_filtered (stream, "%s",
 249                         reg_names[fetch_arg (buffer, place, 3) + 010]);
 250       break;
 251
 252     case 'R':
 253       fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
 254       break;
 255
 256     case 'F':
 257       fprintf_filtered (stream, "fp%d", fetch_arg (buffer, place, 3));
 258       break;
 259
 260     case 'O':
 261       val = fetch_arg (buffer, place, 6);
 262       if (val & 0x20)
 263         fprintf_filtered (stream, "%s", reg_names [val & 7]);
 264       else
 265         fprintf_filtered (stream, "%d", val);
 266       break;
 267
 268     case '+':
 269       fprintf_filtered (stream, "%s@+",
 270                         reg_names[fetch_arg (buffer, place, 3) + 8]);
 271       break;
 272
 273     case '-':
 274       fprintf_filtered (stream, "%s@-",
 275                reg_names[fetch_arg (buffer, place, 3) + 8]);
 276       break;
 277
 278     case 'k':
 279       if (place == 'k')
 280         fprintf_filtered (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
 281       else if (place == 'C')
 282         {
 283           val = fetch_arg (buffer, place, 7);
 284           if ( val > 63 )               /* This is a signed constant. */
 285             val -= 128;
 286           fprintf_filtered (stream, "{#%d}", val);
 287         }
 288       else
 289         error ("Invalid arg format in opcode table: \"%c%c\".",
 290                *d, place);
 291       break;
 292
 293     case '#':
 294     case '^':
 295       p1 = buffer + (*d == '#' ? 2 : 4);
 296       if (place == 's')
 297         val = fetch_arg (buffer, place, 4);
 298       else if (place == 'C')
 299         val = fetch_arg (buffer, place, 7);
 300       else if (place == '8')
 301         val = fetch_arg (buffer, place, 3);
 302       else if (place == '3')
 303         val = fetch_arg (buffer, place, 8);
 304       else if (place == 'b')
 305         val = NEXTBYTE (p1);
 306       else if (place == 'w')
 307         val = NEXTWORD (p1);
 308       else if (place == 'l')
 309         val = NEXTLONG (p1);
 310       else
 311         error ("Invalid arg format in opcode table: \"%c%c\".",
 312                *d, place);
 313       fprintf_filtered (stream, "#%d", val);
 314       break;
 315
 316     case 'B':
 317       if (place == 'b')
 318         val = NEXTBYTE (p);
 319       else if (place == 'B')
 320         val = buffer[1];
 321       else if (place == 'w' || place == 'W')
 322         val = NEXTWORD (p);
 323       else if (place == 'l' || place == 'L')
 324         val = NEXTLONG (p);
 325       else if (place == 'g')
 326         {
 327           val = ((char *)buffer)[1];
 328           if (val == 0)
 329             val = NEXTWORD (p);
 330           else if (val == -1)
 331             val = NEXTLONG (p);
 332         }
 333       else if (place == 'c')
 334         {
 335           if (buffer[1] & 0x40)         /* If bit six is one, long offset */
 336             val = NEXTLONG (p);
 337           else
 338             val = NEXTWORD (p);
 339         }
 340       else
 341         error ("Invalid arg format in opcode table: \"%c%c\".",
 342                *d, place);
 343
 344       print_address (addr + val, stream);
 345       break;
 346
 347     case 'd':
 348       val = NEXTWORD (p);
 349       fprintf_filtered (stream, "%s@(%d)",
 350                         reg_names[fetch_arg (buffer, place, 3)], val);
 351       break;
 352
 353     case 's':
 354       fprintf_filtered (stream, "%s",
 355                         fpcr_names[fetch_arg (buffer, place, 3)]);
 356       break;
 357
 358     case 'I':
 359       val = fetch_arg (buffer, 'd', 3);           /* Get coprocessor ID... */
 360       if (val != 1)                             /* Unusual coprocessor ID? */
 361         fprintf_filtered (stream, "(cpid=%d) ", val);
 362       if (place == 'i')
 363         p += 2;                      /* Skip coprocessor extended operands */
 364       break;
 365
 366     case '*':
 367     case '~':
 368     case '%':
 369     case ';':
 370     case '@':
 371     case '!':
 372     case '$':
 373     case '?':
 374     case '/':
 375     case '&':
 376
 377       if (place == 'd')
 378         {
 379           val = fetch_arg (buffer, 'x', 6);
 380           val = ((val & 7) << 3) + ((val >> 3) & 7);
 381         }
 382       else
 383         val = fetch_arg (buffer, 's', 6);
 384
 385       /* Get register number assuming address register.  */
 386       regno = (val & 7) + 8;
 387       regname = reg_names[regno];
 388       switch (val >> 3)
 389         {
 390         case 0:
 391           fprintf_filtered (stream, "%s", reg_names[val]);
 392           break;
 393
 394         case 1:
 395           fprintf_filtered (stream, "%s", regname);
 396           break;
 397
 398         case 2:
 399           fprintf_filtered (stream, "%s@", regname);
 400           break;
 401
 402         case 3:
 403           fprintf_filtered (stream, "%s@+", regname);
 404           break;
 405
 406         case 4:
 407           fprintf_filtered (stream, "%s@-", regname);
 408           break;
 409
 410         case 5:
 411           val = NEXTWORD (p);
 412           fprintf_filtered (stream, "%s@(%d)", regname, val);
 413           break;
 414
 415         case 6:
 416           p = print_indexed (regno, p, addr, stream);
 417           break;
 418
 419         case 7:
 420           switch (val & 7)
 421             {
 422             case 0:
 423               val = NEXTWORD (p);
 424               fprintf_filtered (stream, "@#");
 425               print_address (val, stream);
 426               break;
 427
 428             case 1:
 429               val = NEXTLONG (p);
 430               fprintf_filtered (stream, "@#");
 431               print_address (val, stream);
 432               break;
 433
 434             case 2:
 435               val = NEXTWORD (p);
 436               print_address (addr + val, stream);
 437               break;
 438
 439             case 3:
 440               p = print_indexed (-1, p, addr, stream);
 441               break;
 442
 443             case 4:
 444               flt_p = 1;        /* Assume it's a float... */
 445               switch( place )
 446               {
 447                 case 'b':
 448                   val = NEXTBYTE (p);
 449                   flt_p = 0;
 450                   break;
 451
 452                 case 'w':
 453                   val = NEXTWORD (p);
 454                   flt_p = 0;
 455                   break;
 456
 457                 case 'l':
 458                   val = NEXTLONG (p);
 459                   flt_p = 0;
 460                   break;
 461
 462                 case 'f':
 463                   flval = NEXTSINGLE(p);
 464                   break;
 465
 466                 case 'F':
 467                   flval = NEXTDOUBLE(p);
 468                   break;
 469
 470                 case 'x':
 471                   flval = NEXTEXTEND(p);
 472                   break;
 473
 474                 case 'p':
 475                   flval = NEXTPACKED(p);
 476                   break;
 477
 478                 default:
 479                   error ("Invalid arg format in opcode table: \"%c%c\".",
 480                        *d, place);
 481               }
 482               if ( flt_p )      /* Print a float? */
 483                 fprintf_filtered (stream, "#%g", flval);
 484               else
 485                 fprintf_filtered (stream, "#%d", val);
 486               break;
 487
 488             default:
 489               fprintf_filtered (stream, "<invalid address mode 0%o>", val);
 490             }
 491         }
 492       break;
 493
 494     case 'L':
 495     case 'l':
 496         if (place == 'w')
 497           {
 498             char doneany;
 499             p1 = buffer + 2;
 500             val = NEXTWORD (p1);
 501             /* Move the pointer ahead if this point is farther ahead
 502                than the last.  */
 503             p = p1 > p ? p1 : p;
 504             if (val == 0)
 505               {
 506                 fputs_filtered ("#0", stream);
 507                 break;
 508               }
 509             if (*d == 'l')
 510               {
 511                 register int newval = 0;
 512                 for (regno = 0; regno < 16; ++regno)
 513                   if (val & (0x8000 >> regno))
 514                     newval |= 1 << regno;
 515                 val = newval;
 516               }
 517             val &= 0xffff;
 518             doneany = 0;
 519             for (regno = 0; regno < 16; ++regno)
 520               if (val & (1 << regno))
 521                 {
 522                   int first_regno;
 523                   if (doneany)
 524                     fputs_filtered ("/", stream);
 525                   doneany = 1;
 526                   fprintf_filtered (stream, "%s", reg_names[regno]);
 527                   first_regno = regno;
 528                   while (val & (1 << (regno + 1)))
 529                     ++regno;
 530                   if (regno > first_regno)
 531                     fprintf_filtered (stream, "-%s", reg_names[regno]);
 532                 }
 533           }
 534         else if (place == '3')
 535           {
 536             /* `fmovem' insn.  */
 537             char doneany;
 538             val = fetch_arg (buffer, place, 8);
 539             if (val == 0)
 540               {
 541                 fputs_filtered ("#0", stream);
 542                 break;
 543               }
 544             if (*d == 'l')
 545               {
 546                 register int newval = 0;
 547                 for (regno = 0; regno < 8; ++regno)
 548                   if (val & (0x80 >> regno))
 549                     newval |= 1 << regno;
 550                 val = newval;
 551               }
 552             val &= 0xff;
 553             doneany = 0;
 554             for (regno = 0; regno < 8; ++regno)
 555               if (val & (1 << regno))
 556                 {
 557                   int first_regno;
 558                   if (doneany)
 559                     fputs_filtered ("/", stream);
 560                   doneany = 1;
 561                   fprintf_filtered (stream, "fp%d", regno);
 562                   first_regno = regno;
 563                   while (val & (1 << (regno + 1)))
 564                     ++regno;
 565                   if (regno > first_regno)
 566                     fprintf_filtered (stream, "-fp%d", regno);
 567                 }
 568           }
 569         else
 570           abort ();
 571       break;
 572
 573     default:
 574       error ("Invalid arg format in opcode table: \"%c\".", *d);
 575     }
 576
 577   return (unsigned char *) p;
 578 }
 579
 580 /* Fetch BITS bits from a position in the instruction specified by CODE.
 581    CODE is a "place to put an argument", or 'x' for a destination
 582    that is a general address (mode and register).
 583    BUFFER contains the instruction.  */
 584
 585 static int
 586 fetch_arg (buffer, code, bits)
 587      unsigned char *buffer;
 588      int code;
 589      int bits;
 590 {
 591   register int val;
 592   switch (code)
 593     {
 594     case 's':
 595       val = buffer[1];
 596       break;
 597
 598     case 'd':                   /* Destination, for register or quick.  */
 599       val = (buffer[0] << 8) + buffer[1];
 600       val >>= 9;
 601       break;
 602
 603     case 'x':                   /* Destination, for general arg */
 604       val = (buffer[0] << 8) + buffer[1];
 605       val >>= 6;
 606       break;
 607
 608     case 'k':
 609       val = (buffer[3] >> 4);
 610       break;
 611
 612     case 'C':
 613       val = buffer[3];
 614       break;
 615
 616     case '1':
 617       val = (buffer[2] << 8) + buffer[3];
 618       val >>= 12;
 619       break;
 620
 621     case '2':
 622       val = (buffer[2] << 8) + buffer[3];
 623       val >>= 6;
 624       break;
 625
 626     case '3':
 627     case 'j':
 628       val = (buffer[2] << 8) + buffer[3];
 629       break;
 630
 631     case '4':
 632       val = (buffer[4] << 8) + buffer[5];
 633       val >>= 12;
 634       break;
 635
 636     case '5':
 637       val = (buffer[4] << 8) + buffer[5];
 638       val >>= 6;
 639       break;
 640
 641     case '6':
 642       val = (buffer[4] << 8) + buffer[5];
 643       break;
 644
 645     case '7':
 646       val = (buffer[2] << 8) + buffer[3];
 647       val >>= 7;
 648       break;
 649
 650     case '8':
 651       val = (buffer[2] << 8) + buffer[3];
 652       val >>= 10;
 653       break;
 654
 655     default:
 656       abort ();
 657     }
 658
 659   switch (bits)
 660     {
 661     case 3:
 662       return val & 7;
 663     case 4:
 664       return val & 017;
 665     case 5:
 666       return val & 037;
 667     case 6:
 668       return val & 077;
 669     case 7:
 670       return val & 0177;
 671     case 8:
 672       return val & 0377;
 673     case 12:
 674       return val & 07777;
 675     default:
 676       abort ();
 677     }
 678 }
 679
 680 /* Print an indexed argument.  The base register is BASEREG (-1 for pc).
 681    P points to extension word, in buffer.
 682    ADDR is the nominal core address of that extension word.  */
 683
 684 static unsigned char *
 685 print_indexed (basereg, p, addr, stream)
 686      int basereg;
 687      unsigned char *p;
 688      CORE_ADDR addr;
 689      FILE *stream;
 690 {
 691   register int word;
 692   static char *scales[] = {"", "*2", "*4", "*8"};
 693   register int base_disp;
 694   register int outer_disp;
 695   char buf[40];
 696
 697   word = NEXTWORD (p);
 698
 699   /* Generate the text for the index register.
 700      Where this will be output is not yet determined.  */
 701   sprintf (buf, "[%s.%c%s]",
 702            reg_names[(word >> 12) & 0xf],
 703            (word & 0x800) ? 'l' : 'w',
 704            scales[(word >> 9) & 3]);
 705
 706   /* Handle the 68000 style of indexing.  */
 707
 708   if ((word & 0x100) == 0)
 709     {
 710       print_base (basereg,
 711                   ((word & 0x80) ? word | 0xff00 : word & 0xff)
 712                   + ((basereg == -1) ? addr : 0),
 713                   stream);
 714       fputs_filtered (buf, stream);
 715       return p;
 716     }
 717
 718   /* Handle the generalized kind.  */
 719   /* First, compute the displacement to add to the base register.  */
 720
 721   if (word & 0200)
 722     basereg = -2;
 723   if (word & 0100)
 724     buf[0] = 0;
 725   base_disp = 0;
 726   switch ((word >> 4) & 3)
 727     {
 728     case 2:
 729       base_disp = NEXTWORD (p);
 730       break;
 731     case 3:
 732       base_disp = NEXTLONG (p);
 733     }
 734   if (basereg == -1)
 735     base_disp += addr;
 736
 737   /* Handle single-level case (not indirect) */
 738
 739   if ((word & 7) == 0)
 740     {
 741       print_base (basereg, base_disp, stream);
 742       fputs_filtered (buf, stream);
 743       return p;
 744     }
 745
 746   /* Two level.  Compute displacement to add after indirection.  */
 747
 748   outer_disp = 0;
 749   switch (word & 3)
 750     {
 751     case 2:
 752       outer_disp = NEXTWORD (p);
 753       break;
 754     case 3:
 755       outer_disp = NEXTLONG (p);
 756     }
 757
 758   fprintf_filtered (stream, "%d(", outer_disp);
 759   print_base (basereg, base_disp, stream);
 760
 761   /* If postindexed, print the closeparen before the index.  */
 762   if (word & 4)
 763     fprintf_filtered (stream, ")%s", buf);
 764   /* If preindexed, print the closeparen after the index.  */
 765   else
 766     fprintf_filtered (stream, "%s)", buf);
 767
 768   return p;
 769 }
 770
 771 /* Print a base register REGNO and displacement DISP, on STREAM.
 772    REGNO = -1 for pc, -2 for none (suppressed).  */
 773
 774 static void
 775 print_base (regno, disp, stream)
 776      int regno;
 777      int disp;
 778      FILE *stream;
 779 {
 780   if (regno == -2)
 781     fprintf_filtered (stream, "%d", disp);
 782   else if (regno == -1)
 783     fprintf_filtered (stream, "0x%x", disp);
 784   else
 785     fprintf_filtered (stream, "%d(%s)", disp, reg_names[regno]);
 786 }