git.sur5r.net Git - cc65/blob - src/cc65/codeent.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 codeent.c                                 */
   4 /*                                                                           */
   5 /*                            Code segment entry                             */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2001-2009, Ullrich von Bassewitz                                      */
  10 /*                Roemerstrasse 52                                           */
  11 /*                D-70794 Filderstadt                                        */
  12 /* EMail:         uz@cc65.org                                                */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <stdlib.h>
  37
  38 /* common */
  39 #include "chartype.h"
  40 #include "check.h"
  41 #include "debugflag.h"
  42 #include "xmalloc.h"
  43 #include "xsprintf.h"
  44
  45 /* cc65 */
  46 #include "codeent.h"
  47 #include "codeinfo.h"
  48 #include "error.h"
  49 #include "global.h"
  50 #include "codelab.h"
  51 #include "opcodes.h"
  52 #include "output.h"
  53
  54
  55
  56 /*****************************************************************************/
  57 /*                                   Data                                    */
  58 /*****************************************************************************/
  59
  60
  61
  62 /* Empty argument */
  63 static char EmptyArg[] = "";
  64
  65
  66
  67 /*****************************************************************************/
  68 /*                             Helper functions                              */
  69 /*****************************************************************************/
  70
  71
  72
  73 static void FreeArg (char* Arg)
  74 /* Free a code entry argument */
  75 {
  76     if (Arg != EmptyArg) {
  77         xfree (Arg);
  78     }
  79 }
  80
  81
  82
  83 static char* GetArgCopy (const char* Arg)
  84 /* Create an argument copy for assignment */
  85 {
  86     if (Arg && Arg[0] != '\0') {
  87         /* Create a copy */
  88         return xstrdup (Arg);
  89     } else {
  90         /* Use the empty argument string */
  91         return EmptyArg;
  92     }
  93 }
  94
  95
  96
  97 static int NumArg (const char* Arg, unsigned long* Num)
  98 /* If the given argument is numerical, convert it and return true. Otherwise
  99  * set Num to zero and return false.
 100  */
 101 {
 102     char* End;
 103     unsigned long Val;
 104
 105     /* Determine the base */
 106     int Base = 10;
 107     if (*Arg == '$') {
 108         ++Arg;
 109         Base = 16;
 110     } else if (*Arg == '%') {
 111         ++Arg;
 112         Base = 2;
 113     }
 114
 115     /* Convert the value. strtol is not exactly what we want here, but it's
 116      * cheap and may be replaced by something fancier later.
 117      */
 118     Val = strtoul (Arg, &End, Base);
 119
 120     /* Check if the conversion was successful */
 121     if (*End != '\0') {
 122
 123         /* Could not convert */
 124         *Num = 0;
 125         return 0;
 126
 127     } else {
 128
 129         /* Conversion ok */
 130         *Num = Val;
 131         return 1;
 132
 133     }
 134 }
 135
 136
 137
 138 static void SetUseChgInfo (CodeEntry* E, const OPCDesc* D)
 139 /* Set the Use and Chg in E */
 140 {
 141     const ZPInfo* Info;
 142
 143     /* If this is a subroutine call, or a jump to an external function,
 144      * lookup the information about this function and use it. The jump itself
 145      * does not change any registers, so we don't need to use the data from D.
 146      */
 147     if ((E->Info & (OF_UBRA | OF_CALL)) != 0 && E->JumpTo == 0) {
 148         /* A subroutine call or jump to external symbol (function exit) */
 149         GetFuncInfo (E->Arg, &E->Use, &E->Chg);
 150     } else {
 151         /* Some other instruction. Use the values from the opcode description
 152          * plus addressing mode info.
 153          */
 154         E->Use = D->Use | GetAMUseInfo (E->AM);
 155         E->Chg = D->Chg;
 156
 157         /* Check for special zero page registers used */
 158         switch (E->AM) {
 159
 160             case AM65_ACC:
 161                 if (E->OPC == OP65_ASL || E->OPC == OP65_DEC ||
 162                     E->OPC == OP65_INC || E->OPC == OP65_LSR ||
 163                     E->OPC == OP65_ROL || E->OPC == OP65_ROR) {
 164                     /* A is changed by these insns */
 165                     E->Chg |= REG_A;
 166                 }
 167                 break;
 168
 169             case AM65_ZP:
 170             case AM65_ABS:
 171             /* Be conservative: */
 172             case AM65_ZPX:
 173             case AM65_ABSX:
 174             case AM65_ABSY:
 175                 Info = GetZPInfo (E->Arg);
 176                 if (Info && Info->ByteUse != REG_NONE) {
 177                     if (E->OPC == OP65_ASL || E->OPC == OP65_DEC ||
 178                         E->OPC == OP65_INC || E->OPC == OP65_LSR ||
 179                         E->OPC == OP65_ROL || E->OPC == OP65_ROR ||
 180                         E->OPC == OP65_TRB || E->OPC == OP65_TSB) {
 181                         /* The zp loc is both, input and output */
 182                         E->Chg |= Info->ByteUse;
 183                         E->Use |= Info->ByteUse;
 184                     } else if ((E->Info & OF_STORE) != 0) {
 185                         /* Just output */
 186                         E->Chg |= Info->ByteUse;
 187                     } else {
 188                         /* Input only */
 189                         E->Use |= Info->ByteUse;
 190                     }
 191                 }
 192                 break;
 193
 194             case AM65_ZPX_IND:
 195             case AM65_ZP_INDY:
 196             case AM65_ZP_IND:
 197                 Info = GetZPInfo (E->Arg);
 198                 if (Info && Info->ByteUse != REG_NONE) {
 199                     /* These addressing modes will never change the zp loc */
 200                     E->Use |= Info->WordUse;
 201                 }
 202                 break;
 203
 204             default:
 205                 /* Keep gcc silent */
 206                 break;
 207         }
 208     }
 209 }
 210
 211
 212
 213 /*****************************************************************************/
 214 /*                                   Code                                    */
 215 /*****************************************************************************/
 216
 217
 218
 219 const char* MakeHexArg (unsigned Num)
 220 /* Convert Num into a string in the form $XY, suitable for passing it as an
 221  * argument to NewCodeEntry, and return a pointer to the string.
 222  * BEWARE: The function returns a pointer to a static buffer, so the value is
 223  * gone if you call it twice (and apart from that it's not thread and signal
 224  * safe).
 225  */
 226 {
 227     static char Buf[16];
 228     xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned char) Num);
 229     return Buf;
 230 }
 231
 232
 233
 234 CodeEntry* NewCodeEntry (opc_t OPC, am_t AM, const char* Arg,
 235                          CodeLabel* JumpTo, LineInfo* LI)
 236 /* Create a new code entry, initialize and return it */
 237 {
 238     /* Get the opcode description */
 239     const OPCDesc* D = GetOPCDesc (OPC);
 240
 241     /* Allocate memory */
 242     CodeEntry* E = xmalloc (sizeof (CodeEntry));
 243
 244     /* Initialize the fields */
 245     E->OPC    = D->OPC;
 246     E->AM     = AM;
 247     E->Size   = GetInsnSize (E->OPC, E->AM);
 248     E->Arg    = GetArgCopy (Arg);
 249     E->Flags  = NumArg (E->Arg, &E->Num)? CEF_NUMARG : 0;   /* Needs E->Arg */
 250     E->Info   = D->Info;
 251     E->JumpTo = JumpTo;
 252     E->LI     = UseLineInfo (LI);
 253     E->RI     = 0;
 254     SetUseChgInfo (E, D);
 255     InitCollection (&E->Labels);
 256
 257     /* If we have a label given, add this entry to the label */
 258     if (JumpTo) {
 259         CollAppend (&JumpTo->JumpFrom, E);
 260     }
 261
 262     /* Return the initialized struct */
 263     return E;
 264 }
 265
 266
 267
 268 void FreeCodeEntry (CodeEntry* E)
 269 /* Free the given code entry */
 270 {
 271     /* Free the string argument if we have one */
 272     FreeArg (E->Arg);
 273
 274     /* Cleanup the collection */
 275     DoneCollection (&E->Labels);
 276
 277     /* Release the line info */
 278     ReleaseLineInfo (E->LI);
 279
 280     /* Delete the register info */
 281     CE_FreeRegInfo (E);
 282
 283     /* Free the entry */
 284     xfree (E);
 285 }
 286
 287
 288
 289 void CE_ReplaceOPC (CodeEntry* E, opc_t OPC)
 290 /* Replace the opcode of the instruction. This will also replace related info,
 291  * Size, Use and Chg, but it will NOT update any arguments or labels.
 292  */
 293 {
 294     /* Get the opcode descriptor */
 295     const OPCDesc* D = GetOPCDesc (OPC);
 296
 297     /* Replace the opcode */
 298     E->OPC  = OPC;
 299     E->Info = D->Info;
 300     E->Size = GetInsnSize (E->OPC, E->AM);
 301     SetUseChgInfo (E, D);
 302 }
 303
 304
 305
 306 int CodeEntriesAreEqual (const CodeEntry* E1, const CodeEntry* E2)
 307 /* Check if both code entries are equal */
 308 {
 309     return (E1->OPC == E2->OPC && E1->AM == E2->AM && strcmp (E1->Arg, E2->Arg) == 0);
 310 }
 311
 312
 313
 314 void CE_AttachLabel (CodeEntry* E, CodeLabel* L)
 315 /* Attach the label to the entry */
 316 {
 317     /* Add it to the entries label list */
 318     CollAppend (&E->Labels, L);
 319
 320     /* Tell the label about it's owner */
 321     L->Owner = E;
 322 }
 323
 324
 325
 326 void CE_ClearJumpTo (CodeEntry* E)
 327 /* Clear the JumpTo entry and the argument (which contained the name of the
 328  * label). Note: The function will not clear the backpointer from the label,
 329  * so use it with care.
 330  */
 331 {
 332     /* Clear the JumpTo entry */
 333     E->JumpTo = 0;
 334
 335     /* Clear the argument and assign the empty one */
 336     FreeArg (E->Arg);
 337     E->Arg = EmptyArg;
 338 }
 339
 340
 341
 342 void CE_MoveLabel (CodeLabel* L, CodeEntry* E)
 343 /* Move the code label L from it's former owner to the code entry E. */
 344 {
 345     /* Delete the label from the owner */
 346     CollDeleteItem (&L->Owner->Labels, L);
 347
 348     /* Set the new owner */
 349     CollAppend (&E->Labels, L);
 350     L->Owner = E;
 351 }
 352
 353
 354
 355 void CE_SetArg (CodeEntry* E, const char* Arg)
 356 /* Replace the argument by the new one. */
 357 {
 358     /* Free the old argument */
 359     FreeArg (E->Arg);
 360
 361     /* Assign the new one */
 362     E->Arg = GetArgCopy (Arg);
 363 }
 364
 365
 366
 367 void CE_SetNumArg (CodeEntry* E, long Num)
 368 /* Set a new numeric argument for the given code entry that must already
 369  * have a numeric argument.
 370  */
 371 {
 372     char Buf[16];
 373
 374     /* Check that the entry has a numerical argument */
 375     CHECK (E->Flags & CEF_NUMARG);
 376
 377     /* Make the new argument string */
 378     if (E->Size == 2) {
 379         Num &= 0xFF;
 380         xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned) Num);
 381     } else if (E->Size == 3) {
 382         Num &= 0xFFFF;
 383         xsprintf (Buf, sizeof (Buf), "$%04X", (unsigned) Num);
 384     } else {
 385         Internal ("Invalid instruction size in CE_SetNumArg");
 386     }
 387
 388     /* Replace the argument by the new one */
 389     CE_SetArg (E, Buf);
 390
 391     /* Use the new numerical value */
 392     E->Num = Num;
 393 }
 394
 395
 396
 397 int CE_IsConstImm (const CodeEntry* E)
 398 /* Return true if the argument of E is a constant immediate value */
 399 {
 400     return (E->AM == AM65_IMM && (E->Flags & CEF_NUMARG) != 0);
 401 }
 402
 403
 404
 405 int CE_IsKnownImm (const CodeEntry* E, unsigned long Num)
 406 /* Return true if the argument of E is a constant immediate value that is
 407  * equal to Num.
 408  */
 409 {
 410     return E->AM == AM65_IMM            &&
 411            (E->Flags & CEF_NUMARG) != 0 &&
 412            E->Num == Num;
 413 }
 414
 415
 416
 417 int CE_UseLoadFlags (const CodeEntry* E)
 418 /* Return true if the instruction uses any flags that are set by a load of
 419  * a register (N and Z).
 420  */
 421 {
 422     /* Follow unconditional branches, but beware of endless loops. After this,
 423      * E will point to the first entry that is not a branch.
 424      */
 425     if (E->Info & OF_UBRA) {
 426         Collection C = AUTO_COLLECTION_INITIALIZER;
 427
 428         /* Follow the chain */
 429         while (E->Info & OF_UBRA) {
 430
 431             /* Remember the entry so we can detect loops */
 432             CollAppend (&C, (void*) E);
 433
 434             /* Check the target */
 435             if (E->JumpTo == 0 || CollIndex (&C, E->JumpTo->Owner) >= 0) {
 436                 /* Unconditional jump to external symbol, or endless loop. */
 437                 DoneCollection (&C);
 438                 return 0;       /* Flags not used */
 439             }
 440
 441             /* Follow the chain */
 442             E = E->JumpTo->Owner;
 443         }
 444
 445         /* Delete the collection */
 446         DoneCollection (&C);
 447     }
 448
 449     /* A branch will use the flags */
 450     if (E->Info & OF_FBRA) {
 451         return 1;
 452     }
 453
 454     /* Call of a boolean transformer routine will also use the flags */
 455     if (E->OPC == OP65_JSR) {
 456         /* Get the condition that is evaluated and check it */
 457         switch (FindBoolCmpCond (E->Arg)) {
 458             case CMP_EQ:
 459             case CMP_NE:
 460             case CMP_GT:
 461             case CMP_GE:
 462             case CMP_LT:
 463             case CMP_LE:
 464             case CMP_UGT:
 465             case CMP_ULE:
 466                 /* Will use the N or Z flags */
 467                 return 1;
 468
 469
 470             case CMP_UGE:       /* Uses only carry */
 471             case CMP_ULT:       /* Dito */
 472             default:            /* No bool transformer subroutine */
 473                 return 0;
 474         }
 475     }
 476
 477     /* Anything else */
 478     return 0;
 479 }
 480
 481
 482
 483 void CE_FreeRegInfo (CodeEntry* E)
 484 /* Free an existing register info struct */
 485 {
 486     if (E->RI) {
 487         FreeRegInfo (E->RI);
 488         E->RI = 0;
 489     }
 490 }
 491
 492
 493
 494 void CE_GenRegInfo (CodeEntry* E, RegContents* InputRegs)
 495 /* Generate register info for this instruction. If an old info exists, it is
 496  * overwritten.
 497  */
 498 {
 499     /* Pointers to the register contents */
 500     RegContents* In;
 501     RegContents* Out;
 502
 503     /* Function register usage */
 504     unsigned short Use, Chg;
 505
 506     /* If we don't have a register info struct, allocate one. */
 507     if (E->RI == 0) {
 508         E->RI = NewRegInfo (InputRegs);
 509     } else {
 510         if (InputRegs) {
 511             E->RI->In  = *InputRegs;
 512         } else {
 513             RC_Invalidate (&E->RI->In);
 514         }
 515         E->RI->Out2 = E->RI->Out = E->RI->In;
 516     }
 517
 518     /* Get pointers to the register contents */
 519     In  = &E->RI->In;
 520     Out = &E->RI->Out;
 521
 522     /* Handle the different instructions */
 523     switch (E->OPC) {
 524
 525         case OP65_ADC:
 526             /* We don't know the value of the carry, so the result is
 527              * always unknown.
 528              */
 529             Out->RegA = UNKNOWN_REGVAL;
 530             break;
 531
 532         case OP65_AND:
 533             if (RegValIsKnown (In->RegA)) {
 534                 if (CE_IsConstImm (E)) {
 535                     Out->RegA = In->RegA & (short) E->Num;
 536                 } else if (E->AM == AM65_ZP) {
 537                     switch (GetKnownReg (E->Use & REG_ZP, In)) {
 538                         case REG_TMP1:
 539                             Out->RegA = In->RegA & In->Tmp1;
 540                             break;
 541                         case REG_PTR1_LO:
 542                             Out->RegA = In->RegA & In->Ptr1Lo;
 543                             break;
 544                         case REG_PTR1_HI:
 545                             Out->RegA = In->RegA & In->Ptr1Hi;
 546                             break;
 547                         case REG_SREG_LO:
 548                             Out->RegA = In->RegA & In->SRegLo;
 549                             break;
 550                         case REG_SREG_HI:
 551                             Out->RegA = In->RegA & In->SRegHi;
 552                             break;
 553                         default:
 554                             Out->RegA = UNKNOWN_REGVAL;
 555                             break;
 556                     }
 557                 } else {
 558                     Out->RegA = UNKNOWN_REGVAL;
 559                 }
 560             } else if (CE_IsKnownImm (E, 0)) {
 561                 /* A and $00 does always give zero */
 562                 Out->RegA = 0;
 563             }
 564             break;
 565
 566         case OP65_ASL:
 567             if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
 568                 Out->RegA = (In->RegA << 1) & 0xFF;
 569             } else if (E->AM == AM65_ZP) {
 570                 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
 571                     case REG_TMP1:
 572                         Out->Tmp1 = (In->Tmp1 << 1) & 0xFF;
 573                         break;
 574                     case REG_PTR1_LO:
 575                         Out->Ptr1Lo = (In->Ptr1Lo << 1) & 0xFF;
 576                         break;
 577                     case REG_PTR1_HI:
 578                         Out->Ptr1Hi = (In->Ptr1Hi << 1) & 0xFF;
 579                         break;
 580                     case REG_SREG_LO:
 581                         Out->SRegLo = (In->SRegLo << 1) & 0xFF;
 582                         break;
 583                     case REG_SREG_HI:
 584                         Out->SRegHi = (In->SRegHi << 1) & 0xFF;
 585                         break;
 586                 }
 587             } else if (E->AM == AM65_ZPX) {
 588                 /* Invalidates all ZP registers */
 589                 RC_InvalidateZP (Out);
 590             }
 591             break;
 592
 593         case OP65_BCC:
 594             break;
 595
 596         case OP65_BCS:
 597             break;
 598
 599         case OP65_BEQ:
 600             break;
 601
 602         case OP65_BIT:
 603             break;
 604
 605         case OP65_BMI:
 606             break;
 607
 608         case OP65_BNE:
 609             break;
 610
 611         case OP65_BPL:
 612             break;
 613
 614         case OP65_BRA:
 615             break;
 616
 617         case OP65_BRK:
 618             break;
 619
 620         case OP65_BVC:
 621             break;
 622
 623         case OP65_BVS:
 624             break;
 625
 626         case OP65_CLC:
 627             break;
 628
 629         case OP65_CLD:
 630             break;
 631
 632         case OP65_CLI:
 633             break;
 634
 635         case OP65_CLV:
 636             break;
 637
 638         case OP65_CMP:
 639             break;
 640
 641         case OP65_CPX:
 642             break;
 643
 644         case OP65_CPY:
 645             break;
 646
 647         case OP65_DEA:
 648             if (RegValIsKnown (In->RegA)) {
 649                 Out->RegA = (In->RegA - 1) & 0xFF;
 650             }
 651             break;
 652
 653         case OP65_DEC:
 654             if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
 655                 Out->RegA = (In->RegA - 1) & 0xFF;
 656             } else if (E->AM == AM65_ZP) {
 657                 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
 658                     case REG_TMP1:
 659                         Out->Tmp1 = (In->Tmp1 - 1) & 0xFF;
 660                         break;
 661                     case REG_PTR1_LO:
 662                         Out->Ptr1Lo = (In->Ptr1Lo - 1) & 0xFF;
 663                         break;
 664                     case REG_PTR1_HI:
 665                         Out->Ptr1Hi = (In->Ptr1Hi - 1) & 0xFF;
 666                         break;
 667                     case REG_SREG_LO:
 668                         Out->SRegLo = (In->SRegLo - 1) & 0xFF;
 669                         break;
 670                     case REG_SREG_HI:
 671                         Out->SRegHi = (In->SRegHi - 1) & 0xFF;
 672                         break;
 673                 }
 674             } else if (E->AM == AM65_ZPX) {
 675                 /* Invalidates all ZP registers */
 676                 RC_InvalidateZP (Out);
 677             }
 678             break;
 679
 680         case OP65_DEX:
 681             if (RegValIsKnown (In->RegX)) {
 682                 Out->RegX = (In->RegX - 1) & 0xFF;
 683             }
 684             break;
 685
 686         case OP65_DEY:
 687             if (RegValIsKnown (In->RegY)) {
 688                 Out->RegY = (In->RegY - 1) & 0xFF;
 689             }
 690             break;
 691
 692         case OP65_EOR:
 693             if (RegValIsKnown (In->RegA)) {
 694                 if (CE_IsConstImm (E)) {
 695                     Out->RegA = In->RegA ^ (short) E->Num;
 696                 } else if (E->AM == AM65_ZP) {
 697                     switch (GetKnownReg (E->Use & REG_ZP, In)) {
 698                         case REG_TMP1:
 699                             Out->RegA = In->RegA ^ In->Tmp1;
 700                             break;
 701                         case REG_PTR1_LO:
 702                             Out->RegA = In->RegA ^ In->Ptr1Lo;
 703                             break;
 704                         case REG_PTR1_HI:
 705                             Out->RegA = In->RegA ^ In->Ptr1Hi;
 706                             break;
 707                         case REG_SREG_LO:
 708                             Out->RegA = In->RegA ^ In->SRegLo;
 709                             break;
 710                         case REG_SREG_HI:
 711                             Out->RegA = In->RegA ^ In->SRegHi;
 712                             break;
 713                         default:
 714                             Out->RegA = UNKNOWN_REGVAL;
 715                             break;
 716                     }
 717                 } else {
 718                     Out->RegA = UNKNOWN_REGVAL;
 719                 }
 720             }
 721             break;
 722
 723         case OP65_INA:
 724             if (RegValIsKnown (In->RegA)) {
 725                 Out->RegA = (In->RegA + 1) & 0xFF;
 726             }
 727             break;
 728
 729         case OP65_INC:
 730             if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
 731                 Out->RegA = (In->RegA + 1) & 0xFF;
 732             } else if (E->AM == AM65_ZP) {
 733                 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
 734                     case REG_TMP1:
 735                         Out->Tmp1 = (In->Tmp1 + 1) & 0xFF;
 736                         break;
 737                     case REG_PTR1_LO:
 738                         Out->Ptr1Lo = (In->Ptr1Lo + 1) & 0xFF;
 739                         break;
 740                     case REG_PTR1_HI:
 741                         Out->Ptr1Hi = (In->Ptr1Hi + 1) & 0xFF;
 742                         break;
 743                     case REG_SREG_LO:
 744                         Out->SRegLo = (In->SRegLo + 1) & 0xFF;
 745                         break;
 746                     case REG_SREG_HI:
 747                         Out->SRegHi = (In->SRegHi + 1) & 0xFF;
 748                         break;
 749                 }
 750             } else if (E->AM == AM65_ZPX) {
 751                 /* Invalidates all ZP registers */
 752                 RC_InvalidateZP (Out);
 753             }
 754             break;
 755
 756         case OP65_INX:
 757             if (RegValIsKnown (In->RegX)) {
 758                 Out->RegX = (In->RegX + 1) & 0xFF;
 759             }
 760             break;
 761
 762         case OP65_INY:
 763             if (RegValIsKnown (In->RegY)) {
 764                 Out->RegY = (In->RegY + 1) & 0xFF;
 765             }
 766             break;
 767
 768         case OP65_JCC:
 769             break;
 770
 771         case OP65_JCS:
 772             break;
 773
 774         case OP65_JEQ:
 775             break;
 776
 777         case OP65_JMI:
 778             break;
 779
 780         case OP65_JMP:
 781             break;
 782
 783         case OP65_JNE:
 784             break;
 785
 786         case OP65_JPL:
 787             break;
 788
 789         case OP65_JSR:
 790             /* Get the code info for the function */
 791             GetFuncInfo (E->Arg, &Use, &Chg);
 792             if (Chg & REG_A) {
 793                 Out->RegA = UNKNOWN_REGVAL;
 794             }
 795             if (Chg & REG_X) {
 796                 Out->RegX = UNKNOWN_REGVAL;
 797             }
 798             if (Chg & REG_Y) {
 799                 Out->RegY = UNKNOWN_REGVAL;
 800             }
 801             if (Chg & REG_TMP1) {
 802                 Out->Tmp1 = UNKNOWN_REGVAL;
 803             }
 804             if (Chg & REG_PTR1_LO) {
 805                 Out->Ptr1Lo = UNKNOWN_REGVAL;
 806             }
 807             if (Chg & REG_PTR1_HI) {
 808                 Out->Ptr1Hi = UNKNOWN_REGVAL;
 809             }
 810             if (Chg & REG_SREG_LO) {
 811                 Out->SRegLo = UNKNOWN_REGVAL;
 812             }
 813             if (Chg & REG_SREG_HI) {
 814                 Out->SRegHi = UNKNOWN_REGVAL;
 815             }
 816             /* ## FIXME: Quick hack for some known functions: */
 817             if (strcmp (E->Arg, "tosandax") == 0) {
 818                 if (In->RegA == 0) {
 819                     Out->RegA = 0;
 820                 }
 821                 if (In->RegX == 0) {
 822                     Out->RegX = 0;
 823                 }
 824             } else if (strcmp (E->Arg, "tosorax") == 0) {
 825                 if (In->RegA == 0xFF) {
 826                     Out->RegA = 0xFF;
 827                 }
 828                 if (In->RegX == 0xFF) {
 829                     Out->RegX = 0xFF;
 830                 }
 831             } else if (FindBoolCmpCond (E->Arg) != CMP_INV) {
 832                 Out->RegX = 0;
 833             }
 834             break;
 835
 836         case OP65_JVC:
 837             break;
 838
 839         case OP65_JVS:
 840             break;
 841
 842         case OP65_LDA:
 843             if (CE_IsConstImm (E)) {
 844                 Out->RegA = (unsigned char) E->Num;
 845             } else if (E->AM == AM65_ZP) {
 846                 switch (GetKnownReg (E->Use & REG_ZP, In)) {
 847                     case REG_TMP1:
 848                         Out->RegA = In->Tmp1;
 849                         break;
 850                     case REG_PTR1_LO:
 851                         Out->RegA = In->Ptr1Lo;
 852                         break;
 853                     case REG_PTR1_HI:
 854                         Out->RegA = In->Ptr1Hi;
 855                         break;
 856                     case REG_SREG_LO:
 857                         Out->RegA = In->SRegLo;
 858                         break;
 859                     case REG_SREG_HI:
 860                         Out->RegA = In->SRegHi;
 861                         break;
 862                     default:
 863                         Out->RegA = UNKNOWN_REGVAL;
 864                         break;
 865                 }
 866             } else {
 867                 /* A is now unknown */
 868                 Out->RegA = UNKNOWN_REGVAL;
 869             }
 870             break;
 871
 872         case OP65_LDX:
 873             if (CE_IsConstImm (E)) {
 874                 Out->RegX = (unsigned char) E->Num;
 875             } else if (E->AM == AM65_ZP) {
 876                 switch (GetKnownReg (E->Use & REG_ZP, In)) {
 877                     case REG_TMP1:
 878                         Out->RegX = In->Tmp1;
 879                         break;
 880                     case REG_PTR1_LO:
 881                         Out->RegX = In->Ptr1Lo;
 882                         break;
 883                     case REG_PTR1_HI:
 884                         Out->RegX = In->Ptr1Hi;
 885                         break;
 886                     case REG_SREG_LO:
 887                         Out->RegX = In->SRegLo;
 888                         break;
 889                     case REG_SREG_HI:
 890                         Out->RegX = In->SRegHi;
 891                         break;
 892                     default:
 893                         Out->RegX = UNKNOWN_REGVAL;
 894                         break;
 895                 }
 896             } else {
 897                 /* X is now unknown */
 898                 Out->RegX = UNKNOWN_REGVAL;
 899             }
 900             break;
 901
 902         case OP65_LDY:
 903             if (CE_IsConstImm (E)) {
 904                 Out->RegY = (unsigned char) E->Num;
 905             } else if (E->AM == AM65_ZP) {
 906                 switch (GetKnownReg (E->Use & REG_ZP, In)) {
 907                     case REG_TMP1:
 908                         Out->RegY = In->Tmp1;
 909                         break;
 910                     case REG_PTR1_LO:
 911                         Out->RegY = In->Ptr1Lo;
 912                         break;
 913                     case REG_PTR1_HI:
 914                         Out->RegY = In->Ptr1Hi;
 915                         break;
 916                     case REG_SREG_LO:
 917                         Out->RegY = In->SRegLo;
 918                         break;
 919                     case REG_SREG_HI:
 920                         Out->RegY = In->SRegHi;
 921                         break;
 922                     default:
 923                         Out->RegY = UNKNOWN_REGVAL;
 924                         break;
 925                 }
 926             } else {
 927                 /* Y is now unknown */
 928                 Out->RegY = UNKNOWN_REGVAL;
 929             }
 930             break;
 931
 932         case OP65_LSR:
 933             if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
 934                 Out->RegA = (In->RegA >> 1) & 0xFF;
 935             } else if (E->AM == AM65_ZP) {
 936                 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
 937                     case REG_TMP1:
 938                         Out->Tmp1 = (In->Tmp1 >> 1) & 0xFF;
 939                         break;
 940                     case REG_PTR1_LO:
 941                         Out->Ptr1Lo = (In->Ptr1Lo >> 1) & 0xFF;
 942                         break;
 943                     case REG_PTR1_HI:
 944                         Out->Ptr1Hi = (In->Ptr1Hi >> 1) & 0xFF;
 945                         break;
 946                     case REG_SREG_LO:
 947                         Out->SRegLo = (In->SRegLo >> 1) & 0xFF;
 948                         break;
 949                     case REG_SREG_HI:
 950                         Out->SRegHi = (In->SRegHi >> 1) & 0xFF;
 951                         break;
 952                 }
 953             } else if (E->AM == AM65_ZPX) {
 954                 /* Invalidates all ZP registers */
 955                 RC_InvalidateZP (Out);
 956             }
 957             break;
 958
 959         case OP65_NOP:
 960             break;
 961
 962         case OP65_ORA:
 963             if (RegValIsKnown (In->RegA)) {
 964                 if (CE_IsConstImm (E)) {
 965                     Out->RegA = In->RegA | (short) E->Num;
 966                 } else if (E->AM == AM65_ZP) {
 967                     switch (GetKnownReg (E->Use & REG_ZP, In)) {
 968                         case REG_TMP1:
 969                             Out->RegA = In->RegA | In->Tmp1;
 970                             break;
 971                         case REG_PTR1_LO:
 972                             Out->RegA = In->RegA | In->Ptr1Lo;
 973                             break;
 974                         case REG_PTR1_HI:
 975                             Out->RegA = In->RegA | In->Ptr1Hi;
 976                             break;
 977                         case REG_SREG_LO:
 978                             Out->RegA = In->RegA | In->SRegLo;
 979                             break;
 980                         case REG_SREG_HI:
 981                             Out->RegA = In->RegA | In->SRegHi;
 982                             break;
 983                         default:
 984                             Out->RegA = UNKNOWN_REGVAL;
 985                             break;
 986                     }
 987                 } else {
 988                     /* A is now unknown */
 989                     Out->RegA = UNKNOWN_REGVAL;
 990                 }
 991             } else if (CE_IsKnownImm (E, 0xFF)) {
 992                 /* ORA with 0xFF does always give 0xFF */
 993                 Out->RegA = 0xFF;
 994             }
 995             break;
 996
 997         case OP65_PHA:
 998             break;
 999
1000         case OP65_PHP:
1001             break;
1002
1003         case OP65_PHX:
1004             break;
1005
1006         case OP65_PHY:
1007             break;
1008
1009         case OP65_PLA:
1010             Out->RegA = UNKNOWN_REGVAL;
1011             break;
1012
1013         case OP65_PLP:
1014             break;
1015
1016         case OP65_PLX:
1017             Out->RegX = UNKNOWN_REGVAL;
1018             break;
1019
1020         case OP65_PLY:
1021             Out->RegY = UNKNOWN_REGVAL;
1022             break;
1023
1024         case OP65_ROL:
1025             /* We don't know the value of the carry bit */
1026             if (E->AM == AM65_ACC) {
1027                 Out->RegA = UNKNOWN_REGVAL;
1028             } else if (E->AM == AM65_ZP) {
1029                 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1030                     case REG_TMP1:
1031                         Out->Tmp1 = UNKNOWN_REGVAL;
1032                         break;
1033                     case REG_PTR1_LO:
1034                         Out->Ptr1Lo = UNKNOWN_REGVAL;
1035                         break;
1036                     case REG_PTR1_HI:
1037                         Out->Ptr1Hi = UNKNOWN_REGVAL;
1038                         break;
1039                     case REG_SREG_LO:
1040                         Out->SRegLo = UNKNOWN_REGVAL;
1041                         break;
1042                     case REG_SREG_HI:
1043                         Out->SRegHi = UNKNOWN_REGVAL;
1044                         break;
1045                 }
1046             } else if (E->AM == AM65_ZPX) {
1047                 /* Invalidates all ZP registers */
1048                 RC_InvalidateZP (Out);
1049             }
1050             break;
1051
1052         case OP65_ROR:
1053             /* We don't know the value of the carry bit */
1054             if (E->AM == AM65_ACC) {
1055                 Out->RegA = UNKNOWN_REGVAL;
1056             } else if (E->AM == AM65_ZP) {
1057                 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1058                     case REG_TMP1:
1059                         Out->Tmp1 = UNKNOWN_REGVAL;
1060                         break;
1061                     case REG_PTR1_LO:
1062                         Out->Ptr1Lo = UNKNOWN_REGVAL;
1063                         break;
1064                     case REG_PTR1_HI:
1065                         Out->Ptr1Hi = UNKNOWN_REGVAL;
1066                         break;
1067                     case REG_SREG_LO:
1068                         Out->SRegLo = UNKNOWN_REGVAL;
1069                         break;
1070                     case REG_SREG_HI:
1071                         Out->SRegHi = UNKNOWN_REGVAL;
1072                         break;
1073                 }
1074             } else if (E->AM == AM65_ZPX) {
1075                 /* Invalidates all ZP registers */
1076                 RC_InvalidateZP (Out);
1077             }
1078             break;
1079
1080         case OP65_RTI:
1081             break;
1082
1083         case OP65_RTS:
1084             break;
1085
1086         case OP65_SBC:
1087             /* We don't know the value of the carry bit */
1088             Out->RegA = UNKNOWN_REGVAL;
1089             break;
1090
1091         case OP65_SEC:
1092             break;
1093
1094         case OP65_SED:
1095             break;
1096
1097         case OP65_SEI:
1098             break;
1099
1100         case OP65_STA:
1101             if (E->AM == AM65_ZP) {
1102                 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1103                     case REG_TMP1:
1104                         Out->Tmp1 = In->RegA;
1105                         break;
1106                     case REG_PTR1_LO:
1107                         Out->Ptr1Lo = In->RegA;
1108                         break;
1109                     case REG_PTR1_HI:
1110                         Out->Ptr1Hi = In->RegA;
1111                         break;
1112                     case REG_SREG_LO:
1113                         Out->SRegLo = In->RegA;
1114                         break;
1115                     case REG_SREG_HI:
1116                         Out->SRegHi = In->RegA;
1117                         break;
1118                 }
1119             } else if (E->AM == AM65_ZPX) {
1120                 /* Invalidates all ZP registers */
1121                 RC_InvalidateZP (Out);
1122             }
1123             break;
1124
1125         case OP65_STX:
1126             if (E->AM == AM65_ZP) {
1127                 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1128                     case REG_TMP1:
1129                         Out->Tmp1 = In->RegX;
1130                         break;
1131                     case REG_PTR1_LO:
1132                         Out->Ptr1Lo = In->RegX;
1133                         break;
1134                     case REG_PTR1_HI:
1135                         Out->Ptr1Hi = In->RegX;
1136                         break;
1137                     case REG_SREG_LO:
1138                         Out->SRegLo = In->RegX;
1139                         break;
1140                     case REG_SREG_HI:
1141                         Out->SRegHi = In->RegX;
1142                         break;
1143                 }
1144             } else if (E->AM == AM65_ZPX) {
1145                 /* Invalidates all ZP registers */
1146                 RC_InvalidateZP (Out);
1147             }
1148             break;
1149
1150         case OP65_STY:
1151             if (E->AM == AM65_ZP) {
1152                 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1153                     case REG_TMP1:
1154                         Out->Tmp1 = In->RegY;
1155                         break;
1156                     case REG_PTR1_LO:
1157                         Out->Ptr1Lo = In->RegY;
1158                         break;
1159                     case REG_PTR1_HI:
1160                         Out->Ptr1Hi = In->RegY;
1161                         break;
1162                     case REG_SREG_LO:
1163                         Out->SRegLo = In->RegY;
1164                         break;
1165                     case REG_SREG_HI:
1166                         Out->SRegHi = In->RegY;
1167                         break;
1168                 }
1169             } else if (E->AM == AM65_ZPX) {
1170                 /* Invalidates all ZP registers */
1171                 RC_InvalidateZP (Out);
1172             }
1173             break;
1174
1175         case OP65_STZ:
1176             if (E->AM == AM65_ZP) {
1177                 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1178                     case REG_TMP1:
1179                         Out->Tmp1 = 0;
1180                         break;
1181                     case REG_PTR1_LO:
1182                         Out->Ptr1Lo = 0;
1183                         break;
1184                     case REG_PTR1_HI:
1185                         Out->Ptr1Hi = 0;
1186                         break;
1187                     case REG_SREG_LO:
1188                         Out->SRegLo = 0;
1189                         break;
1190                     case REG_SREG_HI:
1191                         Out->SRegHi = 0;
1192                         break;
1193                 }
1194             } else if (E->AM == AM65_ZPX) {
1195                 /* Invalidates all ZP registers */
1196                 RC_InvalidateZP (Out);
1197             }
1198             break;
1199
1200         case OP65_TAX:
1201             Out->RegX = In->RegA;
1202             break;
1203
1204         case OP65_TAY:
1205             Out->RegY = In->RegA;
1206             break;
1207
1208         case OP65_TRB:
1209             if (E->AM == AM65_ZPX) {
1210                 /* Invalidates all ZP registers */
1211                 RC_InvalidateZP (Out);
1212             } else if (E->AM == AM65_ZP) {
1213                 if (RegValIsKnown (In->RegA)) {
1214                     switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1215                         case REG_TMP1:
1216                             Out->Tmp1 &= ~In->RegA;
1217                             break;
1218                         case REG_PTR1_LO:
1219                             Out->Ptr1Lo &= ~In->RegA;
1220                             break;
1221                         case REG_PTR1_HI:
1222                             Out->Ptr1Hi &= ~In->RegA;
1223                             break;
1224                         case REG_SREG_LO:
1225                             Out->SRegLo &= ~In->RegA;
1226                             break;
1227                         case REG_SREG_HI:
1228                             Out->SRegHi &= ~In->RegA;
1229                             break;
1230                     }
1231                 } else {
1232                     switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1233                         case REG_TMP1:
1234                             Out->Tmp1 = UNKNOWN_REGVAL;
1235                             break;
1236                         case REG_PTR1_LO:
1237                             Out->Ptr1Lo = UNKNOWN_REGVAL;
1238                             break;
1239                         case REG_PTR1_HI:
1240                             Out->Ptr1Hi = UNKNOWN_REGVAL;
1241                             break;
1242                         case REG_SREG_LO:
1243                             Out->SRegLo = UNKNOWN_REGVAL;
1244                             break;
1245                         case REG_SREG_HI:
1246                             Out->SRegHi = UNKNOWN_REGVAL;
1247                             break;
1248                     }
1249                 }
1250             }
1251             break;
1252
1253         case OP65_TSB:
1254             if (E->AM == AM65_ZPX) {
1255                 /* Invalidates all ZP registers */
1256                 RC_InvalidateZP (Out);
1257             } else if (E->AM == AM65_ZP) {
1258                 if (RegValIsKnown (In->RegA)) {
1259                     switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1260                         case REG_TMP1:
1261                             Out->Tmp1 |= In->RegA;
1262                             break;
1263                         case REG_PTR1_LO:
1264                             Out->Ptr1Lo |= In->RegA;
1265                             break;
1266                         case REG_PTR1_HI:
1267                             Out->Ptr1Hi |= In->RegA;
1268                             break;
1269                         case REG_SREG_LO:
1270                             Out->SRegLo |= In->RegA;
1271                             break;
1272                         case REG_SREG_HI:
1273                             Out->SRegHi |= In->RegA;
1274                             break;
1275                     }
1276                 } else {
1277                     switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1278                         case REG_TMP1:
1279                             Out->Tmp1 = UNKNOWN_REGVAL;
1280                             break;
1281                         case REG_PTR1_LO:
1282                             Out->Ptr1Lo = UNKNOWN_REGVAL;
1283                             break;
1284                         case REG_PTR1_HI:
1285                             Out->Ptr1Hi = UNKNOWN_REGVAL;
1286                             break;
1287                         case REG_SREG_LO:
1288                             Out->SRegLo = UNKNOWN_REGVAL;
1289                             break;
1290                         case REG_SREG_HI:
1291                             Out->SRegHi = UNKNOWN_REGVAL;
1292                             break;
1293                     }
1294                 }
1295             }
1296             break;
1297
1298         case OP65_TSX:
1299             Out->RegX = UNKNOWN_REGVAL;
1300             break;
1301
1302         case OP65_TXA:
1303             Out->RegA = In->RegX;
1304             break;
1305
1306         case OP65_TXS:
1307             break;
1308
1309         case OP65_TYA:
1310             Out->RegA = In->RegY;
1311             break;
1312
1313         default:
1314             break;
1315
1316     }
1317 }
1318
1319
1320
1321 static char* RegInfoDesc (unsigned U, char* Buf)
1322 /* Return a string containing register info */
1323 {
1324     Buf[0] = '\0';
1325
1326     strcat (Buf, U & REG_SREG_HI? "H" : "_");
1327     strcat (Buf, U & REG_SREG_LO? "L" : "_");
1328     strcat (Buf, U & REG_A?       "A" : "_");
1329     strcat (Buf, U & REG_X?       "X" : "_");
1330     strcat (Buf, U & REG_Y?       "Y" : "_");
1331     strcat (Buf, U & REG_TMP1?    "T1" : "__");
1332     strcat (Buf, U & REG_PTR1?    "1" : "_");
1333     strcat (Buf, U & REG_PTR2?    "2" : "_");
1334     strcat (Buf, U & REG_SAVE?    "V"  : "_");
1335     strcat (Buf, U & REG_SP?      "S" : "_");
1336
1337     return Buf;
1338 }
1339
1340
1341
1342 static char* RegContentDesc (const RegContents* RC, char* Buf)
1343 /* Return a string containing register contents */
1344 {
1345     char* B = Buf;
1346
1347     if (RegValIsUnknown (RC->RegA)) {
1348         strcpy (B, "A:XX ");
1349     } else {
1350         sprintf (B, "A:%02X ", RC->RegA);
1351     }
1352     B += 5;
1353     if (RegValIsUnknown (RC->RegX)) {
1354         strcpy (B, "X:XX ");
1355     } else {
1356         sprintf (B, "X:%02X ", RC->RegX);
1357     }
1358     B += 5;
1359     if (RegValIsUnknown (RC->RegY)) {
1360         strcpy (B, "Y:XX");
1361     } else {
1362         sprintf (B, "Y:%02X", RC->RegY);
1363     }
1364     B += 4;
1365
1366     return Buf;
1367 }
1368
1369
1370
1371 void CE_Output (const CodeEntry* E)
1372 /* Output the code entry to the output file */
1373 {
1374     const OPCDesc* D;
1375     unsigned Chars;
1376     int Space;
1377     const char* Target;
1378
1379     /* If we have a label, print that */
1380     unsigned LabelCount = CollCount (&E->Labels);
1381     unsigned I;
1382     for (I = 0; I < LabelCount; ++I) {
1383         CL_Output (CollConstAt (&E->Labels, I));
1384     }
1385
1386     /* Get the opcode description */
1387     D = GetOPCDesc (E->OPC);
1388
1389     /* Print the mnemonic */
1390     Chars = WriteOutput ("\t%s", D->Mnemo);
1391
1392     /* Space to leave before the operand */
1393     Space = 9 - Chars;
1394
1395     /* Print the operand */
1396     switch (E->AM) {
1397
1398         case AM65_IMP:
1399             /* implicit */
1400             break;
1401
1402         case AM65_ACC:
1403             /* accumulator */
1404             Chars += WriteOutput ("%*sa", Space, "");
1405             break;
1406
1407         case AM65_IMM:
1408             /* immidiate */
1409             Chars += WriteOutput ("%*s#%s", Space, "", E->Arg);
1410             break;
1411
1412         case AM65_ZP:
1413         case AM65_ABS:
1414             /* zeropage and absolute */
1415             Chars += WriteOutput ("%*s%s", Space, "", E->Arg);
1416             break;
1417
1418         case AM65_ZPX:
1419         case AM65_ABSX:
1420             /* zeropage,X and absolute,X */
1421             Chars += WriteOutput ("%*s%s,x", Space, "", E->Arg);
1422             break;
1423
1424         case AM65_ABSY:
1425             /* absolute,Y */
1426             Chars += WriteOutput ("%*s%s,y", Space, "", E->Arg);
1427             break;
1428
1429         case AM65_ZPX_IND:
1430             /* (zeropage,x) */
1431             Chars += WriteOutput ("%*s(%s,x)", Space, "", E->Arg);
1432             break;
1433
1434         case AM65_ZP_INDY:
1435             /* (zeropage),y */
1436             Chars += WriteOutput ("%*s(%s),y", Space, "", E->Arg);
1437             break;
1438
1439         case AM65_ZP_IND:
1440             /* (zeropage) */
1441             Chars += WriteOutput ("%*s(%s)", Space, "", E->Arg);
1442             break;
1443
1444         case AM65_BRA:
1445             /* branch */
1446             Target = E->JumpTo? E->JumpTo->Name : E->Arg;
1447             Chars += WriteOutput ("%*s%s", Space, "", Target);
1448             break;
1449
1450         default:
1451             Internal ("Invalid addressing mode");
1452
1453     }
1454
1455     /* Print usage info if requested by the debugging flag */
1456     if (Debug) {
1457         char Use [128];
1458         char Chg [128];
1459         WriteOutput ("%*s; USE: %-12s CHG: %-12s SIZE: %u",
1460                      (int)(30-Chars), "",
1461                      RegInfoDesc (E->Use, Use),
1462                      RegInfoDesc (E->Chg, Chg),
1463                      E->Size);
1464
1465         if (E->RI) {
1466             char RegIn[32];
1467             char RegOut[32];
1468             WriteOutput ("    In %s  Out %s",
1469                          RegContentDesc (&E->RI->In, RegIn),
1470                          RegContentDesc (&E->RI->Out, RegOut));
1471         }
1472     }
1473
1474     /* Terminate the line */
1475     WriteOutput ("\n");
1476 }
1477
1478
1479
1480
1481
1482