1 /*****************************************************************************/
5 /* 6502 code generator */
9 /* (C) 1998-2001 llrich von Bassewitz */
11 /* D-70597 Stuttgart */
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 /*****************************************************************************/
43 /*****************************************************************************/
52 /*****************************************************************************/
54 /*****************************************************************************/
58 /* Code generator flags.
59 * Note: The type flags are designed so that a smaller type may override a
60 * larger one by or'ing it into the existing one.
62 #define CF_NONE 0x0000 /* No special flags */
64 #define CF_TYPE 0x0007 /* Mask for operand type */
65 #define CF_CHAR 0x0003 /* Operation on characters */
66 #define CF_INT 0x0001 /* Operation on ints */
67 #define CF_PTR CF_INT /* Alias for readability */
68 #define CF_LONG 0x0000 /* Operation on longs */
70 #define CF_NOKEEP 0x0008 /* Value may get destroyed when storing */
72 #define CF_UNSIGNED 0x0010 /* Value is unsigned */
73 #define CF_CONST 0x0020 /* Constant value available */
74 #define CF_CONSTADDR 0x0040 /* Constant address value available */
75 #define CF_TEST 0x0080 /* Test value */
76 #define CF_FIXARGC 0x0100 /* Function has fixed arg count */
77 #define CF_FORCECHAR 0x0200 /* Handle chars as chars, not ints */
78 #define CF_REG 0x0800 /* Value is in primary register */
80 /* Type of static address */
81 #define CF_ADDRMASK 0xF000 /* Type of address */
82 #define CF_STATIC 0x0000 /* Static local */
83 #define CF_EXTERNAL 0x1000 /* Static external */
84 #define CF_ABSOLUTE 0x2000 /* Numeric absolute address */
85 #define CF_LOCAL 0x4000 /* Auto variable */
86 #define CF_REGVAR 0x8000 /* Register variable */
90 /* Compiler relative stackpointer */
95 /*****************************************************************************/
96 /* Pre- and postamble */
97 /*****************************************************************************/
101 void g_preamble (void);
102 /* Generate the assembler code preamble */
106 /*****************************************************************************/
107 /* Segment support */
108 /*****************************************************************************/
112 void g_pushseg (struct CodeSeg** CS, struct DataSeg** DS, const char* FuncName);
113 /* Push the current segments and generate new ones for the given function */
115 void g_popseg (void);
116 /* Restore the old segments */
118 void g_userodata (void);
119 /* Switch to the read only data segment */
121 void g_usedata (void);
122 /* Switch to the data segment */
124 void g_usebss (void);
125 /* Switch to the bss segment */
127 void g_codename (const char* Name);
128 /* Set the name of the CODE segment */
130 void g_rodataname (const char* Name);
131 /* Set the name of the RODATA segment */
133 void g_dataname (const char* Name);
134 /* Set the name of the DATA segment */
136 void g_bssname (const char* Name);
137 /* Set the name of the BSS segment */
141 /*****************************************************************************/
142 /* Functions handling local labels */
143 /*****************************************************************************/
147 void g_defcodelabel (unsigned label);
148 /* Define a local code label */
150 void g_defdatalabel (unsigned label);
151 /* Define a local data label */
155 /*****************************************************************************/
156 /* Functions handling global labels */
157 /*****************************************************************************/
161 void g_defgloblabel (const char* Name);
162 /* Define a global label with the given name */
164 void g_defexport (const char* Name, int ZP);
165 /* Export the given label */
167 void g_defimport (const char* Name, int ZP);
168 /* Import the given label */
172 /*****************************************************************************/
174 /*****************************************************************************/
178 int pop (unsigned flags);
179 /* Pop an argument of the given size */
181 int push (unsigned flags);
182 /* Push an argument of the given size */
184 unsigned sizeofarg (unsigned flags);
185 /* Return the size of a function argument type that is encoded in flags */
189 /*****************************************************************************/
190 /* type conversion and similiar stuff */
191 /*****************************************************************************/
195 void g_toslong (unsigned flags);
196 /* Make sure, the value on TOS is a long. Convert if necessary */
198 void g_tosint (unsigned flags);
199 /* Make sure, the value on TOS is an int. Convert if necessary */
201 void g_reglong (unsigned flags);
202 /* Make sure, the value in the primary register a long. Convert if necessary */
204 unsigned g_typeadjust (unsigned lhs, unsigned rhs);
205 /* Adjust the integer operands before doing a binary operation. lhs is a flags
206 * value, that corresponds to the value on TOS, rhs corresponds to the value
207 * in (e)ax. The return value is the the flags value for the resulting type.
210 unsigned g_typecast (unsigned lhs, unsigned rhs);
211 /* Cast the value in the primary register to the operand size that is flagged
212 * by the lhs value. Return the result value.
215 void g_scale (unsigned flags, long val);
216 /* Scale the value in the primary register by the given value. If val is positive,
217 * scale up, is val is negative, scale down. This function is used to scale
218 * the operands or results of pointer arithmetic by the size of the type, the
224 /*****************************************************************************/
225 /* Function entry and exit */
226 /*****************************************************************************/
230 void g_enter (unsigned flags, unsigned argsize);
231 /* Function prologue */
233 void g_leave (int flags, int val);
234 /* Function epilogue */
238 /*****************************************************************************/
239 /* Register variables */
240 /*****************************************************************************/
244 void g_save_regvars (int RegOffs, unsigned Bytes);
245 /* Save register variables */
247 void g_restore_regvars (int StackOffs, int RegOffs, unsigned Bytes);
248 /* Restore register variables */
252 /*****************************************************************************/
253 /* Fetching memory cells */
254 /*****************************************************************************/
258 void g_getimmed (unsigned Flags, unsigned long Val, unsigned Offs);
259 /* Load a constant into the primary register */
261 void g_getstatic (unsigned Flags, unsigned long Label, unsigned Offs);
262 /* Fetch an static memory cell into the primary register */
264 void g_getlocal (unsigned Flags, int Offs);
265 /* Fetch specified local object (local var). */
267 void g_getind (unsigned Flags, unsigned Offs);
268 /* Fetch the specified object type indirect through the primary register
269 * into the primary register
272 void g_leasp (int Offs);
273 /* Fetch the address of the specified symbol into the primary register */
275 void g_leavariadic (int Offs);
276 /* Fetch the address of a parameter in a variadic function into the primary
282 /*****************************************************************************/
283 /* Store into memory */
284 /*****************************************************************************/
288 void g_putstatic (unsigned flags, unsigned long label, unsigned offs);
289 /* Store the primary register into the specified static memory cell */
291 void g_putlocal (unsigned Flags, int Offs, long Val);
292 /* Put data into local object. */
294 void g_putind (unsigned flags, unsigned offs);
295 /* Store the specified object type in the primary register at the address
296 * on the top of the stack
301 /*****************************************************************************/
302 /* Adds and subs of variables fix a fixed address */
303 /*****************************************************************************/
307 void g_addlocal (unsigned flags, int offs);
308 /* Add a local variable to ax */
310 void g_addstatic (unsigned flags, unsigned long label, unsigned offs);
311 /* Add a static variable to ax */
315 /*****************************************************************************/
316 /* Compares of ax with a variable with fixed address */
317 /*****************************************************************************/
321 void g_cmplocal (unsigned flags, int offs);
322 /* Compare a local variable to ax */
324 void g_cmpstatic (unsigned flags, unsigned label, unsigned offs);
325 /* Compare a static variable to ax */
329 /*****************************************************************************/
330 /* Special op= functions */
331 /*****************************************************************************/
335 void g_addeqstatic (unsigned flags, unsigned long label, unsigned offs,
337 /* Emit += for a static variable */
339 void g_addeqlocal (unsigned flags, int offs, unsigned long val);
340 /* Emit += for a local variable */
342 void g_addeqind (unsigned flags, unsigned offs, unsigned long val);
343 /* Emit += for the location with address in ax */
345 void g_subeqstatic (unsigned flags, unsigned long label, unsigned offs,
347 /* Emit -= for a static variable */
349 void g_subeqlocal (unsigned flags, int offs, unsigned long val);
350 /* Emit -= for a local variable */
352 void g_subeqind (unsigned flags, unsigned offs, unsigned long val);
353 /* Emit -= for the location with address in ax */
357 /*****************************************************************************/
358 /* Add a variable address to the value in ax */
359 /*****************************************************************************/
363 void g_addaddr_local (unsigned flags, int offs);
364 /* Add the address of a local variable to ax */
366 void g_addaddr_static (unsigned flags, unsigned long label, unsigned offs);
367 /* Add the address of a static variable to ax */
371 /*****************************************************************************/
373 /*****************************************************************************/
377 void g_save (unsigned flags);
378 /* Copy primary register to hold register. */
380 void g_restore (unsigned flags);
381 /* Copy hold register to primary. */
383 void g_cmp (unsigned flags, unsigned long val);
384 /* Immidiate compare. The primary register will not be changed, Z flag
388 void g_test (unsigned flags);
389 /* Test the value in the primary and set the condition codes */
391 void g_push (unsigned flags, unsigned long val);
392 /* Push the primary register or a constant value onto the stack */
394 void g_swap (unsigned flags);
395 /* Swap the primary register and the top of the stack. flags give the type
396 * of *both* values (must have same size).
399 void g_call (unsigned Flags, const char* Label, unsigned ArgSize);
400 /* Call the specified subroutine name */
402 void g_callind (unsigned Flags, unsigned ArgSize);
403 /* Call subroutine with address in AX */
405 void g_jump (unsigned Label);
406 /* Jump to specified internal label number */
408 void g_switch (unsigned Flags);
409 /* Output switch statement preamble */
411 void g_case (unsigned flags, unsigned label, unsigned long val);
412 /* Create table code for one case selector */
414 void g_truejump (unsigned flags, unsigned label);
415 /* Jump to label if zero flag clear */
417 void g_falsejump (unsigned flags, unsigned label);
418 /* Jump to label if zero flag set */
420 void g_space (int space);
421 /* Create or drop space on the stack */
423 void g_cstackcheck (void);
424 /* Check for a C stack overflow */
426 void g_stackcheck (void);
427 /* Check for a stack overflow */
429 void g_add (unsigned flags, unsigned long val);
430 void g_sub (unsigned flags, unsigned long val);
431 void g_rsub (unsigned flags, unsigned long val);
432 void g_mul (unsigned flags, unsigned long val);
433 void g_div (unsigned flags, unsigned long val);
434 void g_mod (unsigned flags, unsigned long val);
435 void g_or (unsigned flags, unsigned long val);
436 void g_xor (unsigned flags, unsigned long val);
437 void g_and (unsigned flags, unsigned long val);
438 void g_asr (unsigned flags, unsigned long val);
439 void g_asl (unsigned flags, unsigned long val);
440 void g_neg (unsigned flags);
441 void g_bneg (unsigned flags);
442 void g_com (unsigned flags);
443 void g_inc (unsigned flags, unsigned long n);
444 void g_dec (unsigned flags, unsigned long n);
445 void g_eq (unsigned flags, unsigned long val);
446 void g_ne (unsigned flags, unsigned long val);
447 void g_lt (unsigned flags, unsigned long val);
448 void g_le (unsigned flags, unsigned long val);
449 void g_gt (unsigned flags, unsigned long val);
450 void g_ge (unsigned flags, unsigned long val);
452 void g_res (unsigned n);
453 /* Reserve static storage, n bytes */
455 void g_defdata (unsigned flags, unsigned long val, unsigned offs);
456 /* Define data with the size given in flags */
458 void g_defbytes (const void* bytes, unsigned count);
459 /* Output a row of bytes as a constant */
461 void g_zerobytes (unsigned n);
462 /* Output n bytes of data initialized with zero */
466 /*****************************************************************************/
467 /* User supplied assembler code */
468 /*****************************************************************************/
472 void g_asmcode (const char* Line, int Len);
473 /* Output one line of assembler code. If Len is greater than zero, it is used
474 * as the maximum number of characters to use from Line.
479 /*****************************************************************************/
480 /* Inlined known functions */
481 /*****************************************************************************/
485 void g_strlen (unsigned flags, unsigned long val, unsigned offs);
486 /* Inline the strlen() function */
490 /* End of codegen.h */