1 /*****************************************************************************/
5 /* Code segment entry */
9 /* (C) 2001-2009, Ullrich von Bassewitz */
10 /* Roemerstrasse 52 */
11 /* D-70794 Filderstadt */
12 /* EMail: uz@cc65.org */
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. */
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: */
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 */
32 /*****************************************************************************/
41 #include "debugflag.h"
56 /*****************************************************************************/
58 /*****************************************************************************/
63 static char EmptyArg[] = "";
67 /*****************************************************************************/
68 /* Helper functions */
69 /*****************************************************************************/
73 static void FreeArg (char* Arg)
74 /* Free a code entry argument */
76 if (Arg != EmptyArg) {
83 static char* GetArgCopy (const char* Arg)
84 /* Create an argument copy for assignment */
86 if (Arg && Arg[0] != '\0') {
90 /* Use the empty argument string */
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.
105 /* Determine the base */
110 } else if (*Arg == '%') {
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.
118 Val = strtoul (Arg, &End, Base);
120 /* Check if the conversion was successful */
123 /* Could not convert */
138 static void SetUseChgInfo (CodeEntry* E, const OPCDesc* D)
139 /* Set the Use and Chg in E */
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.
147 if ((E->Info & (OF_UBRA | OF_CALL)) != 0 && E->JumpTo == 0) {
148 /* A subroutine call or jump to external symbol (function exit) */
149 GetFuncInfo (E->Arg, &E->Use, &E->Chg);
151 /* Some other instruction. Use the values from the opcode description
152 * plus addressing mode info.
154 E->Use = D->Use | GetAMUseInfo (E->AM);
157 /* Check for special zero page registers used */
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 */
171 /* Be conservative: */
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) {
186 E->Chg |= Info->ByteUse;
189 E->Use |= Info->ByteUse;
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;
205 /* Keep gcc silent */
213 /*****************************************************************************/
215 /*****************************************************************************/
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
228 xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned char) Num);
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 */
238 /* Get the opcode description */
239 const OPCDesc* D = GetOPCDesc (OPC);
241 /* Allocate memory */
242 CodeEntry* E = xmalloc (sizeof (CodeEntry));
244 /* Initialize the fields */
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 */
252 E->LI = UseLineInfo (LI);
254 SetUseChgInfo (E, D);
255 InitCollection (&E->Labels);
257 /* If we have a label given, add this entry to the label */
259 CollAppend (&JumpTo->JumpFrom, E);
262 /* Return the initialized struct */
268 void FreeCodeEntry (CodeEntry* E)
269 /* Free the given code entry */
271 /* Free the string argument if we have one */
274 /* Cleanup the collection */
275 DoneCollection (&E->Labels);
277 /* Release the line info */
278 ReleaseLineInfo (E->LI);
280 /* Delete the register info */
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.
294 /* Get the opcode descriptor */
295 const OPCDesc* D = GetOPCDesc (OPC);
297 /* Replace the opcode */
300 E->Size = GetInsnSize (E->OPC, E->AM);
301 SetUseChgInfo (E, D);
306 int CodeEntriesAreEqual (const CodeEntry* E1, const CodeEntry* E2)
307 /* Check if both code entries are equal */
309 return (E1->OPC == E2->OPC && E1->AM == E2->AM && strcmp (E1->Arg, E2->Arg) == 0);
314 void CE_AttachLabel (CodeEntry* E, CodeLabel* L)
315 /* Attach the label to the entry */
317 /* Add it to the entries label list */
318 CollAppend (&E->Labels, L);
320 /* Tell the label about it's owner */
326 void CE_ClearJumpTo (CodeEntry* E)
327 /* Clear the JumpTo entry and the argument (which contained the name of the
328 * label). Note: The function will not clear the backpointer from the label,
329 * so use it with care.
332 /* Clear the JumpTo entry */
335 /* Clear the argument and assign the empty one */
342 void CE_MoveLabel (CodeLabel* L, CodeEntry* E)
343 /* Move the code label L from it's former owner to the code entry E. */
345 /* Delete the label from the owner */
346 CollDeleteItem (&L->Owner->Labels, L);
348 /* Set the new owner */
349 CollAppend (&E->Labels, L);
355 void CE_SetArg (CodeEntry* E, const char* Arg)
356 /* Replace the argument by the new one. */
358 /* Free the old argument */
361 /* Assign the new one */
362 E->Arg = GetArgCopy (Arg);
367 void CE_SetNumArg (CodeEntry* E, long Num)
368 /* Set a new numeric argument for the given code entry that must already
369 * have a numeric argument.
374 /* Check that the entry has a numerical argument */
375 CHECK (E->Flags & CEF_NUMARG);
377 /* Make the new argument string */
380 xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned) Num);
381 } else if (E->Size == 3) {
383 xsprintf (Buf, sizeof (Buf), "$%04X", (unsigned) Num);
385 Internal ("Invalid instruction size in CE_SetNumArg");
388 /* Replace the argument by the new one */
391 /* Use the new numerical value */
397 int CE_IsConstImm (const CodeEntry* E)
398 /* Return true if the argument of E is a constant immediate value */
400 return (E->AM == AM65_IMM && (E->Flags & CEF_NUMARG) != 0);
405 int CE_IsKnownImm (const CodeEntry* E, unsigned long Num)
406 /* Return true if the argument of E is a constant immediate value that is
410 return E->AM == AM65_IMM &&
411 (E->Flags & CEF_NUMARG) != 0 &&
417 int CE_UseLoadFlags (const CodeEntry* E)
418 /* Return true if the instruction uses any flags that are set by a load of
419 * a register (N and Z).
422 /* Follow unconditional branches, but beware of endless loops. After this,
423 * E will point to the first entry that is not a branch.
425 if (E->Info & OF_UBRA) {
426 Collection C = AUTO_COLLECTION_INITIALIZER;
428 /* Follow the chain */
429 while (E->Info & OF_UBRA) {
431 /* Remember the entry so we can detect loops */
432 CollAppend (&C, (void*) E);
434 /* Check the target */
435 if (E->JumpTo == 0 || CollIndex (&C, E->JumpTo->Owner) >= 0) {
436 /* Unconditional jump to external symbol, or endless loop. */
438 return 0; /* Flags not used */
441 /* Follow the chain */
442 E = E->JumpTo->Owner;
445 /* Delete the collection */
449 /* A branch will use the flags */
450 if (E->Info & OF_FBRA) {
454 /* Call of a boolean transformer routine will also use the flags */
455 if (E->OPC == OP65_JSR) {
456 /* Get the condition that is evaluated and check it */
457 switch (FindBoolCmpCond (E->Arg)) {
466 /* Will use the N or Z flags */
470 case CMP_UGE: /* Uses only carry */
471 case CMP_ULT: /* Dito */
472 default: /* No bool transformer subroutine */
483 void CE_FreeRegInfo (CodeEntry* E)
484 /* Free an existing register info struct */
494 void CE_GenRegInfo (CodeEntry* E, RegContents* InputRegs)
495 /* Generate register info for this instruction. If an old info exists, it is
499 /* Pointers to the register contents */
503 /* Function register usage */
504 unsigned short Use, Chg;
506 /* If we don't have a register info struct, allocate one. */
508 E->RI = NewRegInfo (InputRegs);
511 E->RI->In = *InputRegs;
513 RC_Invalidate (&E->RI->In);
515 E->RI->Out2 = E->RI->Out = E->RI->In;
518 /* Get pointers to the register contents */
522 /* Handle the different instructions */
526 /* We don't know the value of the carry, so the result is
529 Out->RegA = UNKNOWN_REGVAL;
533 if (RegValIsKnown (In->RegA)) {
534 if (CE_IsConstImm (E)) {
535 Out->RegA = In->RegA & (short) E->Num;
536 } else if (E->AM == AM65_ZP) {
537 switch (GetKnownReg (E->Use & REG_ZP, In)) {
539 Out->RegA = In->RegA & In->Tmp1;
542 Out->RegA = In->RegA & In->Ptr1Lo;
545 Out->RegA = In->RegA & In->Ptr1Hi;
548 Out->RegA = In->RegA & In->SRegLo;
551 Out->RegA = In->RegA & In->SRegHi;
554 Out->RegA = UNKNOWN_REGVAL;
558 Out->RegA = UNKNOWN_REGVAL;
560 } else if (CE_IsKnownImm (E, 0)) {
561 /* A and $00 does always give zero */
567 if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
568 Out->RegA = (In->RegA << 1) & 0xFF;
569 } else if (E->AM == AM65_ZP) {
570 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
572 Out->Tmp1 = (In->Tmp1 << 1) & 0xFF;
575 Out->Ptr1Lo = (In->Ptr1Lo << 1) & 0xFF;
578 Out->Ptr1Hi = (In->Ptr1Hi << 1) & 0xFF;
581 Out->SRegLo = (In->SRegLo << 1) & 0xFF;
584 Out->SRegHi = (In->SRegHi << 1) & 0xFF;
587 } else if (E->AM == AM65_ZPX) {
588 /* Invalidates all ZP registers */
589 RC_InvalidateZP (Out);
648 if (RegValIsKnown (In->RegA)) {
649 Out->RegA = (In->RegA - 1) & 0xFF;
654 if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
655 Out->RegA = (In->RegA - 1) & 0xFF;
656 } else if (E->AM == AM65_ZP) {
657 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
659 Out->Tmp1 = (In->Tmp1 - 1) & 0xFF;
662 Out->Ptr1Lo = (In->Ptr1Lo - 1) & 0xFF;
665 Out->Ptr1Hi = (In->Ptr1Hi - 1) & 0xFF;
668 Out->SRegLo = (In->SRegLo - 1) & 0xFF;
671 Out->SRegHi = (In->SRegHi - 1) & 0xFF;
674 } else if (E->AM == AM65_ZPX) {
675 /* Invalidates all ZP registers */
676 RC_InvalidateZP (Out);
681 if (RegValIsKnown (In->RegX)) {
682 Out->RegX = (In->RegX - 1) & 0xFF;
687 if (RegValIsKnown (In->RegY)) {
688 Out->RegY = (In->RegY - 1) & 0xFF;
693 if (RegValIsKnown (In->RegA)) {
694 if (CE_IsConstImm (E)) {
695 Out->RegA = In->RegA ^ (short) E->Num;
696 } else if (E->AM == AM65_ZP) {
697 switch (GetKnownReg (E->Use & REG_ZP, In)) {
699 Out->RegA = In->RegA ^ In->Tmp1;
702 Out->RegA = In->RegA ^ In->Ptr1Lo;
705 Out->RegA = In->RegA ^ In->Ptr1Hi;
708 Out->RegA = In->RegA ^ In->SRegLo;
711 Out->RegA = In->RegA ^ In->SRegHi;
714 Out->RegA = UNKNOWN_REGVAL;
718 Out->RegA = UNKNOWN_REGVAL;
724 if (RegValIsKnown (In->RegA)) {
725 Out->RegA = (In->RegA + 1) & 0xFF;
730 if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
731 Out->RegA = (In->RegA + 1) & 0xFF;
732 } else if (E->AM == AM65_ZP) {
733 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
735 Out->Tmp1 = (In->Tmp1 + 1) & 0xFF;
738 Out->Ptr1Lo = (In->Ptr1Lo + 1) & 0xFF;
741 Out->Ptr1Hi = (In->Ptr1Hi + 1) & 0xFF;
744 Out->SRegLo = (In->SRegLo + 1) & 0xFF;
747 Out->SRegHi = (In->SRegHi + 1) & 0xFF;
750 } else if (E->AM == AM65_ZPX) {
751 /* Invalidates all ZP registers */
752 RC_InvalidateZP (Out);
757 if (RegValIsKnown (In->RegX)) {
758 Out->RegX = (In->RegX + 1) & 0xFF;
763 if (RegValIsKnown (In->RegY)) {
764 Out->RegY = (In->RegY + 1) & 0xFF;
790 /* Get the code info for the function */
791 GetFuncInfo (E->Arg, &Use, &Chg);
793 Out->RegA = UNKNOWN_REGVAL;
796 Out->RegX = UNKNOWN_REGVAL;
799 Out->RegY = UNKNOWN_REGVAL;
801 if (Chg & REG_TMP1) {
802 Out->Tmp1 = UNKNOWN_REGVAL;
804 if (Chg & REG_PTR1_LO) {
805 Out->Ptr1Lo = UNKNOWN_REGVAL;
807 if (Chg & REG_PTR1_HI) {
808 Out->Ptr1Hi = UNKNOWN_REGVAL;
810 if (Chg & REG_SREG_LO) {
811 Out->SRegLo = UNKNOWN_REGVAL;
813 if (Chg & REG_SREG_HI) {
814 Out->SRegHi = UNKNOWN_REGVAL;
816 /* ## FIXME: Quick hack for some known functions: */
817 if (strcmp (E->Arg, "tosandax") == 0) {
824 } else if (strcmp (E->Arg, "tosorax") == 0) {
825 if (In->RegA == 0xFF) {
828 if (In->RegX == 0xFF) {
831 } else if (FindBoolCmpCond (E->Arg) != CMP_INV) {
843 if (CE_IsConstImm (E)) {
844 Out->RegA = (unsigned char) E->Num;
845 } else if (E->AM == AM65_ZP) {
846 switch (GetKnownReg (E->Use & REG_ZP, In)) {
848 Out->RegA = In->Tmp1;
851 Out->RegA = In->Ptr1Lo;
854 Out->RegA = In->Ptr1Hi;
857 Out->RegA = In->SRegLo;
860 Out->RegA = In->SRegHi;
863 Out->RegA = UNKNOWN_REGVAL;
867 /* A is now unknown */
868 Out->RegA = UNKNOWN_REGVAL;
873 if (CE_IsConstImm (E)) {
874 Out->RegX = (unsigned char) E->Num;
875 } else if (E->AM == AM65_ZP) {
876 switch (GetKnownReg (E->Use & REG_ZP, In)) {
878 Out->RegX = In->Tmp1;
881 Out->RegX = In->Ptr1Lo;
884 Out->RegX = In->Ptr1Hi;
887 Out->RegX = In->SRegLo;
890 Out->RegX = In->SRegHi;
893 Out->RegX = UNKNOWN_REGVAL;
897 /* X is now unknown */
898 Out->RegX = UNKNOWN_REGVAL;
903 if (CE_IsConstImm (E)) {
904 Out->RegY = (unsigned char) E->Num;
905 } else if (E->AM == AM65_ZP) {
906 switch (GetKnownReg (E->Use & REG_ZP, In)) {
908 Out->RegY = In->Tmp1;
911 Out->RegY = In->Ptr1Lo;
914 Out->RegY = In->Ptr1Hi;
917 Out->RegY = In->SRegLo;
920 Out->RegY = In->SRegHi;
923 Out->RegY = UNKNOWN_REGVAL;
927 /* Y is now unknown */
928 Out->RegY = UNKNOWN_REGVAL;
933 if (E->AM == AM65_ACC && RegValIsKnown (In->RegA)) {
934 Out->RegA = (In->RegA >> 1) & 0xFF;
935 } else if (E->AM == AM65_ZP) {
936 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
938 Out->Tmp1 = (In->Tmp1 >> 1) & 0xFF;
941 Out->Ptr1Lo = (In->Ptr1Lo >> 1) & 0xFF;
944 Out->Ptr1Hi = (In->Ptr1Hi >> 1) & 0xFF;
947 Out->SRegLo = (In->SRegLo >> 1) & 0xFF;
950 Out->SRegHi = (In->SRegHi >> 1) & 0xFF;
953 } else if (E->AM == AM65_ZPX) {
954 /* Invalidates all ZP registers */
955 RC_InvalidateZP (Out);
963 if (RegValIsKnown (In->RegA)) {
964 if (CE_IsConstImm (E)) {
965 Out->RegA = In->RegA | (short) E->Num;
966 } else if (E->AM == AM65_ZP) {
967 switch (GetKnownReg (E->Use & REG_ZP, In)) {
969 Out->RegA = In->RegA | In->Tmp1;
972 Out->RegA = In->RegA | In->Ptr1Lo;
975 Out->RegA = In->RegA | In->Ptr1Hi;
978 Out->RegA = In->RegA | In->SRegLo;
981 Out->RegA = In->RegA | In->SRegHi;
984 Out->RegA = UNKNOWN_REGVAL;
988 /* A is now unknown */
989 Out->RegA = UNKNOWN_REGVAL;
991 } else if (CE_IsKnownImm (E, 0xFF)) {
992 /* ORA with 0xFF does always give 0xFF */
1010 Out->RegA = UNKNOWN_REGVAL;
1017 Out->RegX = UNKNOWN_REGVAL;
1021 Out->RegY = UNKNOWN_REGVAL;
1025 /* We don't know the value of the carry bit */
1026 if (E->AM == AM65_ACC) {
1027 Out->RegA = UNKNOWN_REGVAL;
1028 } else if (E->AM == AM65_ZP) {
1029 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1031 Out->Tmp1 = UNKNOWN_REGVAL;
1034 Out->Ptr1Lo = UNKNOWN_REGVAL;
1037 Out->Ptr1Hi = UNKNOWN_REGVAL;
1040 Out->SRegLo = UNKNOWN_REGVAL;
1043 Out->SRegHi = UNKNOWN_REGVAL;
1046 } else if (E->AM == AM65_ZPX) {
1047 /* Invalidates all ZP registers */
1048 RC_InvalidateZP (Out);
1053 /* We don't know the value of the carry bit */
1054 if (E->AM == AM65_ACC) {
1055 Out->RegA = UNKNOWN_REGVAL;
1056 } else if (E->AM == AM65_ZP) {
1057 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1059 Out->Tmp1 = UNKNOWN_REGVAL;
1062 Out->Ptr1Lo = UNKNOWN_REGVAL;
1065 Out->Ptr1Hi = UNKNOWN_REGVAL;
1068 Out->SRegLo = UNKNOWN_REGVAL;
1071 Out->SRegHi = UNKNOWN_REGVAL;
1074 } else if (E->AM == AM65_ZPX) {
1075 /* Invalidates all ZP registers */
1076 RC_InvalidateZP (Out);
1087 /* We don't know the value of the carry bit */
1088 Out->RegA = UNKNOWN_REGVAL;
1101 if (E->AM == AM65_ZP) {
1102 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1104 Out->Tmp1 = In->RegA;
1107 Out->Ptr1Lo = In->RegA;
1110 Out->Ptr1Hi = In->RegA;
1113 Out->SRegLo = In->RegA;
1116 Out->SRegHi = In->RegA;
1119 } else if (E->AM == AM65_ZPX) {
1120 /* Invalidates all ZP registers */
1121 RC_InvalidateZP (Out);
1126 if (E->AM == AM65_ZP) {
1127 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1129 Out->Tmp1 = In->RegX;
1132 Out->Ptr1Lo = In->RegX;
1135 Out->Ptr1Hi = In->RegX;
1138 Out->SRegLo = In->RegX;
1141 Out->SRegHi = In->RegX;
1144 } else if (E->AM == AM65_ZPX) {
1145 /* Invalidates all ZP registers */
1146 RC_InvalidateZP (Out);
1151 if (E->AM == AM65_ZP) {
1152 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1154 Out->Tmp1 = In->RegY;
1157 Out->Ptr1Lo = In->RegY;
1160 Out->Ptr1Hi = In->RegY;
1163 Out->SRegLo = In->RegY;
1166 Out->SRegHi = In->RegY;
1169 } else if (E->AM == AM65_ZPX) {
1170 /* Invalidates all ZP registers */
1171 RC_InvalidateZP (Out);
1176 if (E->AM == AM65_ZP) {
1177 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1194 } else if (E->AM == AM65_ZPX) {
1195 /* Invalidates all ZP registers */
1196 RC_InvalidateZP (Out);
1201 Out->RegX = In->RegA;
1205 Out->RegY = In->RegA;
1209 if (E->AM == AM65_ZPX) {
1210 /* Invalidates all ZP registers */
1211 RC_InvalidateZP (Out);
1212 } else if (E->AM == AM65_ZP) {
1213 if (RegValIsKnown (In->RegA)) {
1214 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1216 Out->Tmp1 &= ~In->RegA;
1219 Out->Ptr1Lo &= ~In->RegA;
1222 Out->Ptr1Hi &= ~In->RegA;
1225 Out->SRegLo &= ~In->RegA;
1228 Out->SRegHi &= ~In->RegA;
1232 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1234 Out->Tmp1 = UNKNOWN_REGVAL;
1237 Out->Ptr1Lo = UNKNOWN_REGVAL;
1240 Out->Ptr1Hi = UNKNOWN_REGVAL;
1243 Out->SRegLo = UNKNOWN_REGVAL;
1246 Out->SRegHi = UNKNOWN_REGVAL;
1254 if (E->AM == AM65_ZPX) {
1255 /* Invalidates all ZP registers */
1256 RC_InvalidateZP (Out);
1257 } else if (E->AM == AM65_ZP) {
1258 if (RegValIsKnown (In->RegA)) {
1259 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1261 Out->Tmp1 |= In->RegA;
1264 Out->Ptr1Lo |= In->RegA;
1267 Out->Ptr1Hi |= In->RegA;
1270 Out->SRegLo |= In->RegA;
1273 Out->SRegHi |= In->RegA;
1277 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1279 Out->Tmp1 = UNKNOWN_REGVAL;
1282 Out->Ptr1Lo = UNKNOWN_REGVAL;
1285 Out->Ptr1Hi = UNKNOWN_REGVAL;
1288 Out->SRegLo = UNKNOWN_REGVAL;
1291 Out->SRegHi = UNKNOWN_REGVAL;
1299 Out->RegX = UNKNOWN_REGVAL;
1303 Out->RegA = In->RegX;
1310 Out->RegA = In->RegY;
1321 static char* RegInfoDesc (unsigned U, char* Buf)
1322 /* Return a string containing register info */
1326 strcat (Buf, U & REG_SREG_HI? "H" : "_");
1327 strcat (Buf, U & REG_SREG_LO? "L" : "_");
1328 strcat (Buf, U & REG_A? "A" : "_");
1329 strcat (Buf, U & REG_X? "X" : "_");
1330 strcat (Buf, U & REG_Y? "Y" : "_");
1331 strcat (Buf, U & REG_TMP1? "T1" : "__");
1332 strcat (Buf, U & REG_PTR1? "1" : "_");
1333 strcat (Buf, U & REG_PTR2? "2" : "_");
1334 strcat (Buf, U & REG_SAVE? "V" : "_");
1335 strcat (Buf, U & REG_SP? "S" : "_");
1342 static char* RegContentDesc (const RegContents* RC, char* Buf)
1343 /* Return a string containing register contents */
1347 if (RegValIsUnknown (RC->RegA)) {
1348 strcpy (B, "A:XX ");
1350 sprintf (B, "A:%02X ", RC->RegA);
1353 if (RegValIsUnknown (RC->RegX)) {
1354 strcpy (B, "X:XX ");
1356 sprintf (B, "X:%02X ", RC->RegX);
1359 if (RegValIsUnknown (RC->RegY)) {
1362 sprintf (B, "Y:%02X", RC->RegY);
1371 void CE_Output (const CodeEntry* E)
1372 /* Output the code entry to the output file */
1379 /* If we have a label, print that */
1380 unsigned LabelCount = CollCount (&E->Labels);
1382 for (I = 0; I < LabelCount; ++I) {
1383 CL_Output (CollConstAt (&E->Labels, I));
1386 /* Get the opcode description */
1387 D = GetOPCDesc (E->OPC);
1389 /* Print the mnemonic */
1390 Chars = WriteOutput ("\t%s", D->Mnemo);
1392 /* Space to leave before the operand */
1395 /* Print the operand */
1404 Chars += WriteOutput ("%*sa", Space, "");
1409 Chars += WriteOutput ("%*s#%s", Space, "", E->Arg);
1414 /* zeropage and absolute */
1415 Chars += WriteOutput ("%*s%s", Space, "", E->Arg);
1420 /* zeropage,X and absolute,X */
1421 Chars += WriteOutput ("%*s%s,x", Space, "", E->Arg);
1426 Chars += WriteOutput ("%*s%s,y", Space, "", E->Arg);
1431 Chars += WriteOutput ("%*s(%s,x)", Space, "", E->Arg);
1436 Chars += WriteOutput ("%*s(%s),y", Space, "", E->Arg);
1441 Chars += WriteOutput ("%*s(%s)", Space, "", E->Arg);
1446 Target = E->JumpTo? E->JumpTo->Name : E->Arg;
1447 Chars += WriteOutput ("%*s%s", Space, "", Target);
1451 Internal ("Invalid addressing mode");
1455 /* Print usage info if requested by the debugging flag */
1459 WriteOutput ("%*s; USE: %-12s CHG: %-12s SIZE: %u",
1460 (int)(30-Chars), "",
1461 RegInfoDesc (E->Use, Use),
1462 RegInfoDesc (E->Chg, Chg),
1468 WriteOutput (" In %s Out %s",
1469 RegContentDesc (&E->RI->In, RegIn),
1470 RegContentDesc (&E->RI->Out, RegOut));
1474 /* Terminate the line */