/**********************************************************************
* plink.c
* P-Code Linker
*
* Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
**********************************************************************/
/**********************************************************************
* Included Files
**********************************************************************/
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "keywords.h"
#include "pdefs.h"
#include "podefs.h"
#include "pedefs.h"
#include "paslib.h"
#include "perr.h"
#include "plsym.h"
#include "plreloc.h"
#include "pinsn.h"
#include "plink.h"
/**********************************************************************
* Definitions
**********************************************************************/
#define MAX_POFF_FILES 8
/**********************************************************************
* Private Type Definitions
**********************************************************************/
/**********************************************************************
* Private Constant Data
**********************************************************************/
/**********************************************************************
* Private Data
**********************************************************************/
static const char *outFileName;
static const char *inFileName[MAX_POFF_FILES];
static int nPoffFiles = 0;
/**********************************************************************
* Private Function Prototypes
**********************************************************************/
static void showUsage (const char *progname);
static void parseArgs (int argc, char **argv);
static void loadInputFiles (poffHandle_t outHandle);
static void checkFileHeader (poffHandle_t inHandle, poffHandle_t outHandle,
uint32_t pcOffset, bool *progFound);
static uint32_t mergeRoData (poffHandle_t inHandle, poffHandle_t outHandle);
static uint32_t mergeProgramData (poffHandle_t inHandle, poffHandle_t outHandle,
uint32_t pcOffset, uint32_t roOffset);
static uint32_t mergeFileNames (poffHandle_t inHandle, poffHandle_t outHandle);
static uint32_t mergeLineNumbers (poffHandle_t inHandle, poffHandle_t outHandle,
uint32_t pcOffset, uint32_t fnOffset);
static void writeOutputFile (poffHandle_t outHandle);
/**********************************************************************
* Global Variables
**********************************************************************/
/**********************************************************************
* Private Variables
**********************************************************************/
/**********************************************************************
* Public Functions
**********************************************************************/
int main(int argc, char *argv[], char *envp[])
{
poffHandle_t outHandle;
/* Parse the command line arguments */
parseArgs(argc, argv);
/* Create a handle to hold the output file data */
outHandle = poffCreateHandle();
if (outHandle == NULL) fatal(eNOMEMORY);
/* Load the POFF files specified on the command line */
loadInputFiles(outHandle);
/* Verify that all symbols were processed correctly */
verifySymbols();
/* Apply the relocation data to the program data */
applyRelocations(outHandle);
/* Write the symbol table information to the output file */
writeSymbols(outHandle);
/* Write the output file */
writeOutputFile(outHandle);
/* Release bufferred symbol/relocation informtion */
releaseSymbols();
releaseRelocations();
/* Release the input file data */
poffDestroyHandle(outHandle);
return 0;
} /* end main */
/**********************************************************************
* Private Functions
**********************************************************************/
static void showUsage(const char *progname)
{
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s <in-file-name> {<in-file-name>} <out-file-name>\n",
progname);
}
/***********************************************************************/
static void parseArgs(int argc, char **argv)
{
int i;
/* Check for existence of filename argument */
if (argc < 3)
{
fprintf(stderr,
"ERROR: <in-file-name> and one <out-file-name> required\n");
showUsage(argv[0]);
} /* end if */
/* Get the name of the p-code file(s) from the last argument(s) */
for (i = 1; i < argc-1; i++)
{
inFileName[nPoffFiles] = argv[i];
nPoffFiles++;
}
/* The last thing on the command line is the output file name */
outFileName = argv[argc-1];
}
/***********************************************************************/
/* This function loads each POFF file specified on the command line,
* merges the input POFF data, and generates intermediate structures
* to be used in the final link.
*/
static void loadInputFiles(poffHandle_t outHandle)
{
poffHandle_t inHandle;
FILE *instream;
char fileName[FNAME_SIZE+1]; /* Object file name */
uint32_t pcOffset = 0;
uint32_t fnOffset = 0;
uint32_t symOffset = 0;
uint32_t roOffset = 0;
uint32_t pcEnd = 0;
uint32_t fnEnd = 0;
uint32_t symEnd = 0;
uint16_t errCode;
bool progFound = false;
int i;
/* Load the POFF files specified on the command line */
for (i = 0; i < nPoffFiles; i++)
{
/* Create a handle to hold the input file data */
inHandle = poffCreateHandle();
if (inHandle == NULL) fatal(eNOMEMORY);
/* Use .o or command line extension, if supplied, to get the
* input file name.
*/
(void)extension(inFileName[i], "o", fileName, 0);
/* Open the input file */
instream = fopen(fileName, "rb");
if (instream == NULL)
{
fprintf(stderr, "ERROR: Could not open %s: %s\n",
fileName, strerror(errno));
exit(1);
}
/* Load the POFF file */
errCode = poffReadFile(inHandle, instream);
if (errCode != eNOERROR)
{
fprintf(stderr, "ERROR: Could not read %s (%d)\n",
fileName, errCode);
exit(1);
}
/* Check file header for critical settings */
checkFileHeader(inHandle, outHandle, pcOffset, &progFound);
/* Merge the read-only data sections */
roOffset = mergeRoData(inHandle, outHandle);
/* Merge program section data from the new input file into the
* output file container.
*/
pcEnd = mergeProgramData(inHandle, outHandle, pcOffset, roOffset);
/* Merge the file name data from the new input file into the
* output file container.
*/
fnEnd = mergeFileNames(inHandle, outHandle);
/* Merge the line number data from the new input file into the
* output file container.
*/
(void)mergeLineNumbers(inHandle, outHandle, pcOffset, fnOffset);
/* On this pass, we just want to collect all symbol table in a
* local list where we can resolve all undefined symbols (later)
*/
symEnd = mergeSymbols(inHandle, pcOffset, symOffset);
/* On this pass, we will also want to buffer all relocation data,
* adjusting only the program section offset and sym table
* offsets.
*/
mergeRelocations(inHandle, pcOffset, symOffset);
/* Release the input file data */
insn_ResetOpCodeRead(inHandle);
poffDestroyHandle(inHandle);
/* Close the input file */
fclose(instream);
/* Set the offsest to be used for the next file equal
* to the end values found from processing this file
*/
pcOffset = pcEnd;
fnOffset = fnEnd;
symOffset = symEnd;
}
/* Did we find exactly one program file? */
if (!progFound)
{
/* No! We have to have a program file to generate an executable */
fprintf(stderr, "ERROR: No program file found in input files\n");
exit(1);
}
} /* end loadInputFiles */
/***********************************************************************/
static void checkFileHeader(poffHandle_t inHandle, poffHandle_t outHandle,
uint32_t pcOffset, bool *progFound)
{
uint8_t fileType;
/* What kind of file are we processing? */
fileType = poffGetFileType(inHandle);
if (fileType == FHT_PROGRAM)
{
/* We can handle only one pascal program file */
if (*progFound)
{
fprintf(stderr,
"ERROR: Only one compiled pascal program file "
"may appear in input file list\n");
exit(1);
}
else
{
/* Get the entry point from the pascal file, apply any
* necessary offsets, and store the entry point in the
* linked output file's file header.
*/
poffSetEntryPoint(outHandle,
poffGetEntryPoint(inHandle) + pcOffset);
/* Copy the program name from the pascal file to the linked
* output file's file header and mark the output file as
* a pascal executable.
*/
poffSetFileType(outHandle, FHT_EXEC, 0,
poffGetFileHdrName(inHandle));
/* Indicate that we have found the program file */
*progFound = true;
}
}
else if (fileType != FHT_UNIT)
{
/* It is something other than a compiled pascal program or unit
* file.
*/
fprintf(stderr,
"ERROR: Only compiled pascal program and unit files "
"may appear in input file list\n");
exit(1);
}
}
/***********************************************************************/
static uint32_t mergeRoData(poffHandle_t inHandle, poffHandle_t outHandle)
{
uint8_t *newRoData;
uint32_t oldRoDataSize;
uint32_t newRoDataSize;
/* Get the size of the read-only data section before we add the
* new data. This is the offset that must be applied to any
* references to the new data.
*/
oldRoDataSize = poffGetRoDataSize(outHandle);
/* Remove the read-only data from new input file */
newRoDataSize = poffExtractRoData(inHandle, &newRoData);
/* And append the new read-only data to output file */
poffAppendRoData(outHandle, newRoData, newRoDataSize);
return oldRoDataSize;
}
/***********************************************************************/
/* This function merges the program data section of a new file into the
* program data section of the output file, relocating simple program
* section references as they are encountered.
*/
static uint32_t mergeProgramData(poffHandle_t inHandle,
poffHandle_t outHandle,
uint32_t pcOffset, uint32_t roOffset)
{
OPTYPE op;
uint32_t pc;
uint32_t opSize;
int endOp;
/* Read each opcode from the input file, add pcOffset to each program
* section address, and add each opcode to the output file.
*/
pc = pcOffset;
do
{
/* Read the next opcode (with its size) */
opSize = insn_GetOpCode(inHandle, &op);
/* Perform any necessary relocations */
endOp = insn_Relocate(&op, pcOffset, roOffset);
/* Save the potentially modified opcode in the temporary
* program data container.
*/
insn_AddOpCode(outHandle, &op);
pc += opSize;
}
while (endOp == 0);
return pc;
}
/***********************************************************************/
/* This function merges the file name section of a new file into the
* file name section of the output file, relocating simple program
* section references as they are encountered.
*/
static uint32_t mergeFileNames(poffHandle_t inHandle,
poffHandle_t outHandle)
{
int32_t inOffset;
uint32_t outOffset;
const char *fname;
do
{
/* Read each file name from the input File */
inOffset = poffGetFileName(inHandle, &fname);
if (inOffset >= 0)
{
/* And write it to the output file */
outOffset = poffAddFileName(outHandle, fname);
}
}
while (inOffset >= 0);
/* Return the offset to the last file name written to the
* output file
*/
return outOffset;
}
/***********************************************************************/
/* This function merges the line number section of a new file into the
* line number section of the output file, relocating simple program
* section references as they are encountered.
*/
static uint32_t mergeLineNumbers(poffHandle_t inHandle,
poffHandle_t outHandle,
uint32_t pcOffset,
uint32_t fnOffset)
{
poffLineNumber_t lineno;
int32_t inOffset;
uint32_t outOffset;
do
{
/* Read each line number from the input File */
inOffset = poffGetRawLineNumber(inHandle, &lineno);
if (inOffset >= 0)
{
/* And write it to the output file */
outOffset = poffAddLineNumber(outHandle, lineno.ln_lineno,
lineno.ln_fileno + fnOffset,
lineno.ln_poffset + pcOffset);
}
}
while (inOffset >= 0);
/* Return the offset to the last line number written to the
* output file
*/
return outOffset;
}
/***********************************************************************/
static void writeOutputFile(poffHandle_t outHandle)
{
FILE *outstream;
char fileName[FNAME_SIZE+1]; /* Output file name */
/* Use .pex or command line extension, if supplied, to get the
* input file name.
*/
(void)extension(outFileName, "pex", fileName, 0);
/* Open the output file */
outstream = fopen(fileName, "wb");
if (outstream == NULL)
{
fprintf(stderr, "ERROR: Could not open %s: %s\n",
fileName, strerror(errno));
exit(1);
}
/* Write the POFF file */
(void)poffWriteFile(outHandle, outstream);
/* Close the output file */
fclose(outstream);
}
/***********************************************************************/
