/* */
/* */
/* */
-/* (C) 1999-2003 Ullrich von Bassewitz */
-/* Römerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 1999-2010, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
#include <stdio.h>
#include <string.h>
+#include <limits.h>
#include <errno.h>
#include <time.h>
#include "fileio.h"
#include "global.h"
#include "lineinfo.h"
+#include "memarea.h"
#include "o65.h"
#include "spool.h"
};
/* A o65 relocation table */
-#define RELOC_BLOCKSIZE 4096
typedef struct O65RelocTab O65RelocTab;
struct O65RelocTab {
unsigned Size; /* Size of the table */
O65Desc* D; /* File format descriptor */
long Val; /* The offset value */
int TooComplex; /* Expression too complex */
+ MemoryArea* MemRef; /* Memory reference if any */
Segment* SegRef; /* Segment reference if any */
Section* SecRef; /* Section reference if any */
ExtSym* ExtRef; /* External reference if any */
ED->D = D;
ED->Val = 0;
ED->TooComplex = 0;
+ ED->MemRef = 0;
ED->SegRef = 0;
ED->SecRef = 0;
ED->ExtRef = 0;
+static void CvtMemoryToSegment (ExprDesc* ED)
+/* Convert a memory area into a segment by searching the list of run segments
+ * in this memory area and assigning the nearest one.
+ */
+{
+ /* Get the memory area from the expression */
+ MemoryArea* M = ED->MemRef;
+
+ /* Remember the "nearest" segment and its offset */
+ Segment* Nearest = 0;
+ unsigned long Offs = ULONG_MAX;
+
+ /* Walk over all segments */
+ unsigned I;
+ for (I = 0; I < CollCount (&M->SegList); ++I) {
+
+ /* Get the segment and check if it's a run segment */
+ SegDesc* S = CollAtUnchecked (&M->SegList, I);
+ if (S->Run == M) {
+
+ unsigned long O;
+
+ /* Get the segment from the segment descriptor */
+ Segment* Seg = S->Seg;
+
+ /* Check the PC. */
+ if ((long) Seg->PC <= ED->Val && (O = (ED->Val - Seg->PC)) < Offs) {
+ /* This is the nearest segment for now */
+ Offs = O;
+ Nearest = Seg;
+
+ /* If we found an exact match, don't look further */
+ if (Offs == 0) {
+ break;
+ }
+ }
+ }
+ }
+
+ /* If we found a segment, use it and adjust the offset */
+ if (Nearest) {
+ ED->SegRef = Nearest;
+ ED->MemRef = 0;
+ ED->Val -= Nearest->PC;
+ }
+}
+
+
+
static const SegDesc* FindSeg (SegDesc** const List, unsigned Count, const Segment* S)
/* Search for a segment in the given list of segment descriptors and return
* the descriptor for a segment if we found it, and NULL if not.
*/
{
Export* E;
- unsigned long Val;
switch (Expr->Op) {
case EXPR_LITERAL:
- if (Sign < 0) {
- D->Val -= Expr->V.Val;
- } else {
- D->Val += Expr->V.Val;
- }
+ D->Val += (Sign * Expr->V.IVal);
break;
case EXPR_SYMBOL:
/* Remember the segment reference */
D->SecRef = GetExprSection (Expr);
/* Add the offset of the section to the constant value */
- Val = D->SecRef->Offs + D->SecRef->Seg->PC;
- if (Sign < 0) {
- D->Val -= Val;
- } else {
- D->Val += Val;
- }
+ D->Val += Sign * (D->SecRef->Offs + D->SecRef->Seg->PC);
}
break;
/* Remember the segment reference */
D->SegRef = Expr->V.Seg;
/* Add the offset of the segment to the constant value */
- Val = D->SegRef->PC;
- if (Sign < 0) {
- D->Val -= Val;
- } else {
- D->Val += Val;
- }
+ D->Val += (Sign * D->SegRef->PC);
+ }
+ break;
+
+ case EXPR_MEMAREA:
+ if (D->MemRef) {
+ /* We cannot handle more than one memory reference in o65 */
+ D->TooComplex = 1;
+ } else {
+ /* Remember the memory area reference */
+ D->MemRef = Expr->V.Mem;
+ /* Add the start address of the memory area to the constant
+ * value
+ */
+ D->Val += (Sign * D->MemRef->Start);
}
break;
/* Do we have enough space in the buffer? */
if (R->Fill == R->Size) {
/* We need to grow the buffer */
- unsigned char* NewBuf = xmalloc (R->Size + RELOC_BLOCKSIZE);
- memcpy (NewBuf, R->Buf, R->Size);
- xfree (R->Buf);
- R->Buf = NewBuf;
+ if (R->Size) {
+ R->Size *= 2;
+ } else {
+ R->Size = 1024; /* Initial size */
+ }
+ R->Buf = xrealloc (R->Buf, R->Size);
}
/* Put the byte into the buffer */
O65ParseExpr (Expr, InitExprDesc (&ED, D), 1);
/* We cannot handle more than one external reference */
- RefCount = (ED.SegRef != 0) + (ED.SecRef != 0) + (ED.ExtRef != 0);
+ RefCount = (ED.MemRef != 0) + (ED.SegRef != 0) +
+ (ED.SecRef != 0) + (ED.ExtRef != 0);
if (RefCount > 1) {
ED.TooComplex = 1;
}
+ /* If we have a memory area reference, we need to convert it into a
+ * segment reference. If we cannot do that, we cannot handle the
+ * expression.
+ */
+ if (ED.MemRef) {
+ CvtMemoryToSegment (&ED);
+ if (ED.SegRef == 0) {
+ return SEG_EXPR_TOO_COMPLEX;
+ }
+ }
+
/* Bail out if we cannot handle the expression */
if (ED.TooComplex) {
return SEG_EXPR_TOO_COMPLEX;
/* Get the segment from the list node */
S = Seg [I];
+ /* Relocate line info for this segment */
+ RelocLineInfo (S->Seg);
+
/* Keep the user happy */
Print (stdout, 1, " Writing `%s'\n", GetString (S->Name));
/* Write this segment */
if (DoWrite) {
- RelocLineInfo (S->Seg);
- SegWrite (D->F, S->Seg, O65WriteExpr, D);
+ SegWrite (D->Filename, D->F, S->Seg, O65WriteExpr, D);
}
/* Mark the segment as dumped */
/* Write the correct option length */
switch (OS) {
- case O65OS_OSA65:
- case O65OS_LUNIX:
- /* No id for these two */
- O65SetOption (D, O65OPT_OS, Opt, 2);
- break;
case O65OS_CC65:
/* Set the 16 bit id */
break;
default:
- Internal ("Trying to set invalid O65 operating system: %u", OS);
+ /* No id for OS/A65, Lunix, and unknown OSes */
+ O65SetOption (D, O65OPT_OS, Opt, 2);
+ break;
+
}
}
static void O65SetupSegments (O65Desc* D, File* F)
/* Setup segment assignments */
{
- Memory* M;
- MemListNode* N;
- SegDesc* S;
+ unsigned I;
unsigned TextIdx, DataIdx, BssIdx, ZPIdx;
/* Initialize the counters */
D->ZPCount = 0;
/* Walk over the memory list */
- M = F->MemList;
- while (M) {
+ for (I = 0; I < CollCount (&F->MemoryAreas); ++I) {
+ /* Get this entry */
+ MemoryArea* M = CollAtUnchecked (&F->MemoryAreas, I);
+
/* Walk through the segment list and count the segment types */
- N = M->SegList;
- while (N) {
+ unsigned J;
+ for (J = 0; J < CollCount (&M->SegList); ++J) {
- /* Get the segment from the list node */
- S = N->Seg;
+ /* Get the segment */
+ SegDesc* S = CollAtUnchecked (&M->SegList, J);
/* Check the segment type. */
switch (O65SegType (S)) {
case O65SEG_DATA: D->DataCount++; break;
case O65SEG_BSS: D->BssCount++; break;
case O65SEG_ZP: D->ZPCount++; break;
- default: Internal ("Invalid return from O65SegType");
+ default: Internal ("Invalid return from O65SegType");
}
-
- /* Next segment node */
- N = N->Next;
}
- /* Next memory area */
- M = M->FNext;
}
/* Allocate memory according to the numbers */
/* Walk again through the list and setup the segment arrays */
TextIdx = DataIdx = BssIdx = ZPIdx = 0;
- M = F->MemList;
- while (M) {
+ for (I = 0; I < CollCount (&F->MemoryAreas); ++I) {
+ /* Get this entry */
+ MemoryArea* M = CollAtUnchecked (&F->MemoryAreas, I);
- N = M->SegList;
- while (N) {
+ /* Walk over the segment list and check the segment types */
+ unsigned J;
+ for (J = 0; J < CollCount (&M->SegList); ++J) {
- /* Get the segment from the list node */
- S = N->Seg;
+ /* Get the segment */
+ SegDesc* S = CollAtUnchecked (&M->SegList, J);
/* Check the segment type. */
switch (O65SegType (S)) {
case O65SEG_ZP: D->ZPSeg [ZPIdx++] = S; break;
default: Internal ("Invalid return from O65SegType");
}
-
- /* Next segment node */
- N = N->Next;
}
- /* Next memory area */
- M = M->FNext;
}
}
* if we get an unresolved symbol.
*/
D->Undef = 0; /* Reset the counter */
- CheckExports (O65Unresolved, D);
+ CheckUnresolvedImports (O65Unresolved, D);
if (D->Undef > 0) {
/* We had unresolved symbols, cannot create output file */
Error ("%u unresolved external(s) found - cannot create output file", D->Undef);
}
OptBuf[OptLen] = '\0';
O65SetOption (D, O65OPT_TIMESTAMP, OptBuf, OptLen + 1);
- sprintf (OptBuf, "ld65 V%u.%u.%u", VER_MAJOR, VER_MINOR, VER_PATCH);
+ sprintf (OptBuf, "ld65 V%s", GetVersionAsString ());
O65SetOption (D, O65OPT_ASM, OptBuf, strlen (OptBuf) + 1);
/* Write the header */
projects / cc65 / blobdiff