1 /*****************************************************************************/
5 /* Code segment entry */
9 /* (C) 2001-2003 Ullrich von Bassewitz */
10 /* Römerstrasse 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 /*****************************************************************************/
42 #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_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);
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->Arg = GetArgCopy (Arg);
248 E->Flags = NumArg (E->Arg, &E->Num)? CEF_NUMARG : 0;
250 E->Size = GetInsnSize (E->OPC, E->AM);
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_MoveLabel (CodeLabel* L, CodeEntry* E)
327 /* Move the code label L from it's former owner to the code entry E. */
329 /* Delete the label from the owner */
330 CollDeleteItem (&L->Owner->Labels, L);
332 /* Set the new owner */
333 CollAppend (&E->Labels, L);
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.
346 /* Check that the entry has a numerical argument */
347 CHECK (E->Flags & CEF_NUMARG);
349 /* Make the new argument string */
352 xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned) Num);
353 } else if (E->Size == 3) {
355 xsprintf (Buf, sizeof (Buf), "$%04X", (unsigned) Num);
357 Internal ("Invalid instruction size in CE_SetNumArg");
360 /* Free the old argument */
363 /* Assign the new one */
364 E->Arg = GetArgCopy (Buf);
366 /* Use the new numerical value */
372 int CE_KnownImm (const CodeEntry* E)
373 /* Return true if the argument of E is a known immediate value */
375 return (E->AM == AM65_IMM && (E->Flags & CEF_NUMARG) != 0);
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).
385 /* A branch will use the flags */
386 if (E->Info & OF_FBRA) {
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)) {
402 /* Will use the N or Z flags */
406 case CMP_UGE: /* Uses only carry */
407 case CMP_ULT: /* Dito */
408 default: /* No bool transformer subroutine */
419 void CE_FreeRegInfo (CodeEntry* E)
420 /* Free an existing register info struct */
430 #if 0 /* Used for debugging */
431 static void DumpRegInfo (const char* Desc, const RegInfo* RI)
433 fprintf (stdout, "%s:\n", Desc);
434 fprintf (stdout, "In: ");
435 RC_Dump (stdout, &RI->In);
436 fprintf (stdout, "Out: ");
437 RC_Dump (stdout, &RI->Out);
443 void CE_GenRegInfo (CodeEntry* E, RegContents* InputRegs)
444 /* Generate register info for this instruction. If an old info exists, it is
448 /* Pointers to the register contents */
452 /* Function register usage */
453 unsigned short Use, Chg;
455 /* If we don't have a register info struct, allocate one. */
457 E->RI = NewRegInfo (InputRegs);
460 E->RI->In = *InputRegs;
462 RC_Invalidate (&E->RI->In);
464 E->RI->Out2 = E->RI->Out = E->RI->In;
467 /* Get pointers to the register contents */
471 /* Handle the different instructions */
475 /* We don't know the value of the carry, so the result is
478 Out->RegA = UNKNOWN_REGVAL;
482 if (RegValIsKnown (In->RegA)) {
483 if (CE_KnownImm (E)) {
484 Out->RegA = In->RegA & (short) E->Num;
485 } else if (E->AM == AM65_ZP) {
486 switch (GetKnownReg (E->Use & REG_ZP, In)) {
488 Out->RegA = In->RegA & In->Tmp1;
491 Out->RegA = In->RegA & In->Ptr1Lo;
494 Out->RegA = In->RegA & In->Ptr1Hi;
497 Out->RegA = In->RegA & In->SRegLo;
500 Out->RegA = In->RegA & In->SRegHi;
503 Out->RegA = UNKNOWN_REGVAL;
507 Out->RegA = UNKNOWN_REGVAL;
513 if (E->AM == AM65_ACC && In->RegA >= 0) {
514 Out->RegA = (In->RegA << 1) & 0xFF;
515 } else if (E->AM == AM65_ZP) {
516 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
518 Out->Tmp1 = (In->Tmp1 << 1) & 0xFF;
521 Out->Ptr1Lo = (In->Ptr1Lo << 1) & 0xFF;
524 Out->Ptr1Hi = (In->Ptr1Hi << 1) & 0xFF;
527 Out->SRegLo = (In->SRegLo << 1) & 0xFF;
530 Out->SRegHi = (In->SRegHi << 1) & 0xFF;
533 } else if (E->AM == AM65_ZPX) {
534 /* Invalidates all ZP registers */
535 RC_InvalidateZP (Out);
594 if (RegValIsKnown (In->RegA)) {
595 Out->RegA = (In->RegA - 1) & 0xFF;
600 if (E->AM == AM65_ACC && In->RegA >= 0) {
601 Out->RegA = (In->RegA - 1) & 0xFF;
602 } else if (E->AM == AM65_ZP) {
603 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
605 Out->Tmp1 = (In->Tmp1 - 1) & 0xFF;
608 Out->Ptr1Lo = (In->Ptr1Lo - 1) & 0xFF;
611 Out->Ptr1Hi = (In->Ptr1Hi - 1) & 0xFF;
614 Out->SRegLo = (In->SRegLo - 1) & 0xFF;
617 Out->SRegHi = (In->SRegHi - 1) & 0xFF;
620 } else if (E->AM == AM65_ZPX) {
621 /* Invalidates all ZP registers */
622 RC_InvalidateZP (Out);
627 if (RegValIsKnown (In->RegX)) {
628 Out->RegX = (In->RegX - 1) & 0xFF;
633 if (RegValIsKnown (In->RegY)) {
634 Out->RegY = (In->RegY - 1) & 0xFF;
639 if (RegValIsKnown (In->RegA)) {
640 if (CE_KnownImm (E)) {
641 Out->RegA = In->RegA ^ (short) E->Num;
642 } else if (E->AM == AM65_ZP) {
643 switch (GetKnownReg (E->Use & REG_ZP, In)) {
645 Out->RegA = In->RegA ^ In->Tmp1;
648 Out->RegA = In->RegA ^ In->Ptr1Lo;
651 Out->RegA = In->RegA ^ In->Ptr1Hi;
654 Out->RegA = In->RegA ^ In->SRegLo;
657 Out->RegA = In->RegA ^ In->SRegHi;
660 Out->RegA = UNKNOWN_REGVAL;
664 Out->RegA = UNKNOWN_REGVAL;
670 if (RegValIsKnown (In->RegA)) {
671 Out->RegA = (In->RegA + 1) & 0xFF;
676 if (E->AM == AM65_ACC && In->RegA >= 0) {
677 Out->RegA = (In->RegA + 1) & 0xFF;
678 } else if (E->AM == AM65_ZP) {
679 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
681 Out->Tmp1 = (In->Tmp1 + 1) & 0xFF;
684 Out->Ptr1Lo = (In->Ptr1Lo + 1) & 0xFF;
687 Out->Ptr1Hi = (In->Ptr1Hi + 1) & 0xFF;
690 Out->SRegLo = (In->SRegLo + 1) & 0xFF;
693 Out->SRegHi = (In->SRegHi + 1) & 0xFF;
696 } else if (E->AM == AM65_ZPX) {
697 /* Invalidates all ZP registers */
698 RC_InvalidateZP (Out);
703 if (RegValIsKnown (In->RegX)) {
704 Out->RegX = (In->RegX + 1) & 0xFF;
709 if (RegValIsKnown (In->RegY)) {
710 Out->RegY = (In->RegY + 1) & 0xFF;
736 /* Get the code info for the function */
737 GetFuncInfo (E->Arg, &Use, &Chg);
739 Out->RegA = UNKNOWN_REGVAL;
742 Out->RegX = UNKNOWN_REGVAL;
745 Out->RegY = UNKNOWN_REGVAL;
747 if (Chg & REG_TMP1) {
748 Out->Tmp1 = UNKNOWN_REGVAL;
750 if (Chg & REG_PTR1_LO) {
751 Out->Ptr1Lo = UNKNOWN_REGVAL;
753 if (Chg & REG_PTR1_HI) {
754 Out->Ptr1Hi = UNKNOWN_REGVAL;
756 if (Chg & REG_SREG_LO) {
757 Out->SRegLo = UNKNOWN_REGVAL;
759 if (Chg & REG_SREG_HI) {
760 Out->SRegHi = UNKNOWN_REGVAL;
762 /* ## FIXME: Quick hack for some known functions: */
763 if (strcmp (E->Arg, "tosandax") == 0) {
770 } else if (strcmp (E->Arg, "tosorax") == 0) {
771 if (In->RegA == 0xFF) {
774 if (In->RegX == 0xFF) {
777 } else if (FindBoolCmpCond (E->Arg) != CMP_INV) {
789 if (CE_KnownImm (E)) {
790 Out->RegA = (unsigned char) E->Num;
791 } else if (E->AM == AM65_ZP) {
792 switch (GetKnownReg (E->Use & REG_ZP, In)) {
794 Out->RegA = In->Tmp1;
797 Out->RegA = In->Ptr1Lo;
800 Out->RegA = In->Ptr1Hi;
803 Out->RegA = In->SRegLo;
806 Out->RegA = In->SRegHi;
809 Out->RegA = UNKNOWN_REGVAL;
813 /* A is now unknown */
814 Out->RegA = UNKNOWN_REGVAL;
819 if (CE_KnownImm (E)) {
820 Out->RegX = (unsigned char) E->Num;
821 } else if (E->AM == AM65_ZP) {
822 switch (GetKnownReg (E->Use & REG_ZP, In)) {
824 Out->RegX = In->Tmp1;
827 Out->RegX = In->Ptr1Lo;
830 Out->RegX = In->Ptr1Hi;
833 Out->RegX = In->SRegLo;
836 Out->RegX = In->SRegHi;
839 Out->RegX = UNKNOWN_REGVAL;
843 /* X is now unknown */
844 Out->RegX = UNKNOWN_REGVAL;
849 if (CE_KnownImm (E)) {
850 Out->RegY = (unsigned char) E->Num;
851 } else if (E->AM == AM65_ZP) {
852 switch (GetKnownReg (E->Use & REG_ZP, In)) {
854 Out->RegY = In->Tmp1;
857 Out->RegY = In->Ptr1Lo;
860 Out->RegY = In->Ptr1Hi;
863 Out->RegY = In->SRegLo;
866 Out->RegY = In->SRegHi;
869 Out->RegY = UNKNOWN_REGVAL;
873 /* Y is now unknown */
874 Out->RegY = UNKNOWN_REGVAL;
879 if (E->AM == AM65_ACC && In->RegA >= 0) {
880 Out->RegA = (In->RegA >> 1) & 0xFF;
881 } else if (E->AM == AM65_ZP) {
882 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
884 Out->Tmp1 = (In->Tmp1 >> 1) & 0xFF;
887 Out->Ptr1Lo = (In->Ptr1Lo >> 1) & 0xFF;
890 Out->Ptr1Hi = (In->Ptr1Hi >> 1) & 0xFF;
893 Out->SRegLo = (In->SRegLo >> 1) & 0xFF;
896 Out->SRegHi = (In->SRegHi >> 1) & 0xFF;
899 } else if (E->AM == AM65_ZPX) {
900 /* Invalidates all ZP registers */
901 RC_InvalidateZP (Out);
909 if (RegValIsKnown (In->RegA)) {
910 if (CE_KnownImm (E)) {
911 Out->RegA = In->RegA | (short) E->Num;
912 } else if (E->AM == AM65_ZP) {
913 switch (GetKnownReg (E->Use & REG_ZP, In)) {
915 Out->RegA = In->RegA | In->Tmp1;
918 Out->RegA = In->RegA | In->Ptr1Lo;
921 Out->RegA = In->RegA | In->Ptr1Hi;
924 Out->RegA = In->RegA | In->SRegLo;
927 Out->RegA = In->RegA | In->SRegHi;
930 Out->RegA = UNKNOWN_REGVAL;
934 /* A is now unknown */
935 Out->RegA = UNKNOWN_REGVAL;
953 Out->RegA = UNKNOWN_REGVAL;
960 Out->RegX = UNKNOWN_REGVAL;
964 Out->RegY = UNKNOWN_REGVAL;
968 /* We don't know the value of the carry bit */
969 if (E->AM == AM65_ACC) {
970 Out->RegA = UNKNOWN_REGVAL;
971 } else if (E->AM == AM65_ZP) {
972 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
974 Out->Tmp1 = UNKNOWN_REGVAL;
977 Out->Ptr1Lo = UNKNOWN_REGVAL;
980 Out->Ptr1Hi = UNKNOWN_REGVAL;
983 Out->SRegLo = UNKNOWN_REGVAL;
986 Out->SRegHi = UNKNOWN_REGVAL;
989 } else if (E->AM == AM65_ZPX) {
990 /* Invalidates all ZP registers */
991 RC_InvalidateZP (Out);
996 /* We don't know the value of the carry bit */
997 if (E->AM == AM65_ACC) {
998 Out->RegA = UNKNOWN_REGVAL;
999 } else if (E->AM == AM65_ZP) {
1000 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1002 Out->Tmp1 = UNKNOWN_REGVAL;
1005 Out->Ptr1Lo = UNKNOWN_REGVAL;
1008 Out->Ptr1Hi = UNKNOWN_REGVAL;
1011 Out->SRegLo = UNKNOWN_REGVAL;
1014 Out->SRegHi = UNKNOWN_REGVAL;
1017 } else if (E->AM == AM65_ZPX) {
1018 /* Invalidates all ZP registers */
1019 RC_InvalidateZP (Out);
1030 /* We don't know the value of the carry bit */
1031 Out->RegA = UNKNOWN_REGVAL;
1044 if (E->AM == AM65_ZP) {
1045 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1047 Out->Tmp1 = In->RegA;
1050 Out->Ptr1Lo = In->RegA;
1053 Out->Ptr1Hi = In->RegA;
1056 Out->SRegLo = In->RegA;
1059 Out->SRegHi = In->RegA;
1062 } else if (E->AM == AM65_ZPX) {
1063 /* Invalidates all ZP registers */
1064 RC_InvalidateZP (Out);
1069 if (E->AM == AM65_ZP) {
1070 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1072 Out->Tmp1 = In->RegX;
1075 Out->Ptr1Lo = In->RegX;
1078 Out->Ptr1Hi = In->RegX;
1081 Out->SRegLo = In->RegX;
1084 Out->SRegHi = In->RegX;
1087 } else if (E->AM == AM65_ZPX) {
1088 /* Invalidates all ZP registers */
1089 RC_InvalidateZP (Out);
1094 if (E->AM == AM65_ZP) {
1095 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1097 Out->Tmp1 = In->RegY;
1100 Out->Ptr1Lo = In->RegY;
1103 Out->Ptr1Hi = In->RegY;
1106 Out->SRegLo = In->RegY;
1109 Out->SRegHi = In->RegY;
1112 } else if (E->AM == AM65_ZPX) {
1113 /* Invalidates all ZP registers */
1114 RC_InvalidateZP (Out);
1119 if (E->AM == AM65_ZP) {
1120 switch (GetKnownReg (E->Chg & REG_ZP, 0)) {
1137 } else if (E->AM == AM65_ZPX) {
1138 /* Invalidates all ZP registers */
1139 RC_InvalidateZP (Out);
1144 Out->RegX = In->RegA;
1148 Out->RegY = In->RegA;
1152 if (E->AM == AM65_ZPX) {
1153 /* Invalidates all ZP registers */
1154 RC_InvalidateZP (Out);
1155 } else if (E->AM == AM65_ZP) {
1156 if (In->RegA >= 0) {
1157 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1159 Out->Tmp1 &= ~In->RegA;
1162 Out->Ptr1Lo &= ~In->RegA;
1165 Out->Ptr1Hi &= ~In->RegA;
1168 Out->SRegLo &= ~In->RegA;
1171 Out->SRegHi &= ~In->RegA;
1175 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1177 Out->Tmp1 = UNKNOWN_REGVAL;
1180 Out->Ptr1Lo = UNKNOWN_REGVAL;
1183 Out->Ptr1Hi = UNKNOWN_REGVAL;
1186 Out->SRegLo = UNKNOWN_REGVAL;
1189 Out->SRegHi = UNKNOWN_REGVAL;
1197 if (E->AM == AM65_ZPX) {
1198 /* Invalidates all ZP registers */
1199 RC_InvalidateZP (Out);
1200 } else if (E->AM == AM65_ZP) {
1201 if (In->RegA >= 0) {
1202 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1204 Out->Tmp1 |= In->RegA;
1207 Out->Ptr1Lo |= In->RegA;
1210 Out->Ptr1Hi |= In->RegA;
1213 Out->SRegLo |= In->RegA;
1216 Out->SRegHi |= In->RegA;
1220 switch (GetKnownReg (E->Chg & REG_ZP, In)) {
1222 Out->Tmp1 = UNKNOWN_REGVAL;
1225 Out->Ptr1Lo = UNKNOWN_REGVAL;
1228 Out->Ptr1Hi = UNKNOWN_REGVAL;
1231 Out->SRegLo = UNKNOWN_REGVAL;
1234 Out->SRegHi = UNKNOWN_REGVAL;
1242 Out->RegX = UNKNOWN_REGVAL;
1246 Out->RegA = In->RegX;
1253 Out->RegA = In->RegY;
1264 static char* RegInfoDesc (unsigned U, char* Buf)
1265 /* Return a string containing register info */
1269 strcat (Buf, U & REG_SREG_HI? "H" : "_");
1270 strcat (Buf, U & REG_SREG_LO? "L" : "_");
1271 strcat (Buf, U & REG_A? "A" : "_");
1272 strcat (Buf, U & REG_X? "X" : "_");
1273 strcat (Buf, U & REG_Y? "Y" : "_");
1274 strcat (Buf, U & REG_TMP1? "T1" : "__");
1275 strcat (Buf, U & REG_PTR1? "1" : "_");
1276 strcat (Buf, U & REG_PTR2? "2" : "_");
1277 strcat (Buf, U & REG_SAVE? "V" : "_");
1278 strcat (Buf, U & REG_SP? "S" : "_");
1285 void CE_Output (const CodeEntry* E, FILE* F)
1286 /* Output the code entry to a file */
1292 /* If we have a label, print that */
1293 unsigned LabelCount = CollCount (&E->Labels);
1295 for (I = 0; I < LabelCount; ++I) {
1296 CL_Output (CollConstAt (&E->Labels, I), F);
1299 /* Get the opcode description */
1300 D = GetOPCDesc (E->OPC);
1302 /* Print the mnemonic */
1303 Chars = fprintf (F, "\t%s", D->Mnemo);
1305 /* Print the operand */
1315 Chars += fprintf (F, "%*sa", 9-Chars, "");
1321 Chars += fprintf (F, "%*s#%s", 9-Chars, "", E->Arg);
1327 /* zeropage and absolute */
1328 Chars += fprintf (F, "%*s%s", 9-Chars, "", E->Arg);
1333 /* zeropage,X and absolute,X */
1334 Chars += fprintf (F, "%*s%s,x", 9-Chars, "", E->Arg);
1339 Chars += fprintf (F, "%*s%s,y", 9-Chars, "", E->Arg);
1344 Chars += fprintf (F, "%*s(%s,x)", 9-Chars, "", E->Arg);
1349 Chars += fprintf (F, "%*s(%s),y", 9-Chars, "", E->Arg);
1354 Chars += fprintf (F, "%*s(%s)", 9-Chars, "", E->Arg);
1359 Target = E->JumpTo? E->JumpTo->Name : E->Arg;
1360 Chars += fprintf (F, "%*s%s", 9-Chars, "", Target);
1364 Internal ("Invalid addressing mode");
1368 /* Print usage info if requested by the debugging flag */
1373 "%*s; USE: %-12s CHG: %-12s SIZE: %u\n",
1375 RegInfoDesc (E->Use, Use),
1376 RegInfoDesc (E->Chg, Chg),
1379 /* Terminate the line */