1 /*****************************************************************************/
5 /* Code segment entry */
9 /* (C) 2001-2002 Ullrich von Bassewitz */
11 /* D-70597 Stuttgart */
12 /* EMail: uz@musoftware.de */
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 /*****************************************************************************/
55 /*****************************************************************************/
57 /*****************************************************************************/
62 static char EmptyArg[] = "";
66 /*****************************************************************************/
67 /* Helper functions */
68 /*****************************************************************************/
72 static void FreeArg (char* Arg)
73 /* Free a code entry argument */
75 if (Arg != EmptyArg) {
82 static char* GetArgCopy (const char* Arg)
83 /* Create an argument copy for assignment */
85 if (Arg && Arg[0] != '\0') {
89 /* Use the empty argument string */
96 static int NumArg (const char* Arg, unsigned long* Num)
97 /* If the given argument is numerical, convert it and return true. Otherwise
98 * set Num to zero and return false.
104 /* Determine the base */
109 } else if (*Arg == '%') {
114 /* Convert the value. strtol is not exactly what we want here, but it's
115 * cheap and may be replaced by something fancier later.
117 Val = strtoul (Arg, &End, Base);
119 /* Check if the conversion was successful */
122 /* Could not convert */
137 static void SetUseChgInfo (CodeEntry* E, const OPCDesc* D)
138 /* Set the Use and Chg in E */
142 /* If this is a subroutine call, or a jump to an external function,
143 * lookup the information about this function and use it. The jump itself
144 * does not change any registers, so we don't need to use the data from D.
146 if ((E->Info & (OF_BRA | OF_CALL)) != 0 && E->JumpTo == 0) {
147 /* A subroutine call or jump to external symbol (function exit) */
148 GetFuncInfo (E->Arg, &E->Use, &E->Chg);
150 /* Some other instruction. Use the values from the opcode description
151 * plus addressing mode info.
153 E->Use = D->Use | GetAMUseInfo (E->AM);
156 /* Check for special zero page registers used */
160 if (E->OPC == OP65_ASL || E->OPC == OP65_DEC ||
161 E->OPC == OP65_INC || E->OPC == OP65_LSR ||
162 E->OPC == OP65_ROL || E->OPC == OP65_ROR) {
163 /* A is changed by these insns */
170 /* Be conservative: */
174 Info = GetZPInfo (E->Arg);
175 if (Info && Info->ByteUse != REG_NONE) {
176 if (E->OPC == OP65_ASL || E->OPC == OP65_DEC ||
177 E->OPC == OP65_INC || E->OPC == OP65_LSR ||
178 E->OPC == OP65_ROL || E->OPC == OP65_ROR ||
179 E->OPC == OP65_TRB || E->OPC == OP65_TSB) {
180 /* The zp loc is both, input and output */
181 E->Chg |= Info->ByteUse;
182 E->Use |= Info->ByteUse;
183 } else if ((E->Info & OF_STORE) != 0) {
185 E->Chg |= Info->ByteUse;
188 E->Use |= Info->ByteUse;
196 Info = GetZPInfo (E->Arg);
197 if (Info && Info->ByteUse != REG_NONE) {
198 /* These addressing modes will never change the zp loc */
199 E->Use |= Info->WordUse;
204 /* Keep gcc silent */
212 /*****************************************************************************/
214 /*****************************************************************************/
218 const char* MakeHexArg (unsigned Num)
219 /* Convert Num into a string in the form $XY, suitable for passing it as an
220 * argument to NewCodeEntry, and return a pointer to the string.
221 * BEWARE: The function returns a pointer to a static buffer, so the value is
222 * gone if you call it twice (and apart from that it's not thread and signal
227 xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned char) Num);
233 CodeEntry* NewCodeEntry (opc_t OPC, am_t AM, const char* Arg,
234 CodeLabel* JumpTo, LineInfo* LI)
235 /* Create a new code entry, initialize and return it */
237 /* Get the opcode description */
238 const OPCDesc* D = GetOPCDesc (OPC);
240 /* Allocate memory */
241 CodeEntry* E = xmalloc (sizeof (CodeEntry));
243 /* Initialize the fields */
246 E->Arg = GetArgCopy (Arg);
247 E->Flags = NumArg (E->Arg, &E->Num)? CEF_NUMARG : 0;
249 E->Size = GetInsnSize (E->OPC, E->AM);
251 E->LI = UseLineInfo (LI);
253 SetUseChgInfo (E, D);
254 InitCollection (&E->Labels);
256 /* If we have a label given, add this entry to the label */
258 CollAppend (&JumpTo->JumpFrom, E);
261 /* Return the initialized struct */
267 void FreeCodeEntry (CodeEntry* E)
268 /* Free the given code entry */
270 /* Free the string argument if we have one */
273 /* Cleanup the collection */
274 DoneCollection (&E->Labels);
276 /* Release the line info */
277 ReleaseLineInfo (E->LI);
279 /* Delete the register info */
288 void CE_ReplaceOPC (CodeEntry* E, opc_t OPC)
289 /* Replace the opcode of the instruction. This will also replace related info,
290 * Size, Use and Chg, but it will NOT update any arguments or labels.
293 /* Get the opcode descriptor */
294 const OPCDesc* D = GetOPCDesc (OPC);
296 /* Replace the opcode */
299 E->Size = GetInsnSize (E->OPC, E->AM);
300 SetUseChgInfo (E, D);
305 int CodeEntriesAreEqual (const CodeEntry* E1, const CodeEntry* E2)
306 /* Check if both code entries are equal */
308 return E1->OPC == E2->OPC && E1->AM == E2->AM && strcmp (E1->Arg, E2->Arg) == 0;
313 void CE_AttachLabel (CodeEntry* E, CodeLabel* L)
314 /* Attach the label to the entry */
316 /* Add it to the entries label list */
317 CollAppend (&E->Labels, L);
319 /* Tell the label about it's owner */
325 void CE_MoveLabel (CodeLabel* L, CodeEntry* E)
326 /* Move the code label L from it's former owner to the code entry E. */
328 /* Delete the label from the owner */
329 CollDeleteItem (&L->Owner->Labels, L);
331 /* Set the new owner */
332 CollAppend (&E->Labels, L);
338 void CE_SetNumArg (CodeEntry* E, long Num)
339 /* Set a new numeric argument for the given code entry that must already
340 * have a numeric argument.
345 /* Check that the entry has a numerical argument */
346 CHECK (E->Flags & CEF_NUMARG);
348 /* Make the new argument string */
351 xsprintf (Buf, sizeof (Buf), "$%02X", (unsigned) Num);
352 } else if (E->Size == 3) {
354 xsprintf (Buf, sizeof (Buf), "$%04X", (unsigned) Num);
356 Internal ("Invalid instruction size in CE_SetNumArg");
359 /* Free the old argument */
362 /* Assign the new one */
363 E->Arg = GetArgCopy (Buf);
365 /* Use the new numerical value */
371 int CE_KnownImm (const CodeEntry* E)
372 /* Return true if the argument of E is a known immediate value */
374 return (E->AM == AM65_IMM && (E->Flags & CEF_NUMARG) != 0);
379 int CE_UseLoadFlags (const CodeEntry* E)
380 /* Return true if the instruction uses any flags that are set by a load of
381 * a register (N and Z).
384 /* A branch will use the flags */
385 if (E->Info & OF_FBRA) {
389 /* Call of a boolean transformer routine will also use the flags */
390 if (E->OPC == OP65_JSR) {
391 /* Get the condition that is evaluated and check it */
392 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 void CE_GenRegInfo (CodeEntry* E, RegContents* InputRegs)
431 /* Generate register info for this instruction. If an old info exists, it is
435 /* Pointers to the register contents */
439 /* Function register usage */
440 unsigned short Use, Chg;
442 /* If we don't have a register info struct, allocate one. */
444 E->RI = NewRegInfo (InputRegs);
447 E->RI->In = *InputRegs;
449 RC_Invalidate (&E->RI->In);
451 E->RI->Out2 = E->RI->Out = E->RI->In;
454 /* Get pointers to the register contents */
458 /* Handle the different instructions */
462 /* We don't know the value of the carry, so the result is
470 if (CE_KnownImm (E)) {
471 Out->RegA = In->RegA & (short) E->Num;
472 } else if (E->AM == AM65_ZP) {
473 switch (GetKnownReg (E->Use, In)) {
475 Out->RegA = In->RegA & In->Tmp1;
478 Out->RegA = In->RegA & In->SRegLo;
481 Out->RegA = In->RegA & In->SRegHi;
494 if (E->AM == AM65_ACC && In->RegA >= 0) {
495 Out->RegA = (In->RegA << 1) & 0xFF;
496 } else if (E->AM == AM65_ZP) {
497 switch (GetKnownReg (E->Chg, In)) {
499 Out->Tmp1 = (In->Tmp1 << 1) & 0xFF;
502 Out->SRegLo = (In->SRegLo << 1) & 0xFF;
505 Out->SRegHi = (In->SRegHi << 1) & 0xFF;
508 } else if (E->AM == AM65_ZPX) {
509 /* Invalidates all ZP registers */
510 RC_InvalidateZP (Out);
570 Out->RegA = (In->RegA - 1) & 0xFF;
575 if (E->AM == AM65_ACC && In->RegA >= 0) {
576 Out->RegA = (In->RegA - 1) & 0xFF;
577 } else if (E->AM == AM65_ZP) {
578 switch (GetKnownReg (E->Chg, In)) {
580 Out->Tmp1 = (In->Tmp1 - 1) & 0xFF;
583 Out->SRegLo = (In->SRegLo - 1) & 0xFF;
586 Out->SRegHi = (In->SRegHi - 1) & 0xFF;
589 } else if (E->AM == AM65_ZPX) {
590 /* Invalidates all ZP registers */
591 RC_InvalidateZP (Out);
597 Out->RegX = (In->RegX - 1) & 0xFF;
603 Out->RegY = (In->RegY - 1) & 0xFF;
609 if (CE_KnownImm (E)) {
610 Out->RegA = In->RegA ^ (short) E->Num;
611 } else if (E->AM == AM65_ZP) {
612 switch (GetKnownReg (E->Use, In)) {
614 Out->RegA = In->RegA ^ In->Tmp1;
617 Out->RegA = In->RegA ^ In->SRegLo;
620 Out->RegA = In->RegA ^ In->SRegHi;
634 Out->RegA = (In->RegA + 1) & 0xFF;
639 if (E->AM == AM65_ACC && In->RegA >= 0) {
640 Out->RegA = (In->RegA + 1) & 0xFF;
641 } else if (E->AM == AM65_ZP) {
642 switch (GetKnownReg (E->Chg, In)) {
644 Out->Tmp1 = (In->Tmp1 + 1) & 0xFF;
647 Out->SRegLo = (In->SRegLo + 1) & 0xFF;
650 Out->SRegHi = (In->SRegHi + 1) & 0xFF;
653 } else if (E->AM == AM65_ZPX) {
654 /* Invalidates all ZP registers */
655 RC_InvalidateZP (Out);
661 Out->RegX = (In->RegX + 1) & 0xFF;
667 Out->RegY = (In->RegY + 1) & 0xFF;
693 /* Get the code info for the function */
694 GetFuncInfo (E->Arg, &Use, &Chg);
704 if (Chg & REG_TMP1) {
707 if (Chg & REG_SREG_LO) {
710 if (Chg & REG_SREG_HI) {
713 /* ## FIXME: Quick hack for some known functions: */
714 if (strcmp (E->Arg, "tosandax") == 0) {
721 } else if (strcmp (E->Arg, "tosorax") == 0) {
722 if (In->RegA == 0xFF) {
725 if (In->RegX == 0xFF) {
728 } else if (FindBoolCmpCond (E->Arg) != CMP_INV) {
740 if (CE_KnownImm (E)) {
741 Out->RegA = (unsigned char) E->Num;
742 } else if (E->AM == AM65_ZP) {
743 switch (GetKnownReg (E->Use, In)) {
745 Out->RegA = In->Tmp1;
748 Out->RegA = In->SRegLo;
751 Out->RegA = In->SRegHi;
758 /* A is now unknown */
764 if (CE_KnownImm (E)) {
765 Out->RegX = (unsigned char) E->Num;
766 } else if (E->AM == AM65_ZP) {
767 switch (GetKnownReg (E->Use, In)) {
769 Out->RegX = In->Tmp1;
772 Out->RegX = In->SRegLo;
775 Out->RegX = In->SRegHi;
782 /* X is now unknown */
788 if (CE_KnownImm (E)) {
789 Out->RegY = (unsigned char) E->Num;
790 } else if (E->AM == AM65_ZP) {
791 switch (GetKnownReg (E->Use, In)) {
793 Out->RegY = In->Tmp1;
796 Out->RegY = In->SRegLo;
799 Out->RegY = In->SRegHi;
806 /* Y is now unknown */
812 if (E->AM == AM65_ACC && In->RegA >= 0) {
813 Out->RegA = (In->RegA >> 1) & 0xFF;
814 } else if (E->AM == AM65_ZP) {
815 switch (GetKnownReg (E->Chg, In)) {
817 Out->Tmp1 = (In->Tmp1 >> 1) & 0xFF;
820 Out->SRegLo = (In->SRegLo >> 1) & 0xFF;
823 Out->SRegHi = (In->SRegHi >> 1) & 0xFF;
826 } else if (E->AM == AM65_ZPX) {
827 /* Invalidates all ZP registers */
828 RC_InvalidateZP (Out);
837 if (CE_KnownImm (E)) {
838 Out->RegA = In->RegA | (short) E->Num;
839 } else if (E->AM == AM65_ZP) {
840 switch (GetKnownReg (E->Use, In)) {
842 Out->RegA = In->RegA | In->Tmp1;
845 Out->RegA = In->RegA | In->SRegLo;
848 Out->RegA = In->RegA | In->SRegHi;
855 /* A is now unknown */
889 /* We don't know the value of the carry bit */
890 if (E->AM == AM65_ACC) {
892 } else if (E->AM == AM65_ZP) {
893 switch (GetKnownReg (E->Chg, In)) {
904 } else if (E->AM == AM65_ZPX) {
905 /* Invalidates all ZP registers */
906 RC_InvalidateZP (Out);
911 /* We don't know the value of the carry bit */
912 if (E->AM == AM65_ACC) {
914 } else if (E->AM == AM65_ZP) {
915 switch (GetKnownReg (E->Chg, In)) {
926 } else if (E->AM == AM65_ZPX) {
927 /* Invalidates all ZP registers */
928 RC_InvalidateZP (Out);
939 /* We don't know the value of the carry bit */
953 if (E->AM == AM65_ZP) {
954 switch (GetKnownReg (E->Chg, 0)) {
956 Out->Tmp1 = In->RegA;
959 Out->SRegLo = In->RegA;
962 Out->SRegHi = In->RegA;
965 } else if (E->AM == AM65_ZPX) {
966 /* Invalidates all ZP registers */
967 RC_InvalidateZP (Out);
972 if (E->AM == AM65_ZP) {
973 switch (GetKnownReg (E->Chg, 0)) {
975 Out->Tmp1 = In->RegX;
978 Out->SRegLo = In->RegX;
981 Out->SRegHi = In->RegX;
984 } else if (E->AM == AM65_ZPX) {
985 /* Invalidates all ZP registers */
986 RC_InvalidateZP (Out);
991 if (E->AM == AM65_ZP) {
992 switch (GetKnownReg (E->Chg, 0)) {
994 Out->Tmp1 = In->RegY;
997 Out->SRegLo = In->RegY;
1000 Out->SRegHi = In->RegY;
1003 } else if (E->AM == AM65_ZPX) {
1004 /* Invalidates all ZP registers */
1005 RC_InvalidateZP (Out);
1010 if (E->AM == AM65_ZP) {
1011 switch (GetKnownReg (E->Chg, 0)) {
1022 } else if (E->AM == AM65_ZPX) {
1023 /* Invalidates all ZP registers */
1024 RC_InvalidateZP (Out);
1029 Out->RegX = In->RegA;
1033 Out->RegY = In->RegA;
1037 if (E->AM == AM65_ZPX) {
1038 /* Invalidates all ZP registers */
1039 RC_InvalidateZP (Out);
1040 } else if (E->AM == AM65_ZP) {
1041 if (In->RegA >= 0) {
1042 switch (GetKnownReg (E->Chg, In)) {
1044 Out->Tmp1 &= ~In->RegA;
1047 Out->SRegLo &= ~In->RegA;
1050 Out->SRegHi &= ~In->RegA;
1054 switch (GetKnownReg (E->Chg, In)) {
1070 if (E->AM == AM65_ZPX) {
1071 /* Invalidates all ZP registers */
1072 RC_InvalidateZP (Out);
1073 } else if (E->AM == AM65_ZP) {
1074 if (In->RegA >= 0) {
1075 switch (GetKnownReg (E->Chg, In)) {
1077 Out->Tmp1 |= In->RegA;
1080 Out->SRegLo |= In->RegA;
1083 Out->SRegHi |= In->RegA;
1087 switch (GetKnownReg (E->Chg, In)) {
1107 Out->RegA = In->RegX;
1114 Out->RegA = In->RegY;
1125 static char* RegInfoDesc (unsigned U, char* Buf)
1126 /* Return a string containing register info */
1130 strcat (Buf, U & REG_SREG_HI? "H" : "_");
1131 strcat (Buf, U & REG_SREG_LO? "L" : "_");
1132 strcat (Buf, U & REG_A? "A" : "_");
1133 strcat (Buf, U & REG_X? "X" : "_");
1134 strcat (Buf, U & REG_Y? "Y" : "_");
1135 strcat (Buf, U & REG_TMP1? "T1" : "__");
1136 strcat (Buf, U & REG_PTR1? "1" : "_");
1137 strcat (Buf, U & REG_PTR2? "2" : "_");
1138 strcat (Buf, U & REG_SAVE? "V" : "_");
1145 void CE_Output (const CodeEntry* E, FILE* F)
1146 /* Output the code entry to a file */
1152 /* If we have a label, print that */
1153 unsigned LabelCount = CollCount (&E->Labels);
1155 for (I = 0; I < LabelCount; ++I) {
1156 CL_Output (CollConstAt (&E->Labels, I), F);
1159 /* Get the opcode description */
1160 D = GetOPCDesc (E->OPC);
1162 /* Print the mnemonic */
1163 Chars = fprintf (F, "\t%s", D->Mnemo);
1165 /* Print the operand */
1175 Chars += fprintf (F, "%*sa", 9-Chars, "");
1181 Chars += fprintf (F, "%*s#%s", 9-Chars, "", E->Arg);
1187 /* zeropage and absolute */
1188 Chars += fprintf (F, "%*s%s", 9-Chars, "", E->Arg);
1193 /* zeropage,X and absolute,X */
1194 Chars += fprintf (F, "%*s%s,x", 9-Chars, "", E->Arg);
1199 Chars += fprintf (F, "%*s%s,y", 9-Chars, "", E->Arg);
1204 Chars += fprintf (F, "%*s(%s,x)", 9-Chars, "", E->Arg);
1209 Chars += fprintf (F, "%*s(%s),y", 9-Chars, "", E->Arg);
1214 Chars += fprintf (F, "%*s(%s)", 9-Chars, "", E->Arg);
1219 Target = E->JumpTo? E->JumpTo->Name : E->Arg;
1220 Chars += fprintf (F, "%*s%s", 9-Chars, "", Target);
1224 Internal ("Invalid addressing mode");
1228 /* Print usage info if requested by the debugging flag */
1233 "%*s; USE: %-20s CHG: %-20s SIZE: %u\n",
1235 RegInfoDesc (E->Use, Use),
1236 RegInfoDesc (E->Chg, Chg),
1239 /* Terminate the line */