git.sur5r.net Git - cc65/blob - 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,
 164                          CodeLabel* JumpTo, LineInfo* LI)
 165 /* Create a new code entry, initialize and return it */
 166 {
 167     /* Get the opcode description */
 168     const OPCDesc* D = GetOPCDesc (OPC);
 169
 170     /* Allocate memory */
 171     CodeEntry* E = xmalloc (sizeof (CodeEntry));
 172
 173     /* Initialize the fields */
 174     E->OPC    = D->OPC;
 175     E->AM     = AM;
 176     E->Arg    = GetArgCopy (Arg);
 177     E->Flags  = NumArg (E->Arg, &E->Num)? CEF_NUMARG : 0;
 178     E->Size   = GetInsnSize (E->OPC, E->AM);
 179     E->Info   = D->Info;
 180     E->JumpTo = JumpTo;
 181     E->LI     = UseLineInfo (LI);
 182     SetUseChgInfo (E, D);
 183     InitCollection (&E->Labels);
 184
 185     /* If we have a label given, add this entry to the label */
 186     if (JumpTo) {
 187         CollAppend (&JumpTo->JumpFrom, E);
 188     }
 189
 190     /* Return the initialized struct */
 191     return E;
 192 }
 193
 194
 195
 196 void FreeCodeEntry (CodeEntry* E)
 197 /* Free the given code entry */
 198 {
 199     /* Free the string argument if we have one */
 200     FreeArg (E->Arg);
 201
 202     /* Cleanup the collection */
 203     DoneCollection (&E->Labels);
 204
 205     /* Release the line info */
 206     ReleaseLineInfo (E->LI);
 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 SIZE: %u\n",
 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                           E->Size);
 371 //    }
 372
 373 }
 374
 375
 376
 377
 378