]> git.sur5r.net Git - cc65/blob - src/cc65/codeent.c
08728cabbe428369dd5b43d332177759923dac22
[cc65] / src / cc65 / codeent.c
1 /*****************************************************************************/
2 /*                                                                           */
3 /*                                 codeent.c                                 */
4 /*                                                                           */
5 /*                            Code segment entry                             */
6 /*                                                                           */
7 /*                                                                           */
8 /*                                                                           */
9 /* (C) 2001     Ullrich von Bassewitz                                        */
10 /*              Wacholderweg 14                                              */
11 /*              D-70597 Stuttgart                                            */
12 /* EMail:       uz@musoftware.de                                             */
13 /*                                                                           */
14 /*                                                                           */
15 /* This software is provided 'as-is', without any expressed or implied       */
16 /* warranty.  In no event will the authors be held liable for any damages    */
17 /* arising from the use of this software.                                    */
18 /*                                                                           */
19 /* Permission is granted to anyone to use this software for any purpose,     */
20 /* including commercial applications, and to alter it and redistribute it    */
21 /* freely, subject to the following restrictions:                            */
22 /*                                                                           */
23 /* 1. The origin of this software must not be misrepresented; you must not   */
24 /*    claim that you wrote the original software. If you use this software   */
25 /*    in a product, an acknowledgment in the product documentation would be  */
26 /*    appreciated but is not required.                                       */
27 /* 2. Altered source versions must be plainly marked as such, and must not   */
28 /*    be misrepresented as being the original software.                      */
29 /* 3. This notice may not be removed or altered from any source              */
30 /*    distribution.                                                          */
31 /*                                                                           */
32 /*****************************************************************************/
33
34
35
36 #include <stdlib.h>
37 #include <string.h>
38
39 /* common */
40 #include "chartype.h"
41 #include "check.h"
42 #include "xmalloc.h"
43
44 /* cc65 */
45 #include "codeinfo.h"
46 #include "error.h"
47 #include "global.h"
48 #include "codelab.h"
49 #include "opcodes.h"
50 #include "codeent.h"
51
52
53
54 /*****************************************************************************/
55 /*                                   Data                                    */
56 /*****************************************************************************/
57
58
59
60 /* Empty argument */
61 static char EmptyArg[] = "";
62
63
64
65 /*****************************************************************************/
66 /*                             Helper functions                              */
67 /*****************************************************************************/
68
69
70
71 static void FreeArg (char* Arg)
72 /* Free a code entry argument */
73 {
74     if (Arg != EmptyArg) {
75         xfree (Arg);
76     }
77 }
78
79
80
81 static char* GetArgCopy (const char* Arg)
82 /* Create an argument copy for assignment */
83 {
84     if (Arg && Arg[0] != '\0') {
85         /* Create a copy */
86         return xstrdup (Arg);
87     } else {
88         /* Use the empty argument string */
89         return EmptyArg;
90     }
91 }
92
93
94
95 static int NumArg (const char* Arg, unsigned long* Num)
96 /* If the given argument is numerical, convert it and return true. Otherwise
97  * set Num to zero and return false.
98  */
99 {
100     char* End;
101     unsigned long Val;
102
103     /* Determine the base */
104     int Base = 10;
105     if (*Arg == '$') {
106         ++Arg;
107         Base = 16;
108     } else if (*Arg == '%') {
109         ++Arg;
110         Base = 2;
111     }
112
113     /* Convert the value. strtol is not exactly what we want here, but it's
114      * cheap and may be replaced by something fancier later.
115      */
116     Val = strtoul (Arg, &End, Base);
117
118     /* Check if the conversion was successful */
119     if (*End != '\0') {
120
121         /* Could not convert */
122         *Num = 0;
123         return 0;
124
125     } else {
126
127         /* Conversion ok */
128         *Num = Val;
129         return 1;
130
131     }
132 }
133
134
135
136 static void SetUseChgInfo (CodeEntry* E, const OPCDesc* D)
137 /* Set the Use and Chg in E */
138 {
139     /* If this is a subroutine call, or a jump to an external function,
140      * lookup the information about this function and use it. The jump itself
141      * does not change any registers, so we don't need to use the data from D.
142      */
143     if (E->OPC == OPC_JSR || ((E->Info & OF_BRA) != 0 && E->JumpTo == 0)) {
144         /* A subroutine call or jump to external symbol (function exit) */
145         GetFuncInfo (E->Arg, &E->Use, &E->Chg);
146     } else {
147         /* Some other instruction. Use the values from the opcode description
148          * plus addressing mode info
149          */
150         E->Use = D->Use | GetAMUseInfo (E->AM);
151         E->Chg = D->Chg;
152     }
153 }
154
155
156
157 /*****************************************************************************/
158 /*                                   Code                                    */
159 /*****************************************************************************/
160
161
162
163 CodeEntry* NewCodeEntry (opc_t OPC, am_t AM, const char* Arg, CodeLabel* JumpTo)
164 /* Create a new code entry, initialize and return it */
165 {
166     /* Get the opcode description */
167     const OPCDesc* D = GetOPCDesc (OPC);
168
169     /* Allocate memory */
170     CodeEntry* E = xmalloc (sizeof (CodeEntry));
171
172     /* Initialize the fields */
173     E->OPC      = D->OPC;
174     E->AM       = AM;
175     E->Size     = GetInsnSize (E->OPC, E->AM);
176     E->Hints    = 0;
177     E->Arg      = GetArgCopy (Arg);
178     if (NumArg (E->Arg, &E->Num)) {
179         E-> Flags = CEF_NUMARG;
180     } else {
181         E->Flags  = 0;
182     }
183     E->Info   = D->Info;
184     E->JumpTo = JumpTo;
185     SetUseChgInfo (E, D);
186     InitCollection (&E->Labels);
187
188     /* If we have a label given, add this entry to the label */
189     if (JumpTo) {
190         CollAppend (&JumpTo->JumpFrom, E);
191     }
192
193     /* Return the initialized struct */
194     return E;
195 }
196
197
198
199 void FreeCodeEntry (CodeEntry* E)
200 /* Free the given code entry */
201 {
202     /* Free the string argument if we have one */
203     FreeArg (E->Arg);
204
205     /* Cleanup the collection */
206     DoneCollection (&E->Labels);
207
208     /* Free the entry */
209     xfree (E);
210 }
211
212
213
214 void ReplaceOPC (CodeEntry* E, opc_t OPC)
215 /* Replace the opcode of the instruction. This will also replace related info,
216  * Size, Use and Chg, but it will NOT update any arguments or labels.
217  */
218 {
219     /* Get the opcode descriptor */
220     const OPCDesc* D = GetOPCDesc (OPC);
221
222     /* Replace the opcode */
223     E->OPC  = OPC;
224     E->Size = GetInsnSize (E->OPC, E->AM);
225     E->Info = D->Info;
226     SetUseChgInfo (E, D);
227 }
228
229
230
231 int CodeEntriesAreEqual (const CodeEntry* E1, const CodeEntry* E2)
232 /* Check if both code entries are equal */
233 {
234     return E1->OPC == E2->OPC && E1->AM == E2->AM && strcmp (E1->Arg, E2->Arg) == 0;
235 }
236
237
238
239 void AttachCodeLabel (CodeEntry* E, CodeLabel* L)
240 /* Attach the label to the entry */
241 {
242     /* Mark the label as defined */
243     L->Flags |= LF_DEF;
244
245     /* Add it to the entries label list */
246     CollAppend (&E->Labels, L);
247
248     /* Tell the label about it's owner */
249     L->Owner = E;
250 }
251
252
253
254 void MoveCodeLabel (CodeLabel* L, CodeEntry* E)
255 /* Move the code label L from it's former owner to the code entry E. */
256 {
257     /* Delete the label from the owner */
258     CollDeleteItem (&L->Owner->Labels, L);
259
260     /* Set the new owner */
261     CollAppend (&E->Labels, L);
262     L->Owner = E;
263 }
264
265
266
267 void CodeEntrySetArg (CodeEntry* E, const char* Arg)
268 /* Set a new argument for the given code entry. An old string is deleted. */
269 {
270     /* Free the old argument */
271     FreeArg (E->Arg);
272
273     /* Assign the new one */
274     E->Arg = GetArgCopy (Arg);
275 }
276
277
278
279 void OutputCodeEntry (const CodeEntry* E, FILE* F)
280 /* Output the code entry to a file */
281 {
282     const OPCDesc* D;
283     unsigned Chars;
284     const char* Target;
285
286     /* If we have a label, print that */
287     unsigned LabelCount = CollCount (&E->Labels);
288     unsigned I;
289     for (I = 0; I < LabelCount; ++I) {
290         OutputCodeLabel (CollConstAt (&E->Labels, I), F);
291     }
292
293     /* Get the opcode description */
294     D = GetOPCDesc (E->OPC);
295
296     /* Print the mnemonic */
297     Chars = fprintf (F, "\t%s", D->Mnemo);
298
299     /* Print the operand */
300     switch (E->AM) {
301
302         case AM_IMP:
303             /* implicit */
304             break;
305
306         case AM_ACC:
307             /* accumulator */
308             Chars += fprintf (F, "%*sa", 9-Chars, "");
309             break;
310
311         case AM_IMM:
312             /* immidiate */
313             Chars += fprintf (F, "%*s#%s", 9-Chars, "", E->Arg);
314             break;
315
316         case AM_ZP:
317         case AM_ABS:
318             /* zeropage and absolute */
319             Chars += fprintf (F, "%*s%s", 9-Chars, "", E->Arg);
320             break;
321
322         case AM_ZPX:
323         case AM_ABSX:
324             /* zeropage,X and absolute,X */
325             Chars += fprintf (F, "%*s%s,x", 9-Chars, "", E->Arg);
326             break;
327
328         case AM_ABSY:
329             /* absolute,Y */
330             Chars += fprintf (F, "%*s%s,y", 9-Chars, "", E->Arg);
331             break;
332
333         case AM_ZPX_IND:
334             /* (zeropage,x) */
335             Chars += fprintf (F, "%*s(%s,x)", 9-Chars, "", E->Arg);
336             break;
337
338         case AM_ZP_INDY:
339             /* (zeropage),y */
340             Chars += fprintf (F, "%*s(%s),y", 9-Chars, "", E->Arg);
341             break;
342
343         case AM_ZP_IND:
344             /* (zeropage) */
345             Chars += fprintf (F, "%*s(%s)", 9-Chars, "", E->Arg);
346             break;
347
348         case AM_BRA:
349             /* branch */
350             Target = E->JumpTo? E->JumpTo->Name : E->Arg;
351             Chars += fprintf (F, "%*s%s", 9-Chars, "", Target);
352             break;
353
354         default:
355             Internal ("Invalid addressing mode");
356
357     }
358
359     /* Print usage info if requested by the debugging flag */
360 //    if (Debug) {
361         Chars += fprintf (F,
362                           "%*s; USE: %c%c%c CHG: %c%c%c",
363                           30-Chars, "",
364                           (E->Use & REG_A)? 'A' : '_',
365                           (E->Use & REG_X)? 'X' : '_',
366                           (E->Use & REG_Y)? 'Y' : '_',
367                           (E->Chg & REG_A)? 'A' : '_',
368                           (E->Chg & REG_X)? 'X' : '_',
369                           (E->Chg & REG_Y)? 'Y' : '_');
370 //    }
371
372 }
373
374
375
376