git.sur5r.net Git - cc65/blob - src/cc65/codeseg.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 codeseg.c                                 */
   4 /*                                                                           */
   5 /*                          Code segment structure                           */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2001      Ullrich von Bassewitz                                       */
  10 /*               Wacholderweg 14                                             */
  11 /*               D-70597 Stuttgart                                           */
  12 /* EMail:        uz@cc65.org                                                 */
  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 <string.h>
  37 #include <ctype.h>
  38
  39 /* common */
  40 #include "chartype.h"
  41 #include "check.h"
  42 #include "hashstr.h"
  43 #include "strutil.h"
  44 #include "xmalloc.h"
  45 #include "xsprintf.h"
  46
  47 /* cc65 */
  48 #include "asmlabel.h"
  49 #include "codeent.h"
  50 #include "codeinfo.h"
  51 #include "datatype.h"
  52 #include "error.h"
  53 #include "symentry.h"
  54 #include "codeseg.h"
  55
  56
  57
  58 /*****************************************************************************/
  59 /*                             Helper functions                              */
  60 /*****************************************************************************/
  61
  62
  63
  64 static void MoveLabelsToPool (CodeSeg* S, CodeEntry* E)
  65 /* Move the labels of the code entry E to the label pool of the code segment */
  66 {
  67     unsigned LabelCount = GetCodeLabelCount (E);
  68     while (LabelCount--) {
  69         CodeLabel* L = GetCodeLabel (E, LabelCount);
  70         L->Flags &= ~LF_DEF;
  71         L->Owner = 0;
  72         CollAppend (&S->Labels, L);
  73     }
  74     CollDeleteAll (&E->Labels);
  75 }
  76
  77
  78
  79 static CodeLabel* FindCodeLabel (CodeSeg* S, const char* Name, unsigned Hash)
  80 /* Find the label with the given name. Return the label or NULL if not found */
  81 {
  82     /* Get the first hash chain entry */
  83     CodeLabel* L = S->LabelHash[Hash];
  84
  85     /* Search the list */
  86     while (L) {
  87         if (strcmp (Name, L->Name) == 0) {
  88             /* Found */
  89             break;
  90         }
  91         L = L->Next;
  92     }
  93     return L;
  94 }
  95
  96
  97
  98 static CodeLabel* NewCodeSegLabel (CodeSeg* S, const char* Name, unsigned Hash)
  99 /* Create a new label and insert it into the label hash table */
 100 {
 101     /* Not found - create a new one */
 102     CodeLabel* L = NewCodeLabel (Name, Hash);
 103
 104     /* Enter the label into the hash table */
 105     L->Next = S->LabelHash[L->Hash];
 106     S->LabelHash[L->Hash] = L;
 107
 108     /* Return the new label */
 109     return L;
 110 }
 111
 112
 113
 114 static void RemoveLabelFromHash (CodeSeg* S, CodeLabel* L)
 115 /* Remove the given code label from the hash list */
 116 {
 117     /* Get the first entry in the hash chain */
 118     CodeLabel* List = S->LabelHash[L->Hash];
 119     CHECK (List != 0);
 120
 121     /* First, remove the label from the hash chain */
 122     if (List == L) {
 123         /* First entry in hash chain */
 124         S->LabelHash[L->Hash] = L->Next;
 125     } else {
 126         /* Must search through the chain */
 127         while (List->Next != L) {
 128             /* If we've reached the end of the chain, something is *really* wrong */
 129             CHECK (List->Next != 0);
 130             /* Next entry */
 131             List = List->Next;
 132         }
 133         /* The next entry is the one, we have been searching for */
 134         List->Next = L->Next;
 135     }
 136 }
 137
 138
 139
 140 /*****************************************************************************/
 141 /*                    Functions for parsing instructions                     */
 142 /*****************************************************************************/
 143
 144
 145
 146 static const char* SkipSpace (const char* S)
 147 /* Skip white space and return an updated pointer */
 148 {
 149     while (IsSpace (*S)) {
 150         ++S;
 151     }
 152     return S;
 153 }
 154
 155
 156
 157 static const char* ReadToken (const char* L, const char* Term,
 158                               char* Buf, unsigned BufSize)
 159 /* Read the next token into Buf, return the updated line pointer. The
 160  * token is terminated by one of the characters given in term.
 161  */
 162 {
 163     /* Read/copy the token */
 164     unsigned I = 0;
 165     unsigned ParenCount = 0;
 166     while (*L && (ParenCount > 0 || strchr (Term, *L) == 0)) {
 167         if (I < BufSize-1) {
 168             Buf[I++] = *L;
 169         }
 170         if (*L == ')') {
 171             --ParenCount;
 172         } else if (*L == '(') {
 173             ++ParenCount;
 174         }
 175         ++L;
 176     }
 177
 178     /* Terminate the buffer contents */
 179     Buf[I] = '\0';
 180
 181     /* Return the updated line pointer */
 182     return L;
 183 }
 184
 185
 186
 187 static CodeEntry* ParseInsn (CodeSeg* S, const char* L)
 188 /* Parse an instruction nnd generate a code entry from it. If the line contains
 189  * errors, output an error message and return NULL.
 190  * For simplicity, we don't accept the broad range of input a "real" assembler
 191  * does. The instruction and the argument are expected to be separated by
 192  * white space, for example.
 193  */
 194 {
 195     char                Mnemo[16];
 196     const OPCDesc*      OPC;
 197     am_t                AM = 0;         /* Initialize to keep gcc silent */
 198     char                Arg[64];
 199     char                Reg;
 200     CodeEntry*          E;
 201     CodeLabel*          Label;
 202
 203     /* Mnemonic */
 204     L = ReadToken (L, " \t", Mnemo, sizeof (Mnemo));
 205
 206     /* Try to find the opcode description for the mnemonic */
 207     OPC = FindOpcode (Mnemo);
 208
 209     /* If we didn't find the opcode, print an error and bail out */
 210     if (OPC == 0) {
 211         Error ("ASM code error: %s is not a valid mnemonic", Mnemo);
 212         return 0;
 213     }
 214
 215     /* Skip separator white space */
 216     L = SkipSpace (L);
 217
 218     /* Get the addressing mode */
 219     Arg[0] = '\0';
 220     switch (*L) {
 221
 222         case '\0':
 223             /* Implicit */
 224             AM = AM_IMP;
 225             break;
 226
 227         case '#':
 228             /* Immidiate */
 229             StrCopy (Arg, sizeof (Arg), L+1);
 230             AM = AM_IMM;
 231             break;
 232
 233         case '(':
 234             /* Indirect */
 235             L = ReadToken (L+1, ",)", Arg, sizeof (Arg));
 236
 237             /* Check for errors */
 238             if (*L == '\0') {
 239                 Error ("ASM code error: syntax error");
 240                 return 0;
 241             }
 242
 243             /* Check the different indirect modes */
 244             if (*L == ',') {
 245                 /* Expect zp x indirect */
 246                 L = SkipSpace (L+1);
 247                 if (toupper (*L) != 'X') {
 248                     Error ("ASM code error: `X' expected");
 249                     return 0;
 250                 }
 251                 L = SkipSpace (L+1);
 252                 if (*L != ')') {
 253                     Error ("ASM code error: `)' expected");
 254                     return 0;
 255                 }
 256                 L = SkipSpace (L+1);
 257                 if (*L != '\0') {
 258                     Error ("ASM code error: syntax error");
 259                     return 0;
 260                 }
 261                 AM = AM_ZPX_IND;
 262             } else if (*L == ')') {
 263                 /* zp indirect or zp indirect, y */
 264                 L = SkipSpace (L+1);
 265                 if (*L == ',') {
 266                     L = SkipSpace (L+1);
 267                     if (toupper (*L) != 'Y') {
 268                         Error ("ASM code error: `Y' expected");
 269                         return 0;
 270                     }
 271                     L = SkipSpace (L+1);
 272                     if (*L != '\0') {
 273                         Error ("ASM code error: syntax error");
 274                         return 0;
 275                     }
 276                     AM = AM_ZP_INDY;
 277                 } else if (*L == '\0') {
 278                     AM = AM_ZP_IND;
 279                 } else {
 280                     Error ("ASM code error: syntax error");
 281                     return 0;
 282                 }
 283             }
 284             break;
 285
 286         case 'a':
 287         case 'A':
 288             /* Accumulator? */
 289             if (L[1] == '\0') {
 290                 AM = AM_ACC;
 291                 break;
 292             }
 293             /* FALLTHROUGH */
 294
 295         default:
 296             /* Absolute, maybe indexed */
 297             L = ReadToken (L, ",", Arg, sizeof (Arg));
 298             if (*L == '\0') {
 299                 /* Assume absolute */
 300                 AM = AM_ABS;
 301             } else if (*L == ',') {
 302                 /* Indexed */
 303                 L = SkipSpace (L+1);
 304                 if (*L == '\0') {
 305                     Error ("ASM code error: syntax error");
 306                     return 0;
 307                 } else {
 308                     Reg = toupper (*L);
 309                     L = SkipSpace (L+1);
 310                     if (Reg == 'X') {
 311                         AM = AM_ABSX;
 312                     } else if (Reg == 'Y') {
 313                         AM = AM_ABSY;
 314                     } else {
 315                         Error ("ASM code error: syntax error");
 316                         return 0;
 317                     }
 318                     if (*L != '\0') {
 319                         Error ("ASM code error: syntax error");
 320                         return 0;
 321                     }
 322                 }
 323             }
 324             break;
 325
 326     }
 327
 328     /* If the instruction is a branch, check for the label and generate it
 329      * if it does not exist. Ignore anything but local labels here.
 330      */
 331     Label = 0;
 332     if ((OPC->Info & OF_BRA) != 0 && Arg[0] == 'L') {
 333
 334         unsigned Hash;
 335
 336         /* Addressing mode must be alsobute or something is really wrong */
 337         CHECK (AM == AM_ABS);
 338
 339         /* Addressing mode is a branch/jump */
 340         AM = AM_BRA;
 341
 342         /* Generate the hash over the label, then search for the label */
 343         Hash = HashStr (Arg) % CS_LABEL_HASH_SIZE;
 344         Label = FindCodeLabel (S, Arg, Hash);
 345
 346         /* If we don't have the label, it's a forward ref - create it */
 347         if (Label == 0) {
 348             /* Generate a new label */
 349             Label = NewCodeSegLabel (S, Arg, Hash);
 350         }
 351     }
 352
 353     /* We do now have the addressing mode in AM. Allocate a new CodeEntry
 354      * structure and initialize it.
 355      */
 356     E = NewCodeEntry (OPC, AM, Arg, Label);
 357
 358     /* Return the new code entry */
 359     return E;
 360 }
 361
 362
 363
 364 /*****************************************************************************/
 365 /*                                   Code                                    */
 366 /*****************************************************************************/
 367
 368
 369
 370 CodeSeg* NewCodeSeg (const char* SegName, SymEntry* Func)
 371 /* Create a new code segment, initialize and return it */
 372 {
 373     unsigned I;
 374
 375     /* Allocate memory */
 376     CodeSeg* S = xmalloc (sizeof (CodeSeg));
 377
 378     /* Initialize the fields */
 379     S->SegName  = xstrdup (SegName);
 380     S->Func     = Func;
 381     InitCollection (&S->Entries);
 382     InitCollection (&S->Labels);
 383     for (I = 0; I < sizeof(S->LabelHash) / sizeof(S->LabelHash[0]); ++I) {
 384         S->LabelHash[I] = 0;
 385     }
 386
 387     /* If we have a function given, get the return type of the function.
 388      * Assume ANY return type besides void will use the A and X registers.
 389      */
 390     if (S->Func && !IsTypeVoid (GetFuncReturn (Func->Type))) {
 391         S->ExitRegs = REG_AX;
 392     } else {
 393         S->ExitRegs = REG_NONE;
 394     }
 395
 396     /* Return the new struct */
 397     return S;
 398 }
 399
 400
 401
 402 void AddCodeEntry (CodeSeg* S, const char* Format, va_list ap)
 403 /* Add a line to the given code segment */
 404 {
 405     const char* L;
 406     CodeEntry*  E;
 407     char        Token[64];
 408
 409     /* Format the line */
 410     char Buf [256];
 411     xvsprintf (Buf, sizeof (Buf), Format, ap);
 412
 413     /* Skip whitespace */
 414     L = SkipSpace (Buf);
 415
 416     /* Check which type of instruction we have */
 417     E = 0;      /* Assume no insn created */
 418     switch (*L) {
 419
 420         case '\0':
 421             /* Empty line, just ignore it */
 422             break;
 423
 424         case ';':
 425             /* Comment or hint, ignore it for now */
 426             break;
 427
 428         case '.':
 429             /* Control instruction */
 430             ReadToken (L, " \t", Token, sizeof (Token));
 431             Error ("ASM code error: Pseudo instruction `%s' not supported", Token);
 432             break;
 433
 434         default:
 435             E = ParseInsn (S, L);
 436             break;
 437     }
 438
 439     /* If we have a code entry, transfer the labels and insert it */
 440     if (E) {
 441
 442         /* Transfer the labels if we have any */
 443         unsigned I;
 444         unsigned LabelCount = CollCount (&S->Labels);
 445         for (I = 0; I < LabelCount; ++I) {
 446
 447             /* Get the label */
 448             CodeLabel* L = CollAt (&S->Labels, I);
 449
 450             /* Attach it to the entry */
 451             AttachCodeLabel (E, L);
 452         }
 453
 454         /* Delete the transfered labels */
 455         CollDeleteAll (&S->Labels);
 456
 457         /* Add the entry to the list of code entries in this segment */
 458         CollAppend (&S->Entries, E);
 459
 460     }
 461 }
 462
 463
 464
 465 void InsertCodeEntry (CodeSeg* S, struct CodeEntry* E, unsigned Index)
 466 /* Insert the code entry at the index given. Following code entries will be
 467  * moved to slots with higher indices.
 468  */
 469 {
 470     /* Insert the entry into the collection */
 471     CollInsert (&S->Entries, E, Index);
 472 }
 473
 474
 475
 476 void DelCodeEntry (CodeSeg* S, unsigned Index)
 477 /* Delete an entry from the code segment. This includes moving any associated
 478  * labels, removing references to labels and even removing the referenced labels
 479  * if the reference count drops to zero.
 480  */
 481 {
 482     /* Get the code entry for the given index */
 483     CodeEntry* E = GetCodeEntry (S, Index);
 484
 485     /* If the entry has a labels, we have to move this label to the next insn.
 486      * If there is no next insn, move the label into the code segement label
 487      * pool. The operation is further complicated by the fact that the next
 488      * insn may already have a label. In that case change all reference to
 489      * this label and delete the label instead of moving it.
 490      */
 491     unsigned Count = GetCodeLabelCount (E);
 492     if (Count > 0) {
 493
 494         /* The instruction has labels attached. Check if there is a next
 495          * instruction.
 496          */
 497         if (Index == GetCodeEntryCount (S)-1) {
 498
 499             /* No next instruction, move to the codeseg label pool */
 500             MoveLabelsToPool (S, E);
 501
 502         } else {
 503
 504             /* There is a next insn, get it */
 505             CodeEntry* N = GetCodeEntry (S, Index+1);
 506
 507             /* Move labels to the next entry */
 508             MoveCodeLabels (S, E, N);
 509
 510         }
 511     }
 512
 513     /* If this insn references a label, remove the reference. And, if the
 514      * the reference count for this label drops to zero, remove this label.
 515      */
 516     if (E->JumpTo) {
 517         /* Remove the reference */
 518         RemoveCodeLabelRef (S, E);
 519     }
 520
 521     /* Delete the pointer to the insn */
 522     CollDelete (&S->Entries, Index);
 523
 524     /* Delete the instruction itself */
 525     FreeCodeEntry (E);
 526 }
 527
 528
 529
 530 struct CodeEntry* GetCodeEntry (CodeSeg* S, unsigned Index)
 531 /* Get an entry from the given code segment */
 532 {
 533     return CollAt (&S->Entries, Index);
 534 }
 535
 536
 537
 538 struct CodeEntry* GetNextCodeEntry (CodeSeg* S, unsigned Index)
 539 /* Get the code entry following the one with the index Index. If there is no
 540  * following code entry, return NULL.
 541  */
 542 {
 543     if (Index >= CollCount (&S->Entries)-1) {
 544         /* This is the last entry */
 545         return 0;
 546     } else {
 547         /* Code entries left */
 548         return CollAt (&S->Entries, Index+1);
 549     }
 550 }
 551
 552
 553
 554 unsigned GetCodeEntryIndex (CodeSeg* S, struct CodeEntry* E)
 555 /* Return the index of a code entry */
 556 {
 557     int Index = CollIndex (&S->Entries, E);
 558     CHECK (Index >= 0);
 559     return Index;
 560 }
 561
 562
 563
 564 void AddCodeLabel (CodeSeg* S, const char* Name)
 565 /* Add a code label for the next instruction to follow */
 566 {
 567     /* Calculate the hash from the name */
 568     unsigned Hash = HashStr (Name) % CS_LABEL_HASH_SIZE;
 569
 570     /* Try to find the code label if it does already exist */
 571     CodeLabel* L = FindCodeLabel (S, Name, Hash);
 572
 573     /* Did we find it? */
 574     if (L) {
 575         /* We found it - be sure it does not already have an owner */
 576         CHECK (L->Owner == 0);
 577     } else {
 578         /* Not found - create a new one */
 579         L = NewCodeSegLabel (S, Name, Hash);
 580     }
 581
 582     /* Safety. This call is quite costly, but safety is better */
 583     if (CollIndex (&S->Labels, L) >= 0) {
 584         Internal ("AddCodeLabel: Label `%s' already defined", Name);
 585     }
 586
 587     /* We do now have a valid label. Remember it for later */
 588     CollAppend (&S->Labels, L);
 589 }
 590
 591
 592
 593 CodeLabel* GenCodeLabel (CodeSeg* S, struct CodeEntry* E)
 594 /* If the code entry E does already have a label, return it. Otherwise
 595  * create a new label, attach it to E and return it.
 596  */
 597 {
 598     CodeLabel* L;
 599
 600     if (CodeEntryHasLabel (E)) {
 601
 602         /* Get the label from this entry */
 603         L = GetCodeLabel (E, 0);
 604
 605     } else {
 606
 607         /* Get a new name */
 608         const char* Name = LocalLabelName (GetLocalLabel ());
 609
 610         /* Generate the hash over the name */
 611         unsigned Hash = HashStr (Name) % CS_LABEL_HASH_SIZE;
 612
 613         /* Create a new label */
 614         L = NewCodeSegLabel (S, Name, Hash);
 615
 616         /* Attach this label to the code entry */
 617         AttachCodeLabel (E, L);
 618
 619     }
 620
 621     /* Return the label */
 622     return L;
 623 }
 624
 625
 626
 627 void DelCodeLabel (CodeSeg* S, CodeLabel* L)
 628 /* Remove references from this label and delete it. */
 629 {
 630     unsigned Count, I;
 631
 632     /* First, remove the label from the hash chain */
 633     RemoveLabelFromHash (S, L);
 634
 635     /* Remove references from insns jumping to this label */
 636     Count = CollCount (&L->JumpFrom);
 637     for (I = 0; I < Count; ++I) {
 638         /* Get the insn referencing this label */
 639         CodeEntry* E = CollAt (&L->JumpFrom, I);
 640         /* Remove the reference */
 641         E->JumpTo = 0;
 642     }
 643     CollDeleteAll (&L->JumpFrom);
 644
 645     /* Remove the reference to the owning instruction if it has one. The
 646      * function may be called for a label without an owner when deleting
 647      * unfinished parts of the code. This is unfortunate since it allows
 648      * errors to slip through.
 649      */
 650     if (L->Owner) {
 651         CollDeleteItem (&L->Owner->Labels, L);
 652     }
 653
 654     /* All references removed, delete the label itself */
 655     FreeCodeLabel (L);
 656 }
 657
 658
 659
 660 void MergeCodeLabels (CodeSeg* S)
 661 /* Merge code labels. That means: For each instruction, remove all labels but
 662  * one and adjust references accordingly.
 663  */
 664 {
 665     unsigned I;
 666
 667     /* Walk over all code entries */
 668     unsigned EntryCount = GetCodeEntryCount (S);
 669     for (I = 0; I < EntryCount; ++I) {
 670
 671         CodeLabel* RefLab;
 672         unsigned   J;
 673
 674         /* Get a pointer to the next entry */
 675         CodeEntry* E = GetCodeEntry (S, I);
 676
 677         /* If this entry has zero labels, continue with the next one */
 678         unsigned LabelCount = GetCodeLabelCount (E);
 679         if (LabelCount == 0) {
 680             continue;
 681         }
 682
 683         /* We have at least one label. Use the first one as reference label. */
 684         RefLab = GetCodeLabel (E, 0);
 685
 686         /* Walk through the remaining labels and change references to these
 687          * labels to a reference to the one and only label. Delete the labels
 688          * that are no longer used. To increase performance, walk backwards
 689          * through the list.
 690          */
 691         for (J = LabelCount-1; J >= 1; --J) {
 692
 693             /* Get the next label */
 694             CodeLabel* L = GetCodeLabel (E, J);
 695
 696             /* Move all references from this label to the reference label */
 697             MoveLabelRefs (L, RefLab);
 698
 699             /* Remove the label completely. */
 700             DelCodeLabel (S, L);
 701         }
 702
 703         /* The reference label is the only remaining label. Check if there
 704          * are any references to this label, and delete it if this is not
 705          * the case.
 706          */
 707         if (CollCount (&RefLab->JumpFrom) == 0) {
 708             /* Delete the label */
 709             DelCodeLabel (S, RefLab);
 710         }
 711     }
 712 }
 713
 714
 715
 716 void MoveCodeLabels (CodeSeg* S, struct CodeEntry* Old, struct CodeEntry* New)
 717 /* Move all labels from Old to New. The routine will move the labels itself
 718  * if New does not have any labels, and move references if there is at least
 719  * a label for new. If references are moved, the old label is deleted
 720  * afterwards.
 721  */
 722 {
 723     /* Get the number of labels to move */
 724     unsigned OldLabelCount = GetCodeLabelCount (Old);
 725
 726     /* Does the new entry have itself a label? */
 727     if (CodeEntryHasLabel (New)) {
 728
 729         /* The new entry does already have a label - move references */
 730         CodeLabel* NewLabel = GetCodeLabel (New, 0);
 731         while (OldLabelCount--) {
 732
 733             /* Get the next label */
 734             CodeLabel* OldLabel = GetCodeLabel (Old, OldLabelCount);
 735
 736             /* Move references */
 737             MoveLabelRefs (OldLabel, NewLabel);
 738
 739             /* Delete the label */
 740             DelCodeLabel (S, OldLabel);
 741
 742         }
 743
 744     } else {
 745
 746         /* The new entry does not have a label, just move them */
 747         while (OldLabelCount--) {
 748
 749             /* Move the label to the new entry */
 750             MoveCodeLabel (GetCodeLabel (Old, OldLabelCount), New);
 751
 752         }
 753
 754     }
 755 }
 756
 757
 758
 759 void RemoveCodeLabelRef (CodeSeg* S, struct CodeEntry* E)
 760 /* Remove the reference between E and the label it jumps to. The reference
 761  * will be removed on both sides and E->JumpTo will be 0 after that. If
 762  * the reference was the only one for the label, the label will get
 763  * deleted.
 764  */
 765 {
 766     /* Get a pointer to the label and make sure it exists */
 767     CodeLabel* L = E->JumpTo;
 768     CHECK (L != 0);
 769
 770     /* Delete the entry from the label */
 771     CollDeleteItem (&L->JumpFrom, E);
 772
 773     /* The entry jumps no longer to L */
 774     E->JumpTo = 0;
 775
 776     /* If there are no more references, delete the label */
 777     if (CollCount (&L->JumpFrom) == 0) {
 778         DelCodeLabel (S, L);
 779     }
 780 }
 781
 782
 783
 784 void MoveCodeLabelRef (CodeSeg* S, struct CodeEntry* E, CodeLabel* L)
 785 /* Change the reference of E to L instead of the current one. If this
 786  * was the only reference to the old label, the old label will get
 787  * deleted.
 788  */
 789 {
 790     /* Get the old label */
 791     CodeLabel* OldLabel = E->JumpTo;
 792
 793     /* Be sure that code entry references a label */
 794     PRECONDITION (OldLabel != 0);
 795
 796     /* Remove the reference to our label */
 797     RemoveCodeLabelRef (S, E);
 798
 799     /* Use the new label */
 800     AddLabelRef (L, E);
 801 }
 802
 803
 804
 805 void AddCodeSegHint (CodeSeg* S, unsigned Hint)
 806 /* Add a hint for the preceeding instruction */
 807 {
 808     CodeEntry* E;
 809
 810     /* Get the number of entries in this segment */
 811     unsigned EntryCount = GetCodeEntryCount (S);
 812
 813     /* Must have at least one entry */
 814     CHECK (EntryCount > 0);
 815
 816     /* Get the last entry */
 817     E = GetCodeEntry (S, EntryCount-1);
 818
 819     /* Add the hint */
 820     E->Hints |= Hint;
 821 }
 822
 823
 824
 825 void DelCodeSegAfter (CodeSeg* S, unsigned Last)
 826 /* Delete all entries including the given one */
 827 {
 828     /* Get the number of entries in this segment */
 829     unsigned Count = GetCodeEntryCount (S);
 830
 831     /* First pass: Delete all references to labels. If the reference count
 832      * for a label drops to zero, delete it.
 833      */
 834     unsigned C = Count;
 835     while (Last < C--) {
 836
 837         /* Get the next entry */
 838         CodeEntry* E = GetCodeEntry (S, C);
 839
 840         /* Check if this entry has a label reference */
 841         if (E->JumpTo) {
 842             /* Remove the reference to the label */
 843             RemoveCodeLabelRef (S, E);
 844         }
 845
 846     }
 847
 848     /* Second pass: Delete the instructions. If a label attached to an
 849      * instruction still has references, it must be references from outside
 850      * the deleted area. Don't delete the label in this case, just make it
 851      * ownerless and move it to the label pool.
 852      */
 853     C = Count;
 854     while (Last < C--) {
 855
 856         /* Get the next entry */
 857         CodeEntry* E = GetCodeEntry (S, C);
 858
 859         /* Check if this entry has a label attached */
 860         if (CodeEntryHasLabel (E)) {
 861             /* Move the labels to the pool and clear the owner pointer */
 862             MoveLabelsToPool (S, E);
 863         }
 864
 865         /* Delete the pointer to the entry */
 866         CollDelete (&S->Entries, C);
 867
 868         /* Delete the entry itself */
 869         FreeCodeEntry (E);
 870     }
 871 }
 872
 873
 874
 875 void OutputCodeSeg (const CodeSeg* S, FILE* F)
 876 /* Output the code segment data to a file */
 877 {
 878     unsigned I;
 879
 880     /* Get the number of entries in this segment */
 881     unsigned Count = GetCodeEntryCount (S);
 882
 883     /* If the code segment is empty, bail out here */
 884     if (Count == 0) {
 885         return;
 886     }
 887
 888     /* Output the segment directive */
 889     fprintf (F, ".segment\t\"%s\"\n\n", S->SegName);
 890
 891     /* If this is a segment for a function, enter a function */
 892     if (S->Func) {
 893         fprintf (F, ".proc\t_%s\n\n", S->Func->Name);
 894     }
 895
 896     /* Output all entries */
 897     for (I = 0; I < Count; ++I) {
 898
 899         unsigned char Use;
 900
 901         OutputCodeEntry (CollConstAt (&S->Entries, I), F);
 902
 903         /* Print usage info */
 904         Use = GetRegInfo ((CodeSeg*) S, I+1);
 905         fprintf (F,
 906                  "  Use: %c%c%c\n",
 907                  (Use & REG_A)? 'A' : '_',
 908                  (Use & REG_X)? 'X' : '_',
 909                  (Use & REG_Y)? 'Y' : '_');
 910     }
 911
 912     /* If this is a segment for a function, leave the function */
 913     if (S->Func) {
 914         fprintf (F, "\n.endproc\n\n");
 915     }
 916 }
 917
 918
 919
 920 unsigned GetCodeEntryCount (const CodeSeg* S)
 921 /* Return the number of entries for the given code segment */
 922 {
 923     return CollCount (&S->Entries);
 924 }
 925
 926
 927
 928