/* */
/* */
/* */
-/* (C) 1999 Ullrich von Bassewitz */
-/* Wacholderweg 14 */
-/* D-70597 Stuttgart */
-/* EMail: uz@musoftware.de */
+/* (C) 1999-2001 Ullrich von Bassewitz */
+/* Wacholderweg 14 */
+/* D-70597 Stuttgart */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
#include <errno.h>
#include <time.h>
-#include "../common/version.h"
+/* common */
+#include "check.h"
+#include "print.h"
+#include "version.h"
+#include "xmalloc.h"
-#include "global.h"
+/* ld65 */
#include "error.h"
-#include "mem.h"
-#include "fileio.h"
#include "exports.h"
#include "expr.h"
+#include "fileio.h"
+#include "global.h"
+#include "lineinfo.h"
#include "o65.h"
/* Header mode bits */
+#define MF_CPU_65816 0x8000 /* Executable is for 65816 */
+#define MF_CPU_6502 0x0000 /* Executable is for the 6502 */
+#define MF_CPU_MASK 0x8000 /* Mask to extract CPU type */
+
#define MF_SIZE_32BIT 0x2000 /* All size words are 32bit */
-#define MF_CPU_816 0x8000 /* Executable is for 65816 */
+#define MF_SIZE_16BIT 0x0000 /* All size words are 16bit */
+#define MF_SIZE_MASK 0x2000 /* Mask to extract size */
+
+#define MF_ALIGN_1 0x0000 /* Bytewise alignment */
+#define MF_ALIGN_2 0x0001 /* Align words */
+#define MF_ALIGN_4 0x0002 /* Align longwords */
+#define MF_ALIGN_256 0x0003 /* Align pages (256 bytes) */
+#define MF_ALIGN_MASK 0x0003 /* Mask to extract alignment */
/* The four o65 segment types. Note: These values are identical to the values
* needed for the segmentID in the o65 spec.
#define O65SEG_TEXT 0x02
#define O65SEG_DATA 0x03
#define O65SEG_BSS 0x04
-#define O65SEG_ZP 0x05
+#define O65SEG_ZP 0x05
/* Relocation type codes for the o65 format */
#define O65RELOC_WORD 0x80
#define O65RELOC_LOW 0x20
#define O65RELOC_SEGADR 0xc0
#define O65RELOC_SEG 0xa0
+#define O65RELOC_MASK 0xc0
/* O65 executable file header */
-typedef struct O65Header_ O65Header;
-struct O65Header_ {
+typedef struct O65Header O65Header;
+struct O65Header {
unsigned Version; /* Version number for o65 format */
unsigned Mode; /* Mode word */
unsigned long TextBase; /* Base address of text segment */
};
/* An o65 option */
-typedef struct O65Option_ O65Option;
-struct O65Option_ {
+typedef struct O65Option O65Option;
+struct O65Option {
O65Option* Next; /* Next in option list */
unsigned char Type; /* Type of option */
unsigned char Len; /* Data length */
/* A o65 relocation table */
#define RELOC_BLOCKSIZE 4096
-typedef struct O65RelocTab_ O65RelocTab;
-struct O65RelocTab_ {
+typedef struct O65RelocTab O65RelocTab;
+struct O65RelocTab {
unsigned Size; /* Size of the table */
unsigned Fill; /* Amount used */
unsigned char* Buf; /* Buffer, dynamically allocated */
};
/* Structure describing the format */
-struct O65Desc_ {
- O65Header Header; /* File header */
+struct O65Desc {
+ O65Header Header; /* File header */
O65Option* Options; /* List of file options */
ExtSymTab* Exports; /* Table with exported symbols */
ExtSymTab* Imports; /* Table with imported symbols */
- unsigned Undef; /* Count of undefined symbols */
- FILE* F; /* The file we're writing to */
- char* Filename; /* Name of the output file */
+ unsigned Undef; /* Count of undefined symbols */
+ FILE* F; /* The file we're writing to */
+ char* Filename; /* Name of the output file */
O65RelocTab* TextReloc; /* Relocation table for text segment */
O65RelocTab* DataReloc; /* Relocation table for data segment */
- unsigned TextCount; /* Number of segments assigned to .text */
- SegDesc** TextSeg; /* Array of text segments */
- unsigned DataCount; /* Number of segments assigned to .data */
- SegDesc** DataSeg; /* Array of data segments */
- unsigned BssCount; /* Number of segments assigned to .bss */
- SegDesc** BssSeg; /* Array of bss segments */
- unsigned ZPCount; /* Number of segments assigned to .zp */
- SegDesc** ZPSeg; /* Array of zp segments */
+ unsigned TextCount; /* Number of segments assigned to .text */
+ SegDesc** TextSeg; /* Array of text segments */
+ unsigned DataCount; /* Number of segments assigned to .data */
+ SegDesc** DataSeg; /* Array of data segments */
+ unsigned BssCount; /* Number of segments assigned to .bss */
+ SegDesc** BssSeg; /* Array of bss segments */
+ unsigned ZPCount; /* Number of segments assigned to .zp */
+ SegDesc** ZPSeg; /* Array of zp segments */
/* Temporary data for writing segments */
unsigned long SegSize;
O65RelocTab* CurReloc;
- long LastOffs;
+ long LastOffs;
};
/* Structure for parsing expression trees */
-typedef struct ExprDesc_ ExprDesc;
-struct ExprDesc_ {
- O65Desc* D; /* File format descriptor */
- long Val; /* The offset value */
+typedef struct ExprDesc ExprDesc;
+struct ExprDesc {
+ O65Desc* D; /* File format descriptor */
+ long Val; /* The offset value */
int TooComplex; /* Expression too complex */
- Section* SegRef; /* Section referenced if any */
- ExtSym* ExtRef; /* External reference if any */
+ Section* SegRef; /* Section referenced if any */
+ ExtSym* ExtRef; /* External reference if any */
};
/*****************************************************************************/
-/* Helper functions */
+/* Helper functions */
/*****************************************************************************/
+static ExprDesc* InitExprDesc (ExprDesc* ED, O65Desc* D)
+/* Initialize an ExprDesc structure for use with O65ParseExpr */
+{
+ ED->D = D;
+ ED->Val = 0;
+ ED->TooComplex = 0;
+ ED->SegRef = 0;
+ ED->ExtRef = 0;
+ return ED;
+}
+
+
+
static void WriteSize (const O65Desc* D, unsigned long Val)
/* Write a "size" word to the file */
{
- if (D->Header.Mode & MF_SIZE_32BIT) {
- Write32 (D->F, Val);
- } else {
- Write16 (D->F, (unsigned) Val);
+ switch (D->Header.Mode & MF_SIZE_MASK) {
+ case MF_SIZE_16BIT: Write16 (D->F, (unsigned) Val); break;
+ case MF_SIZE_32BIT: Write32 (D->F, Val); break;
+ default: Internal ("Invalid size in header: %04X", D->Header.Mode);
}
}
* to check SF_ZP first.
*/
if (S->Flags & SF_RO) {
- return O65SEG_TEXT;
+ return O65SEG_TEXT;
} else if (S->Flags & SF_ZP) {
- return O65SEG_ZP;
+ return O65SEG_ZP;
} else if (S->Flags & SF_BSS) {
- return O65SEG_BSS;
+ return O65SEG_BSS;
} else {
- return O65SEG_DATA;
+ return O65SEG_DATA;
}
}
+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.
+ */
+{
+ unsigned I;
+
+ for (I = 0; I < Count; ++I) {
+ if (List[I]->Seg == S) {
+ /* Found */
+ return List[I];
+ }
+ }
+
+ /* Not found */
+ return 0;
+}
+
+
+
+static const SegDesc* O65FindSeg (const O65Desc* D, const Segment* S)
+/* Search for a segment in the segment lists and return it's segment descriptor */
+{
+ const SegDesc* SD;
+
+ if ((SD = FindSeg (D->TextSeg, D->TextCount, S)) != 0) {
+ return SD;
+ }
+ if ((SD = FindSeg (D->DataSeg, D->DataCount, S)) != 0) {
+ return SD;
+ }
+ if ((SD = FindSeg (D->BssSeg, D->BssCount, S)) != 0) {
+ return SD;
+ }
+ if ((SD = FindSeg (D->ZPSeg, D->ZPCount, S)) != 0) {
+ return SD;
+ }
+
+ /* Not found */
+ return 0;
+}
+
+
+
/*****************************************************************************/
-/* Expression handling */
+/* Expression handling */
/*****************************************************************************/
}
} else {
MarkExport (E);
- O65ParseExpr (E->Expr, D, Sign);
+ O65ParseExpr (E->Expr, D, Sign);
UnmarkExport (E);
}
break;
/* We cannot handle more than one segment reference in o65 */
D->TooComplex = 1;
} else {
- /* Remember the segment reference */
+ /* Remember the segment reference */
D->SegRef = GetExprSection (Expr);
}
break;
/* Create a new relocation table */
{
/* Allocate a new structure */
- O65RelocTab* R = Xmalloc (sizeof (O65RelocTab));
+ O65RelocTab* R = xmalloc (sizeof (O65RelocTab));
/* Initialize the data */
R->Size = RELOC_BLOCKSIZE;
R->Fill = 0;
- R->Buf = Xmalloc (RELOC_BLOCKSIZE);
+ R->Buf = xmalloc (RELOC_BLOCKSIZE);
/* Return the created struct */
return R;
static void FreeO65RelocTab (O65RelocTab* R)
/* Free a relocation table */
{
- Xfree (R->Buf);
- Xfree (R);
+ xfree (R->Buf);
+ xfree (R);
}
-static void O65RelocPutByte (O65RelocTab* R, unsigned char B)
+static void O65RelocPutByte (O65RelocTab* R, unsigned B)
/* Put the byte into the relocation table */
{
/* 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);
+ unsigned char* NewBuf = xmalloc (R->Size + RELOC_BLOCKSIZE);
memcpy (NewBuf, R->Buf, R->Size);
- Xfree (R->Buf);
+ xfree (R->Buf);
R->Buf = NewBuf;
}
/* Put the byte into the buffer */
- R->Buf [R->Fill++] = B;
+ R->Buf [R->Fill++] = (unsigned char) B;
}
/*****************************************************************************/
-/* Option handling */
+/* Option handling */
/*****************************************************************************/
CHECK (DataLen <= 253);
/* Allocate memory */
- O = Xmalloc (sizeof (O65Option) - 1 + DataLen);
+ O = xmalloc (sizeof (O65Option) - 1 + DataLen);
/* Initialize the structure */
O->Next = 0;
static void FreeO65Option (O65Option* O)
/* Free an O65Option struct */
{
- Xfree (O);
+ xfree (O);
}
/*****************************************************************************/
-/* Subroutines to write o65 sections */
+/* Subroutines to write o65 sections */
/*****************************************************************************/
static unsigned O65WriteExpr (ExprNode* E, int Signed, unsigned Size,
- unsigned long Offs, void* Data)
+ unsigned long Offs, void* Data)
/* Called from SegWrite for an expression. Evaluate the expression, check the
* range and write the expression value to the file, update the relocation
* table.
* Calculate the number of bytes between this entry and the last one, and
* setup all necessary intermediate bytes in the relocation table.
*/
- Offs += D->SegSize; /* Calulate full offset */
+ Offs += D->SegSize; /* Calulate full offset */
Diff = ((long) Offs) - D->LastOffs;
while (Diff > 0xFE) {
- O65RelocPutByte (D->CurReloc, 0xFF);
- Diff -= 0xFE;
+ O65RelocPutByte (D->CurReloc, 0xFF);
+ Diff -= 0xFE;
}
- O65RelocPutByte (D->CurReloc, Diff);
+ O65RelocPutByte (D->CurReloc, (unsigned char) Diff);
/* Remember this offset for the next time */
D->LastOffs = Offs;
/* Determine the expression to relocate */
Expr = E;
- if (E->Op == EXPR_LOBYTE || E->Op == EXPR_HIBYTE) {
- /* Use the real expression */
+ if (E->Op == EXPR_BYTE0 || E->Op == EXPR_BYTE1 ||
+ E->Op == EXPR_BYTE2 || E->Op == EXPR_BYTE3 ||
+ E->Op == EXPR_WORD0 || E->Op == EXPR_WORD1) {
+ /* Use the real expression */
Expr = E->Left;
}
- /* Initialize the descriptor for expression parsing */
- ED.D = D;
- ED.Val = 0;
- ED.TooComplex = 0;
- ED.SegRef = 0;
- ED.ExtRef = 0;
-
/* Recursively collect information about this expression */
- O65ParseExpr (Expr, &ED, 1);
+ O65ParseExpr (Expr, InitExprDesc (&ED, D), 1);
/* We cannot handle both, an imported symbol and a segment ref */
if (ED.SegRef != 0 && ED.ExtRef != 0) {
- ED.TooComplex = 1;
+ ED.TooComplex = 1;
}
/* Bail out if we cannot handle the expression */
if (ED.TooComplex) {
- return SEG_EXPR_TOO_COMPLEX;
+ return SEG_EXPR_TOO_COMPLEX;
}
/* Safety: Check that we are really referencing a symbol or a segment */
/* Write out the offset that goes into the segment. */
BinVal = ED.Val;
- if (E->Op == EXPR_LOBYTE) {
- BinVal &= 0x00FF;
- } else if (E->Op == EXPR_HIBYTE) {
- BinVal = (BinVal >> 8) & 0x00FF;
+ switch (E->Op) {
+ case EXPR_BYTE0: BinVal &= 0xFF; break;
+ case EXPR_BYTE1: BinVal = (BinVal >> 8) & 0xFF; break;
+ case EXPR_BYTE2: BinVal = (BinVal >> 16) & 0xFF; break;
+ case EXPR_BYTE3: BinVal = (BinVal >> 24) & 0xFF; break;
+ case EXPR_WORD0: BinVal &= 0xFFFF; break;
+ case EXPR_WORD1: BinVal = (BinVal >> 16) & 0xFFFF; break;
}
WriteVal (D->F, BinVal, Size);
/* Determine the actual type of relocation entry needed from the
* information gathered about the expression.
*/
- if (E->Op == EXPR_LOBYTE) {
- RelocType = O65RELOC_LOW;
- } else if (E->Op == EXPR_HIBYTE) {
- RelocType = O65RELOC_HIGH;
+ if (E->Op == EXPR_BYTE0) {
+ RelocType = O65RELOC_LOW;
+ } else if (E->Op == EXPR_BYTE1) {
+ RelocType = O65RELOC_HIGH;
+ } else if (E->Op == EXPR_BYTE2) {
+ RelocType = O65RELOC_SEG;
} else {
- switch (Size) {
+ switch (Size) {
- case 1:
- RelocType = O65RELOC_LOW;
- break;
+ case 1:
+ RelocType = O65RELOC_LOW;
+ break;
- case 2:
- RelocType = O65RELOC_WORD;
- break;
+ case 2:
+ RelocType = O65RELOC_WORD;
+ break;
- case 3:
- RelocType = O65RELOC_SEGADR;
- break;
+ case 3:
+ RelocType = O65RELOC_SEGADR;
+ break;
- case 4:
- /* 4 byte expression not supported by o65 */
- return SEG_EXPR_TOO_COMPLEX;
+ case 4:
+ /* 4 byte expression not supported by o65 */
+ return SEG_EXPR_TOO_COMPLEX;
- default:
- Internal ("O65WriteExpr: Invalid expression size: %u", Size);
- RelocType = 0; /* Avoid gcc warnings */
- }
+ default:
+ Internal ("O65WriteExpr: Invalid expression size: %u", Size);
+ RelocType = 0; /* Avoid gcc warnings */
+ }
}
/* Determine which segment we're referencing */
if (ED.ExtRef) {
- /* Imported symbol */
- RelocType |= O65SEG_UNDEF;
+ /* Imported symbol */
+ RelocType |= O65SEG_UNDEF;
O65RelocPutByte (D->CurReloc, RelocType);
/* Put the number of the imported symbol into the table */
O65RelocPutWord (D->CurReloc, ExtSymNum (ED.ExtRef));
} else {
- /* Segment reference */
-
-
-
+ /* Segment reference. Search for the segment and map it to it's
+ * o65 segmentID
+ */
+ const SegDesc* Seg = O65FindSeg (D, ED.SegRef->Seg);
+ if (Seg == 0) {
+ /* For some reason, we didn't find this segment in the list of
+ * segments written to the o65 file.
+ */
+ return SEG_EXPR_INVALID;
+ }
+ RelocType |= O65SegType (Seg);
+ O65RelocPutByte (D->CurReloc, RelocType);
+
+ /* Output additional data if needed */
+ switch (RelocType & O65RELOC_MASK) {
+ case O65RELOC_HIGH:
+ O65RelocPutByte (D->CurReloc, ED.Val & 0xFF);
+ break;
+ case O65RELOC_SEG:
+ O65RelocPutWord (D->CurReloc, ED.Val & 0xFFFF);
+ break;
+ }
}
/* Success */
S = Seg [I];
/* Keep the user happy */
- if (Verbose) {
- printf (" Writing `%s'\n", S->Name);
- }
+ Print (stdout, 1, " Writing `%s'\n", S->Name);
/* Write this segment */
- if (DoWrite) {
+ if (DoWrite) {
+ RelocLineInfo (S->Seg);
SegWrite (D->F, S->Seg, O65WriteExpr, D);
- }
+ }
- /* Mark the segment as dumped */
- S->Seg->Dumped = 1;
+ /* Mark the segment as dumped */
+ S->Seg->Dumped = 1;
- /* Calculate the total size */
- D->SegSize += S->Seg->Size;
+ /* Calculate the total size */
+ D->SegSize += S->Seg->Size;
}
- /* Terminate the relocation table for the this segment */
+ /* Terminate the relocation table for this segment */
if (D->CurReloc) {
O65RelocPutByte (D->CurReloc, 0);
}
/* Check the size of the segment for overflow */
- if ((D->Header.Mode & MF_SIZE_32BIT) == 0 && D->SegSize > 0xFFFF) {
- Error ("Segment overflow in file `%s'", D->Filename);
+ if ((D->Header.Mode & MF_SIZE_MASK) == MF_SIZE_16BIT && D->SegSize > 0xFFFF) {
+ Error ("Segment overflow in file `%s'", D->Filename);
}
}
-static void O65WriteTextSeg (O65Desc* D, Memory* M)
+static void O65WriteTextSeg (O65Desc* D, Memory* M attribute ((unused)))
/* Write the code segment to the o65 output file */
{
/* Initialize variables */
-static void O65WriteDataSeg (O65Desc* D, Memory* M)
+static void O65WriteDataSeg (O65Desc* D, Memory* M attribute ((unused)))
/* Write the data segment to the o65 output file */
{
/* Initialize variables */
-static void O65WriteBssSeg (O65Desc* D, Memory* M)
+static void O65WriteBssSeg (O65Desc* D, Memory* M attribute ((unused)))
/* "Write" the bss segments to the o65 output file. This will only update
* the relevant header fields.
*/
-static void O65WriteZPSeg (O65Desc* D, Memory* M)
+static void O65WriteZPSeg (O65Desc* D, Memory* M attribute ((unused)))
/* "Write" the zeropage segments to the o65 output file. This will only update
* the relevant header fields.
*/
static void O65WriteImports (O65Desc* D)
/* Write the list of imported symbols to the O65 file */
{
- const ExtSym* E;
+ const ExtSym* S;
- /* Write the number of external symbols */
+ /* Write the number of imports */
WriteSize (D, ExtSymCount (D->Imports));
/* Write out the symbol names, zero terminated */
- E = ExtSymList (D->Imports);
- while (E) {
- /* Get the name */
- const char* Name = ExtSymName (E);
- /* And write it to the output file */
- WriteData (D->F, Name, strlen (Name) + 1);
- /* Next symbol */
- E = ExtSymNext (E);
+ S = ExtSymList (D->Imports);
+ while (S) {
+ /* Get the name */
+ const char* Name = ExtSymName (S);
+ /* And write it to the output file */
+ WriteData (D->F, Name, strlen (Name) + 1);
+ /* Next symbol */
+ S = ExtSymNext (S);
}
}
static void O65WriteExports (O65Desc* D)
/* Write the list of exports */
{
- /* For now... */
- WriteSize (D, 0);
+ const ExtSym* S;
+
+ /* Write the number of exports */
+ WriteSize (D, ExtSymCount (D->Exports));
+
+ /* Write out the symbol information */
+ S = ExtSymList (D->Exports);
+ while (S) {
+
+ ExprNode* Expr;
+ unsigned char SegmentID;
+ ExprDesc ED;
+
+ /* Get the name */
+ const char* Name = ExtSymName (S);
+
+ /* Get the export for this symbol. We've checked before that this
+ * export does really exist, so if it is unresolved, or if we don't
+ * find it, there is an error in the linker code.
+ */
+ Export* E = FindExport (Name);
+ if (E == 0 || IsUnresolvedExport (E)) {
+ Internal ("Unresolved export `%s' found in O65WriteExports", Name);
+ }
+
+ /* Get the expression for the symbol */
+ Expr = E->Expr;
+
+ /* Recursively collect information about this expression */
+ O65ParseExpr (Expr, InitExprDesc (&ED, D), 1);
+
+ /* We cannot handle expressions with imported symbols here */
+ if (ED.ExtRef != 0) {
+ ED.TooComplex = 1;
+ }
+
+ /* Bail out if we cannot handle the expression */
+ if (ED.TooComplex) {
+ Error ("Expression for symbol `%s' is too complex", Name);
+ }
+
+ /* Determine the segment id for the expression */
+ if (ED.SegRef == 0) {
+ /* Absolute value */
+ SegmentID = O65SEG_ABS;
+ } else {
+ /* Segment reference. Search for the segment and map it to it's
+ * o65 segmentID
+ */
+ const SegDesc* Seg = O65FindSeg (D, ED.SegRef->Seg);
+ if (Seg == 0) {
+ /* For some reason, we didn't find this segment in the list of
+ * segments written to the o65 file.
+ */
+ Error ("Segment for symbol `%s' is undefined", Name);
+ }
+ SegmentID = O65SegType (Seg);
+ }
+
+ /* Write the name to the output file */
+ WriteData (D->F, Name, strlen (Name) + 1);
+
+ /* Output the segment id followed by the literal value */
+ Write8 (D->F, SegmentID);
+ WriteSize (D, ED.Val);
+
+ /* Next symbol */
+ S = ExtSymNext (S);
+ }
}
/* Create, initialize and return a new O65 descriptor struct */
{
/* Allocate a new structure */
- O65Desc* D = Xmalloc (sizeof (O65Desc));
+ O65Desc* D = xmalloc (sizeof (O65Desc));
/* Initialize the header */
D->Header.Version = 0;
/* Delete the descriptor struct with cleanup */
{
/* Free the segment arrays */
- Xfree (D->ZPSeg);
- Xfree (D->BssSeg);
- Xfree (D->DataSeg);
- Xfree (D->TextSeg);
+ xfree (D->ZPSeg);
+ xfree (D->BssSeg);
+ xfree (D->DataSeg);
+ xfree (D->TextSeg);
/* Free the relocation tables */
FreeO65RelocTab (D->DataReloc);
FreeExtSymTab (D->Imports);
/* Free the struct itself */
- Xfree (D);
+ xfree (D);
+}
+
+
+
+void O65Set6502 (O65Desc* D)
+/* Enable 6502 mode */
+{
+ D->Header.Mode = (D->Header.Mode & ~MF_CPU_MASK) | MF_CPU_6502;
}
-void O65Set816 (O65Desc* D)
+void O65Set65816 (O65Desc* D)
/* Enable 816 mode */
{
- D->Header.Mode |= MF_CPU_816;
+ D->Header.Mode = (D->Header.Mode & ~MF_CPU_MASK) | MF_CPU_65816;
+}
+
+
+
+void O65SetSmallModel (O65Desc* D)
+/* Enable a small memory model executable */
+{
+ D->Header.Mode = (D->Header.Mode & ~MF_SIZE_MASK) | MF_SIZE_16BIT;
}
void O65SetLargeModel (O65Desc* D)
/* Enable a large memory model executable */
{
- D->Header.Mode |= MF_SIZE_32BIT;
+ D->Header.Mode = (D->Header.Mode & ~MF_SIZE_MASK) | MF_SIZE_32BIT;
}
/* Set the executable alignment */
{
/* Remove all alignment bits from the mode word */
- D->Header.Mode &= ~0x0003;
+ D->Header.Mode &= ~MF_ALIGN_MASK;
/* Set the alignment bits */
switch (Align) {
- case 1: break;
- case 2: D->Header.Mode |= 0x01; break;
- case 4: D->Header.Mode |= 0x02; break;
- case 256: D->Header.Mode |= 0x03; break;
+ case 1: D->Header.Mode |= MF_ALIGN_1; break;
+ case 2: D->Header.Mode |= MF_ALIGN_2; break;
+ case 4: D->Header.Mode |= MF_ALIGN_4; break;
+ case 256: D->Header.Mode |= MF_ALIGN_256; break;
default: Error ("Invalid alignment for O65 format: %u", Align);
}
}
void O65SetExport (O65Desc* D, const char* Ident)
/* Set an exported identifier */
{
+ /* Get the export for this symbol and check if it does exist and is
+ * a resolved symbol.
+ */
+ Export* E = FindExport (Ident);
+ if (E == 0 || IsUnresolvedExport (E)) {
+ Error ("Unresolved export: `%s'", Ident);
+ }
+
/* Insert the entry into the table */
NewExtSym (D->Exports, Ident);
}
D->BssCount = 0;
D->ZPCount = 0;
- /* Walk through the memory list and count the segment types */
+ /* Walk through the segment list and count the segment types */
N = M->SegList;
while (N) {
}
/* Allocate memory according to the numbers */
- D->TextSeg = Xmalloc (D->TextCount * sizeof (SegDesc*));
- D->DataSeg = Xmalloc (D->DataCount * sizeof (SegDesc*));
- D->BssSeg = Xmalloc (D->BssCount * sizeof (SegDesc*));
- D->ZPSeg = Xmalloc (D->ZPCount * sizeof (SegDesc*));
+ D->TextSeg = xmalloc (D->TextCount * sizeof (SegDesc*));
+ D->DataSeg = xmalloc (D->DataCount * sizeof (SegDesc*));
+ D->BssSeg = xmalloc (D->BssCount * sizeof (SegDesc*));
+ D->ZPSeg = xmalloc (D->ZPCount * sizeof (SegDesc*));
/* Walk again through the list and setup the segment arrays */
TextIdx = DataIdx = BssIdx = ZPIdx = 0;
}
/* Keep the user happy */
- if (Verbose) {
- printf ("Opened `%s'...\n", F->Name);
- }
+ Print (stdout, 1, "Opened `%s'...\n", F->Name);
/* Define some more options: A timestamp and the linker version */
T = time (0);
-
projects / cc65 / blobdiff