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