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-2002 Ullrich von Bassewitz                                       */
  10 /*               Wacholderweg 14                                             */
  11 /*               D-70597 Stuttgart                                           */
  12 /* EMail:        uz@musoftware.de                                            */
  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 #include <string.h>
  38
  39 /* common */
  40 #include "chartype.h"
  41 #include "check.h"
  42 #include "debugflag.h"
  43 #include "xmalloc.h"
  44 #include "xsprintf.h"
  45
  46 /* cc65 */
  47 #include "codeinfo.h"
  48 #include "error.h"
  49 #include "global.h"
  50 #include "codelab.h"
  51 #include "opcodes.h"
  52 #include "codeent.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_BRA | 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->Arg    = GetArgCopy (Arg);
 248     E->Flags  = NumArg (E->Arg, &E->Num)? CEF_NUMARG : 0;
 249     E->Info   = D->Info;
 250     E->Size   = GetInsnSize (E->OPC, E->AM);
 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_MoveLabel (CodeLabel* L, CodeEntry* E)
 327 /* Move the code label L from it's former owner to the code entry E. */
 328 {
 329     /* Delete the label from the owner */
 330     CollDeleteItem (&L->Owner->Labels, L);
 331
 332     /* Set the new owner */
 333     CollAppend (&E->Labels, L);
 334     L->Owner = E;
 335 }
 336
 337
 338
 339 void CE_SetNumArg (CodeEntry* E, long Num)
 340 /* Set a new numeric argument for the given code entry that must already
 341  * have a numeric argument.
 342  */
 343 {
 344     char Buf[16];
 345
 346     /* Check that the entry has a numerical argument */
 347     CHECK (E->Flags & CEF_NUMARG);
 348
 349     /* Make the new argument string */
 350     if (E->Size == 2) {
 351         Num &= 0xFF;
 352         xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned) Num);
 353     } else if (E->Size == 3) {
 354         Num &= 0xFFFF;
 355         xsprintf (Buf, sizeof (Buf), "$%04X", (unsigned) Num);
 356     } else {
 357         Internal ("Invalid instruction size in CE_SetNumArg");
 358     }
 359
 360     /* Free the old argument */
 361     FreeArg (E->Arg);
 362
 363     /* Assign the new one */
 364     E->Arg = GetArgCopy (Buf);
 365
 366     /* Use the new numerical value */
 367     E->Num = Num;
 368 }
 369
 370
 371
 372 int CE_KnownImm (const CodeEntry* E)
 373 /* Return true if the argument of E is a known immediate value */
 374 {
 375     return (E->AM == AM65_IMM && (E->Flags & CEF_NUMARG) != 0);
 376 }
 377
 378
 379
 380 int CE_UseLoadFlags (const CodeEntry* E)
 381 /* Return true if the instruction uses any flags that are set by a load of
 382  * a register (N and Z).
 383  */
 384 {
 385     /* A branch will use the flags */
 386     if (E->Info & OF_FBRA) {
 387         return 1;
 388     }
 389
 390     /* Call of a boolean transformer routine will also use the flags */
 391     if (E->OPC == OP65_JSR) {
 392         /* Get the condition that is evaluated and check it */
 393         switch (FindBoolCmpCond (E->Arg)) {
 394             case CMP_EQ:
 395             case CMP_NE:
 396             case CMP_GT:
 397             case CMP_GE:
 398             case CMP_LT:
 399             case CMP_LE:
 400             case CMP_UGT:
 401             case CMP_ULE:
 402                 /* Will use the N or Z flags */
 403                 return 1;
 404
 405
 406             case CMP_UGE:       /* Uses only carry */
 407             case CMP_ULT:       /* Dito */
 408             default:            /* No bool transformer subroutine */
 409                 return 0;
 410         }
 411     }
 412
 413     /* Anything else */
 414     return 0;
 415 }
 416
 417
 418
 419 void CE_FreeRegInfo (CodeEntry* E)
 420 /* Free an existing register info struct */
 421 {
 422     if (E->RI) {
 423         FreeRegInfo (E->RI);
 424         E->RI = 0;
 425     }
 426 }
 427
 428
 429
 430 void CE_GenRegInfo (CodeEntry* E, RegContents* InputRegs)
 431 /* Generate register info for this instruction. If an old info exists, it is
 432  * overwritten.
 433  */
 434 {
 435     /* Pointers to the register contents */
 436     RegContents* In;
 437     RegContents* Out;
 438
 439     /* Function register usage */
 440     unsigned short Use, Chg;
 441
 442     /* If we don't have a register info struct, allocate one. */
 443     if (E->RI == 0) {
 444         E->RI = NewRegInfo (InputRegs);
 445     } else {
 446         if (InputRegs) {
 447             E->RI->In  = *InputRegs;
 448         } else {
 449             RC_Invalidate (&E->RI->In);
 450         }
 451         E->RI->Out2 = E->RI->Out = E->RI->In;
 452     }
 453
 454     /* Get pointers to the register contents */
 455     In  = &E->RI->In;
 456     Out = &E->RI->Out;
 457
 458     /* Handle the different instructions */
 459     switch (E->OPC) {
 460
 461         case OP65_ADC:
 462             /* We don't know the value of the carry, so the result is
 463              * always unknown.
 464              */
 465             Out->RegA = UNKNOWN_REGVAL;
 466             break;
 467
 468         case OP65_AND:
 469             if (RegValIsKnown (In->RegA)) {
 470                 if (CE_KnownImm (E)) {
 471                     Out->RegA = In->RegA & (short) E->Num;
 472                 } else if (E->AM == AM65_ZP) {
 473                     switch (GetKnownReg (E->Use, In)) {
 474                         case REG_TMP1:
 475                             Out->RegA = In->RegA & In->Tmp1;
 476                             break;
 477                         case REG_SREG_LO:
 478                             Out->RegA = In->RegA & In->SRegLo;
 479                             break;
 480                         case REG_SREG_HI:
 481                             Out->RegA = In->RegA & In->SRegHi;
 482                             break;
 483                         default:
 484                             Out->RegA = UNKNOWN_REGVAL;
 485                             break;
 486                     }
 487                 } else {
 488                     Out->RegA = UNKNOWN_REGVAL;
 489                 }
 490             }
 491             break;
 492
 493         case OP65_ASL:
 494             if (E->AM == AM65_ACC && In->RegA >= 0) {
 495                 Out->RegA = (In->RegA << 1) & 0xFF;
 496             } else if (E->AM == AM65_ZP) {
 497                 switch (GetKnownReg (E->Chg, In)) {
 498                     case REG_TMP1:
 499                         Out->Tmp1 = (In->Tmp1 << 1) & 0xFF;
 500                         break;
 501                     case REG_SREG_LO:
 502                         Out->SRegLo = (In->SRegLo << 1) & 0xFF;
 503                         break;
 504                     case REG_SREG_HI:
 505                         Out->SRegHi = (In->SRegHi << 1) & 0xFF;
 506                         break;
 507                 }
 508             } else if (E->AM == AM65_ZPX) {
 509                 /* Invalidates all ZP registers */
 510                 RC_InvalidateZP (Out);
 511             }
 512             break;
 513
 514         case OP65_BCC:
 515             break;
 516
 517         case OP65_BCS:
 518             break;
 519
 520         case OP65_BEQ:
 521             break;
 522
 523         case OP65_BIT:
 524             break;
 525
 526         case OP65_BMI:
 527             break;
 528
 529         case OP65_BNE:
 530             break;
 531
 532         case OP65_BPL:
 533             break;
 534
 535         case OP65_BRA:
 536             break;
 537
 538         case OP65_BRK:
 539             break;
 540
 541         case OP65_BVC:
 542             break;
 543
 544         case OP65_BVS:
 545             break;
 546
 547         case OP65_CLC:
 548             break;
 549
 550         case OP65_CLD:
 551             break;
 552
 553         case OP65_CLI:
 554             break;
 555
 556         case OP65_CLV:
 557             break;
 558
 559         case OP65_CMP:
 560             break;
 561
 562         case OP65_CPX:
 563             break;
 564
 565         case OP65_CPY:
 566             break;
 567
 568         case OP65_DEA:
 569             if (RegValIsKnown (In->RegA)) {
 570                 Out->RegA = (In->RegA - 1) & 0xFF;
 571             }
 572             break;
 573
 574         case OP65_DEC:
 575             if (E->AM == AM65_ACC && In->RegA >= 0) {
 576                 Out->RegA = (In->RegA - 1) & 0xFF;
 577             } else if (E->AM == AM65_ZP) {
 578                 switch (GetKnownReg (E->Chg, In)) {
 579                     case REG_TMP1:
 580                         Out->Tmp1 = (In->Tmp1 - 1) & 0xFF;
 581                         break;
 582                     case REG_SREG_LO:
 583                         Out->SRegLo = (In->SRegLo - 1) & 0xFF;
 584                         break;
 585                     case REG_SREG_HI:
 586                         Out->SRegHi = (In->SRegHi - 1) & 0xFF;
 587                         break;
 588                 }
 589             } else if (E->AM == AM65_ZPX) {
 590                 /* Invalidates all ZP registers */
 591                 RC_InvalidateZP (Out);
 592             }
 593             break;
 594
 595         case OP65_DEX:
 596             if (RegValIsKnown (In->RegX)) {
 597                 Out->RegX = (In->RegX - 1) & 0xFF;
 598             }
 599             break;
 600
 601         case OP65_DEY:
 602             if (RegValIsKnown (In->RegY)) {
 603                 Out->RegY = (In->RegY - 1) & 0xFF;
 604             }
 605             break;
 606
 607         case OP65_EOR:
 608             if (RegValIsKnown (In->RegA)) {
 609                 if (CE_KnownImm (E)) {
 610                     Out->RegA = In->RegA ^ (short) E->Num;
 611                 } else if (E->AM == AM65_ZP) {
 612                     switch (GetKnownReg (E->Use, In)) {
 613                         case REG_TMP1:
 614                             Out->RegA = In->RegA ^ In->Tmp1;
 615                             break;
 616                         case REG_SREG_LO:
 617                             Out->RegA = In->RegA ^ In->SRegLo;
 618                             break;
 619                         case REG_SREG_HI:
 620                             Out->RegA = In->RegA ^ In->SRegHi;
 621                             break;
 622                         default:
 623                             Out->RegA = UNKNOWN_REGVAL;
 624                             break;
 625                     }
 626                 } else {
 627                     Out->RegA = UNKNOWN_REGVAL;
 628                 }
 629             }
 630             break;
 631
 632         case OP65_INA:
 633             if (RegValIsKnown (In->RegA)) {
 634                 Out->RegA = (In->RegA + 1) & 0xFF;
 635             }
 636             break;
 637
 638         case OP65_INC:
 639             if (E->AM == AM65_ACC && In->RegA >= 0) {
 640                 Out->RegA = (In->RegA + 1) & 0xFF;
 641             } else if (E->AM == AM65_ZP) {
 642                 switch (GetKnownReg (E->Chg, In)) {
 643                     case REG_TMP1:
 644                         Out->Tmp1 = (In->Tmp1 + 1) & 0xFF;
 645                         break;
 646                     case REG_SREG_LO:
 647                         Out->SRegLo = (In->SRegLo + 1) & 0xFF;
 648                         break;
 649                     case REG_SREG_HI:
 650                         Out->SRegHi = (In->SRegHi + 1) & 0xFF;
 651                         break;
 652                 }
 653             } else if (E->AM == AM65_ZPX) {
 654                 /* Invalidates all ZP registers */
 655                 RC_InvalidateZP (Out);
 656             }
 657             break;
 658
 659         case OP65_INX:
 660             if (RegValIsKnown (In->RegX)) {
 661                 Out->RegX = (In->RegX + 1) & 0xFF;
 662             }
 663             break;
 664
 665         case OP65_INY:
 666             if (RegValIsKnown (In->RegY)) {
 667                 Out->RegY = (In->RegY + 1) & 0xFF;
 668             }
 669             break;
 670
 671         case OP65_JCC:
 672             break;
 673
 674         case OP65_JCS:
 675             break;
 676
 677         case OP65_JEQ:
 678             break;
 679
 680         case OP65_JMI:
 681             break;
 682
 683         case OP65_JMP:
 684             break;
 685
 686         case OP65_JNE:
 687             break;
 688
 689         case OP65_JPL:
 690             break;
 691
 692         case OP65_JSR:
 693             /* Get the code info for the function */
 694             GetFuncInfo (E->Arg, &Use, &Chg);
 695             if (Chg & REG_A) {
 696                 Out->RegA = UNKNOWN_REGVAL;
 697             }
 698             if (Chg & REG_X) {
 699                 Out->RegX = UNKNOWN_REGVAL;
 700             }
 701             if (Chg & REG_Y) {
 702                 Out->RegY = UNKNOWN_REGVAL;
 703             }
 704             if (Chg & REG_TMP1) {
 705                 Out->Tmp1 = UNKNOWN_REGVAL;
 706             }
 707             if (Chg & REG_SREG_LO) {
 708                 Out->SRegLo = UNKNOWN_REGVAL;
 709             }
 710             if (Chg & REG_SREG_HI) {
 711                 Out->SRegHi = UNKNOWN_REGVAL;
 712             }
 713             /* ## FIXME: Quick hack for some known functions: */
 714             if (strcmp (E->Arg, "tosandax") == 0) {
 715                 if (In->RegA == 0) {
 716                     Out->RegA = 0;
 717                 }
 718                 if (In->RegX == 0) {
 719                     Out->RegX = 0;
 720                 }
 721             } else if (strcmp (E->Arg, "tosorax") == 0) {
 722                 if (In->RegA == 0xFF) {
 723                     Out->RegA = 0xFF;
 724                 }
 725                 if (In->RegX == 0xFF) {
 726                     Out->RegX = 0xFF;
 727                 }
 728             } else if (FindBoolCmpCond (E->Arg) != CMP_INV) {
 729                 Out->RegX = 0;
 730             }
 731             break;
 732
 733         case OP65_JVC:
 734             break;
 735
 736         case OP65_JVS:
 737             break;
 738
 739         case OP65_LDA:
 740             if (CE_KnownImm (E)) {
 741                 Out->RegA = (unsigned char) E->Num;
 742             } else if (E->AM == AM65_ZP) {
 743                 switch (GetKnownReg (E->Use, In)) {
 744                     case REG_TMP1:
 745                         Out->RegA = In->Tmp1;
 746                         break;
 747                     case REG_SREG_LO:
 748                         Out->RegA = In->SRegLo;
 749                         break;
 750                     case REG_SREG_HI:
 751                         Out->RegA = In->SRegHi;
 752                         break;
 753                     default:
 754                         Out->RegA = UNKNOWN_REGVAL;
 755                         break;
 756                 }
 757             } else {
 758                 /* A is now unknown */
 759                 Out->RegA = UNKNOWN_REGVAL;
 760             }
 761             break;
 762
 763         case OP65_LDX:
 764             if (CE_KnownImm (E)) {
 765                 Out->RegX = (unsigned char) E->Num;
 766             } else if (E->AM == AM65_ZP) {
 767                 switch (GetKnownReg (E->Use, In)) {
 768                     case REG_TMP1:
 769                         Out->RegX = In->Tmp1;
 770                         break;
 771                     case REG_SREG_LO:
 772                         Out->RegX = In->SRegLo;
 773                         break;
 774                     case REG_SREG_HI:
 775                         Out->RegX = In->SRegHi;
 776                         break;
 777                     default:
 778                         Out->RegX = UNKNOWN_REGVAL;
 779                         break;
 780                 }
 781             } else {
 782                 /* X is now unknown */
 783                 Out->RegX = UNKNOWN_REGVAL;
 784             }
 785             break;
 786
 787         case OP65_LDY:
 788             if (CE_KnownImm (E)) {
 789                 Out->RegY = (unsigned char) E->Num;
 790             } else if (E->AM == AM65_ZP) {
 791                 switch (GetKnownReg (E->Use, In)) {
 792                     case REG_TMP1:
 793                         Out->RegY = In->Tmp1;
 794                         break;
 795                     case REG_SREG_LO:
 796                         Out->RegY = In->SRegLo;
 797                         break;
 798                     case REG_SREG_HI:
 799                         Out->RegY = In->SRegHi;
 800                         break;
 801                     default:
 802                         Out->RegY = UNKNOWN_REGVAL;
 803                         break;
 804                 }
 805             } else {
 806                 /* Y is now unknown */
 807                 Out->RegY = UNKNOWN_REGVAL;
 808             }
 809             break;
 810
 811         case OP65_LSR:
 812             if (E->AM == AM65_ACC && In->RegA >= 0) {
 813                 Out->RegA = (In->RegA >> 1) & 0xFF;
 814             } else if (E->AM == AM65_ZP) {
 815                 switch (GetKnownReg (E->Chg, In)) {
 816                     case REG_TMP1:
 817                         Out->Tmp1 = (In->Tmp1 >> 1) & 0xFF;
 818                         break;
 819                     case REG_SREG_LO:
 820                         Out->SRegLo = (In->SRegLo >> 1) & 0xFF;
 821                         break;
 822                     case REG_SREG_HI:
 823                         Out->SRegHi = (In->SRegHi >> 1) & 0xFF;
 824                         break;
 825                 }
 826             } else if (E->AM == AM65_ZPX) {
 827                 /* Invalidates all ZP registers */
 828                 RC_InvalidateZP (Out);
 829             }
 830             break;
 831
 832         case OP65_NOP:
 833             break;
 834
 835         case OP65_ORA:
 836             if (RegValIsKnown (In->RegA)) {
 837                 if (CE_KnownImm (E)) {
 838                     Out->RegA = In->RegA | (short) E->Num;
 839                 } else if (E->AM == AM65_ZP) {
 840                     switch (GetKnownReg (E->Use, In)) {
 841                         case REG_TMP1:
 842                             Out->RegA = In->RegA | In->Tmp1;
 843                             break;
 844                         case REG_SREG_LO:
 845                             Out->RegA = In->RegA | In->SRegLo;
 846                             break;
 847                         case REG_SREG_HI:
 848                             Out->RegA = In->RegA | In->SRegHi;
 849                             break;
 850                         default:
 851                             Out->RegA = UNKNOWN_REGVAL;
 852                             break;
 853                     }
 854                 } else {
 855                     /* A is now unknown */
 856                     Out->RegA = UNKNOWN_REGVAL;
 857                 }
 858             }
 859             break;
 860
 861         case OP65_PHA:
 862             break;
 863
 864         case OP65_PHP:
 865             break;
 866
 867         case OP65_PHX:
 868             break;
 869
 870         case OP65_PHY:
 871             break;
 872
 873         case OP65_PLA:
 874             Out->RegA = -1;
 875             break;
 876
 877         case OP65_PLP:
 878             break;
 879
 880         case OP65_PLX:
 881             Out->RegX = -1;
 882             break;
 883
 884         case OP65_PLY:
 885             Out->RegY = -1;
 886             break;
 887
 888         case OP65_ROL:
 889             /* We don't know the value of the carry bit */
 890             if (E->AM == AM65_ACC) {
 891                 Out->RegA = UNKNOWN_REGVAL;
 892             } else if (E->AM == AM65_ZP) {
 893                 switch (GetKnownReg (E->Chg, In)) {
 894                     case REG_TMP1:
 895                         Out->Tmp1 = UNKNOWN_REGVAL;
 896                         break;
 897                     case REG_SREG_LO:
 898                         Out->SRegLo = UNKNOWN_REGVAL;
 899                         break;
 900                     case REG_SREG_HI:
 901                         Out->SRegHi = UNKNOWN_REGVAL;
 902                         break;
 903                 }
 904             } else if (E->AM == AM65_ZPX) {
 905                 /* Invalidates all ZP registers */
 906                 RC_InvalidateZP (Out);
 907             }
 908             break;
 909
 910         case OP65_ROR:
 911             /* We don't know the value of the carry bit */
 912             if (E->AM == AM65_ACC) {
 913                 Out->RegA = UNKNOWN_REGVAL;
 914             } else if (E->AM == AM65_ZP) {
 915                 switch (GetKnownReg (E->Chg, In)) {
 916                     case REG_TMP1:
 917                         Out->Tmp1 = UNKNOWN_REGVAL;
 918                         break;
 919                     case REG_SREG_LO:
 920                         Out->SRegLo = UNKNOWN_REGVAL;
 921                         break;
 922                     case REG_SREG_HI:
 923                         Out->SRegHi = UNKNOWN_REGVAL;
 924                         break;
 925                 }
 926             } else if (E->AM == AM65_ZPX) {
 927                 /* Invalidates all ZP registers */
 928                 RC_InvalidateZP (Out);
 929             }
 930             break;
 931
 932         case OP65_RTI:
 933             break;
 934
 935         case OP65_RTS:
 936             break;
 937
 938         case OP65_SBC:
 939             /* We don't know the value of the carry bit */
 940             Out->RegA = -1;
 941             break;
 942
 943         case OP65_SEC:
 944             break;
 945
 946         case OP65_SED:
 947             break;
 948
 949         case OP65_SEI:
 950             break;
 951
 952         case OP65_STA:
 953             if (E->AM == AM65_ZP) {
 954                 switch (GetKnownReg (E->Chg, 0)) {
 955                     case REG_TMP1:
 956                         Out->Tmp1 = In->RegA;
 957                         break;
 958                     case REG_SREG_LO:
 959                         Out->SRegLo = In->RegA;
 960                         break;
 961                     case REG_SREG_HI:
 962                         Out->SRegHi = In->RegA;
 963                         break;
 964                 }
 965             } else if (E->AM == AM65_ZPX) {
 966                 /* Invalidates all ZP registers */
 967                 RC_InvalidateZP (Out);
 968             }
 969             break;
 970
 971         case OP65_STX:
 972             if (E->AM == AM65_ZP) {
 973                 switch (GetKnownReg (E->Chg, 0)) {
 974                     case REG_TMP1:
 975                         Out->Tmp1 = In->RegX;
 976                         break;
 977                     case REG_SREG_LO:
 978                         Out->SRegLo = In->RegX;
 979                         break;
 980                     case REG_SREG_HI:
 981                         Out->SRegHi = In->RegX;
 982                         break;
 983                 }
 984             } else if (E->AM == AM65_ZPX) {
 985                 /* Invalidates all ZP registers */
 986                 RC_InvalidateZP (Out);
 987             }
 988             break;
 989
 990         case OP65_STY:
 991             if (E->AM == AM65_ZP) {
 992                 switch (GetKnownReg (E->Chg, 0)) {
 993                     case REG_TMP1:
 994                         Out->Tmp1 = In->RegY;
 995                         break;
 996                     case REG_SREG_LO:
 997                         Out->SRegLo = In->RegY;
 998                         break;
 999                     case REG_SREG_HI:
1000                         Out->SRegHi = In->RegY;
1001                         break;
1002                 }
1003             } else if (E->AM == AM65_ZPX) {
1004                 /* Invalidates all ZP registers */
1005                 RC_InvalidateZP (Out);
1006             }
1007             break;
1008
1009         case OP65_STZ:
1010             if (E->AM == AM65_ZP) {
1011                 switch (GetKnownReg (E->Chg, 0)) {
1012                     case REG_TMP1:
1013                         Out->Tmp1 = 0;
1014                         break;
1015                     case REG_SREG_LO:
1016                         Out->SRegLo = 0;
1017                         break;
1018                     case REG_SREG_HI:
1019                         Out->SRegHi = 0;
1020                         break;
1021                 }
1022             } else if (E->AM == AM65_ZPX) {
1023                 /* Invalidates all ZP registers */
1024                 RC_InvalidateZP (Out);
1025             }
1026             break;
1027
1028         case OP65_TAX:
1029             Out->RegX = In->RegA;
1030             break;
1031
1032         case OP65_TAY:
1033             Out->RegY = In->RegA;
1034             break;
1035
1036         case OP65_TRB:
1037             if (E->AM == AM65_ZPX) {
1038                 /* Invalidates all ZP registers */
1039                 RC_InvalidateZP (Out);
1040             } else if (E->AM == AM65_ZP) {
1041                 if (In->RegA >= 0) {
1042                     switch (GetKnownReg (E->Chg, In)) {
1043                         case REG_TMP1:
1044                             Out->Tmp1 &= ~In->RegA;
1045                             break;
1046                         case REG_SREG_LO:
1047                             Out->SRegLo &= ~In->RegA;
1048                             break;
1049                         case REG_SREG_HI:
1050                             Out->SRegHi &= ~In->RegA;
1051                             break;
1052                     }
1053                 } else {
1054                     switch (GetKnownReg (E->Chg, In)) {
1055                         case REG_TMP1:
1056                             Out->Tmp1 = UNKNOWN_REGVAL;
1057                             break;
1058                         case REG_SREG_LO:
1059                             Out->SRegLo = UNKNOWN_REGVAL;
1060                             break;
1061                         case REG_SREG_HI:
1062                             Out->SRegHi = UNKNOWN_REGVAL;
1063                             break;
1064                     }
1065                 }
1066             }
1067             break;
1068
1069         case OP65_TSB:
1070             if (E->AM == AM65_ZPX) {
1071                 /* Invalidates all ZP registers */
1072                 RC_InvalidateZP (Out);
1073             } else if (E->AM == AM65_ZP) {
1074                 if (In->RegA >= 0) {
1075                     switch (GetKnownReg (E->Chg, In)) {
1076                         case REG_TMP1:
1077                             Out->Tmp1 |= In->RegA;
1078                             break;
1079                         case REG_SREG_LO:
1080                             Out->SRegLo |= In->RegA;
1081                             break;
1082                         case REG_SREG_HI:
1083                             Out->SRegHi |= In->RegA;
1084                             break;
1085                     }
1086                 } else {
1087                     switch (GetKnownReg (E->Chg, In)) {
1088                         case REG_TMP1:
1089                             Out->Tmp1 = UNKNOWN_REGVAL;
1090                             break;
1091                         case REG_SREG_LO:
1092                             Out->SRegLo = UNKNOWN_REGVAL;
1093                             break;
1094                         case REG_SREG_HI:
1095                             Out->SRegHi = UNKNOWN_REGVAL;
1096                             break;
1097                     }
1098                 }
1099             }
1100             break;
1101
1102         case OP65_TSX:
1103             Out->RegX = UNKNOWN_REGVAL;
1104             break;
1105
1106         case OP65_TXA:
1107             Out->RegA = In->RegX;
1108             break;
1109
1110         case OP65_TXS:
1111             break;
1112
1113         case OP65_TYA:
1114             Out->RegA = In->RegY;
1115             break;
1116
1117         default:
1118             break;
1119
1120     }
1121 }
1122
1123
1124
1125 static char* RegInfoDesc (unsigned U, char* Buf)
1126 /* Return a string containing register info */
1127 {
1128     Buf[0] = '\0';
1129
1130     strcat (Buf, U & REG_SREG_HI? "H" : "_");
1131     strcat (Buf, U & REG_SREG_LO? "L" : "_");
1132     strcat (Buf, U & REG_A?       "A" : "_");
1133     strcat (Buf, U & REG_X?       "X" : "_");
1134     strcat (Buf, U & REG_Y?       "Y" : "_");
1135     strcat (Buf, U & REG_TMP1?    "T1" : "__");
1136     strcat (Buf, U & REG_PTR1?    "1" : "_");
1137     strcat (Buf, U & REG_PTR2?    "2" : "_");
1138     strcat (Buf, U & REG_SAVE?    "V"  : "_");
1139     strcat (Buf, U & REG_SP?      "S" : "_");
1140
1141     return Buf;
1142 }
1143
1144
1145
1146 void CE_Output (const CodeEntry* E, FILE* F)
1147 /* Output the code entry to a file */
1148 {
1149     const OPCDesc* D;
1150     unsigned Chars;
1151     const char* Target;
1152
1153     /* If we have a label, print that */
1154     unsigned LabelCount = CollCount (&E->Labels);
1155     unsigned I;
1156     for (I = 0; I < LabelCount; ++I) {
1157         CL_Output (CollConstAt (&E->Labels, I), F);
1158     }
1159
1160     /* Get the opcode description */
1161     D = GetOPCDesc (E->OPC);
1162
1163     /* Print the mnemonic */
1164     Chars = fprintf (F, "\t%s", D->Mnemo);
1165
1166     /* Print the operand */
1167     switch (E->AM) {
1168
1169         case AM_IMP:
1170         case AM65_IMP:
1171             /* implicit */
1172             break;
1173
1174         case AM65_ACC:
1175             /* accumulator */
1176             Chars += fprintf (F, "%*sa", 9-Chars, "");
1177             break;
1178
1179         case AM_IMM:
1180         case AM65_IMM:
1181             /* immidiate */
1182             Chars += fprintf (F, "%*s#%s", 9-Chars, "", E->Arg);
1183             break;
1184
1185         case AM_ABS:
1186         case AM65_ZP:
1187         case AM65_ABS:
1188             /* zeropage and absolute */
1189             Chars += fprintf (F, "%*s%s", 9-Chars, "", E->Arg);
1190             break;
1191
1192         case AM65_ZPX:
1193         case AM65_ABSX:
1194             /* zeropage,X and absolute,X */
1195             Chars += fprintf (F, "%*s%s,x", 9-Chars, "", E->Arg);
1196             break;
1197
1198         case AM65_ABSY:
1199             /* absolute,Y */
1200             Chars += fprintf (F, "%*s%s,y", 9-Chars, "", E->Arg);
1201             break;
1202
1203         case AM65_ZPX_IND:
1204             /* (zeropage,x) */
1205             Chars += fprintf (F, "%*s(%s,x)", 9-Chars, "", E->Arg);
1206             break;
1207
1208         case AM65_ZP_INDY:
1209             /* (zeropage),y */
1210             Chars += fprintf (F, "%*s(%s),y", 9-Chars, "", E->Arg);
1211             break;
1212
1213         case AM65_ZP_IND:
1214             /* (zeropage) */
1215             Chars += fprintf (F, "%*s(%s)", 9-Chars, "", E->Arg);
1216             break;
1217
1218         case AM65_BRA:
1219             /* branch */
1220             Target = E->JumpTo? E->JumpTo->Name : E->Arg;
1221             Chars += fprintf (F, "%*s%s", 9-Chars, "", Target);
1222             break;
1223
1224         default:
1225             Internal ("Invalid addressing mode");
1226
1227     }
1228
1229     /* Print usage info if requested by the debugging flag */
1230     if (Debug) {
1231         char Use [128];
1232         char Chg [128];
1233         fprintf (F,
1234                  "%*s; USE: %-12s CHG: %-12s SIZE: %u\n",
1235                  30-Chars, "",
1236                  RegInfoDesc (E->Use, Use),
1237                  RegInfoDesc (E->Chg, Chg),
1238                  E->Size);
1239     } else {
1240         /* Terminate the line */
1241         fprintf (F, "\n");
1242     }
1243 }
1244
1245
1246
1247
1248
1249