macross/object.c

626 lines
16 KiB
C
Raw Normal View History

2016-01-14 15:23:33 +00:00
/*
* Copyright (c) 1987 Fujitsu
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/*
object.c -- Routines to output object files for the Macross assembler.
Chip Morningstar -- Lucasfilm Ltd.
20-November-1984
*/
#include "macrossTypes.h"
#include "macrossGlobals.h"
2016-01-23 14:53:00 +00:00
#include <string.h>
static int symbolTableSize;
static int symbolTableStringSize;
bool encodingFunction;
extern void printCodeBuffers (void);
extern bool isExternal (symbolTableEntryType *symbol);
extern bool strcmplc (char *s1, char *s2);
bool hackableSymbol (symbolTableEntryType *symbol);
extern void printExpressionBuffer (void);
extern bool encodeRelocatableNumber (numberTermType number);
extern void freeExpression (expressionType *expression);
void
outputObjectFile(void)
{
void outputPartition(void);
void outputReferenceInfo(void);
void outputSymbolTableInfo(void);
void outputAbsoluteCode(void);
void outputRelocatableCode(void);
void outputReservations(void);
void outputExpressions(void);
void outputFunctions(void);
void dumpSymbolTable(void);
void enumerateAndCountSymbols(void);
if (debug || emitPrint)
printCodeBuffers();
outputPartition();
outputAbsoluteCode();
if (produceLinkableObject) {
outputPartition();
outputRelocatableCode();
outputPartition();
outputReservations();
outputPartition();
enumerateAndCountSymbols();
outputReferenceInfo();
outputSymbolTableInfo();
outputExpressions();
outputFunctions();
}
if (symbolTableDumpOn)
dumpSymbolTable();
fclose(objectFileOutput);
}
void
outputWord(int aWord)
{
putc(aWord & 0xFF, objectFileOutput);
putc((aWord >> 8) & 0xFF, objectFileOutput);
}
void
outputPartition(void)
{
outputWord(0xFFFF);
}
void
outputBigword(long unsigned int bigword)
{
int i;
for (i=1; i<=4; i++) {
putc(bigword & 0xFF, objectFileOutput);
bigword >>= 8;
}
}
void
outputByte(byte aByte)
{
putc(aByte, objectFileOutput);
}
void
outputString(stringType *string)
{
do {
putc(*string, objectFileOutput);
} while (*string++ != '\0');
}
void
outputStartAddress(addressType startAddress)
{
outputWord(startAddress);
if (produceLinkableObject) {
outputWord(startAddress - 3);
outputByte(0);
} else {
outputWord(startAddress);
outputByte(0);
}
}
void
outputRelocatableCode(void)
{
int i;
addressType codeStartAddress;
addressType codeEndAddress;
void outputPseudoSegment(addressType codeStartAddress, addressType codeEndAddress);
void outputBreak(codeBreakType *codeBreak);
if (haveUserStartAddress && !fixupStartAddress && startAddress->
kindOfValue == RELOCATABLE_VALUE)
outputStartAddress(startAddress->value);
else if (haveUserStartAddress && fixupStartAddress)
outputStartAddress(0xFFFE);
if (relocatableHighWaterMark < 0)
return;
codeEndAddress = -1;
do {
codeStartAddress = codeEndAddress + 1;
while (codeBreakList != NULL && codeBreakList->breakAddress
== codeStartAddress) {
outputBreak(codeBreakList);
codeBreakList = codeBreakList->nextBreak;
}
if (codeBreakList == NULL)
codeEndAddress = relocatableHighWaterMark;
else
codeEndAddress = codeBreakList->breakAddress - 1;
outputPseudoSegment(codeStartAddress, codeEndAddress);
} while (codeEndAddress < relocatableHighWaterMark);
}
void
outputBreak(codeBreakType *codeBreak)
{
switch (codeBreak->kindOfBreak) {
case BREAK_BREAK:
case END_CONSTRAIN_BREAK:
/* do nothing */
break;
case ALIGN_BREAK:
outputWord(codeBreak->breakAddress);
outputWord(codeBreak->breakAddress - 2);
outputWord(codeBreak->breakData);
break;
case CONSTRAIN_BREAK:
outputWord(codeBreak->breakAddress);
outputWord(codeBreak->breakAddress - 1);
outputWord(codeBreak->breakData);
break;
}
}
void
outputAbsoluteCode(void)
{
int i;
int startSegment;
int endSegment;
int nextSegment;
void outputOneCodeBuffer(codeSegmentType *segment);
if (haveUserStartAddress && !fixupStartAddress && startAddress->
kindOfValue==ABSOLUTE_VALUE)
outputStartAddress(startAddress->value);
for (startSegment=0; startSegment<CODE_BUFFERS_IN_ADDRESS_SPACE;
startSegment = endSegment + 1) {
endSegment = startSegment;
nextSegment = endSegment + 1;
while (nextSegment < CODE_BUFFERS_IN_ADDRESS_SPACE &&
absoluteCodeRegion.codeSegments[nextSegment]
!= NULL && absoluteCodeRegion.codeSegments[
endSegment] != NULL && absoluteCodeRegion.
codeSegments[endSegment]->codeEndAddress+1 ==
absoluteCodeRegion.codeSegments[nextSegment]
->codeStartAddress) {
++endSegment;
++nextSegment;
}
if (absoluteCodeRegion.codeSegments[startSegment] != NULL) {
outputWord(absoluteCodeRegion.codeSegments[
startSegment]->codeStartAddress);
outputWord(absoluteCodeRegion.codeSegments[
endSegment]->codeEndAddress);
for (i=startSegment; i<=endSegment; ++i)
outputOneCodeBuffer(absoluteCodeRegion.
codeSegments[i]);
}
}
}
void
outputOneCodeBuffer(codeSegmentType *segment)
{
int i;
if (segment != NULL) {
/* outputWord(segment->codeStartAddress);
outputWord(segment->codeEndAddress);*/
for (i=bufferPosition(segment->codeStartAddress); i<=
bufferPosition(segment->codeEndAddress); i++)
outputByte((*segment->codeBuffer)[i]);
}
}
void
outputPseudoSegment(addressType codeStartAddress, addressType codeEndAddress)
{
int startSegment;
int endSegment;
int startPosition;
int endPosition;
int originalStartPosition;
int ultimateEndPosition;
int position;
int segment;
codeSegmentType *segmentPtr;
void outputWord(int aWord);
void outputByte(byte aByte);
outputWord(codeStartAddress);
outputWord(codeEndAddress);
startSegment = bufferNumber(codeStartAddress);
endSegment = bufferNumber(codeEndAddress);
originalStartPosition = bufferPosition(codeStartAddress);
ultimateEndPosition = bufferPosition(codeEndAddress);
for (segment=startSegment; segment<=endSegment; segment++) {
segmentPtr = relocatableCodeRegion.codeSegments[segment];
startPosition = (segment == startSegment) ?
originalStartPosition : 0;
endPosition = (segment == endSegment) ? ultimateEndPosition :
CODE_BUFFER_SIZE - 1;
for(position=startPosition; position<=endPosition; position++)
outputByte((*segmentPtr->codeBuffer)[position]);
}
}
bool
isObjectSymbol(symbolTableEntryType *symbol)
{
return(symbol != NULL && symbol->context->value != NULL &&
symbol->context->value->kindOfValue != FUNCTION_VALUE &&
symbol->context->value->kindOfValue != BUILT_IN_FUNCTION_VALUE
&& symbol->context->value->kindOfValue != MACRO_VALUE &&
((isExternal(symbol) && symbol->context->value->kindOfValue
!= UNDEFINED_VALUE) || symbol->referenceCount > 0));
/* return(symbol != NULL && symbol->context->value != NULL &&
(symbol->context->value->kindOfValue == RELOCATABLE_VALUE ||
symbol->context->value->kindOfValue == ABSOLUTE_VALUE ||
isExternal(symbol)));*/
}
void
enumerateAndCountSymbols(void)
{
int i;
symbolTableEntryType *symb;
symbolTableSize = 0;
symbolTableStringSize = 0;
for (i=0; i<HASH_TABLE_SIZE; i++)
for (symb=symbolTable[i]; symb!=NULL; symb=symb->nextSymbol)
if (isObjectSymbol(symb)) {
symbolTableStringSize += strlen(symb->symbolName) + 1;
symb->ordinal = symbolTableSize++;
}
}
int
enumerateAndCountReferences(void)
{
int result;
int codeMode;
expressionReferenceListType *theReferences;
result = 0;
for (codeMode=0; codeMode<=1; codeMode++) {
theReferences = expressionReferenceList[codeMode];
while (theReferences != NULL) {
theReferences->relocation.referenceExpression = result++;
theReferences = theReferences->nextReference;
}
}
return(result);
}
void
outputReference(expressionReferenceType *reference)
{
byte funnyByte;
bigWord funnyWord;
/* This nonsense is to maintain byte-order and bit-order independence
across host machines so that Macross object files will be
portable. */
funnyByte = reference->referenceMode |
(reference->referenceRelative << 1) |
(reference->referenceExternal << 2) |
(reference->referenceKind << 3);
funnyWord = ((reference->referenceAddress) & 0xFFFFFF) |
(funnyByte << 24);
outputBigword(funnyWord);
outputBigword(reference->referenceExpression);
}
static int referenceCount;
void
outputReferenceInfo(void)
{
expressionReferenceListType *theReferences;
int codeMode;
outputBigword(referenceCount = enumerateAndCountReferences());
for (codeMode=0; codeMode<=1; codeMode++) {
theReferences = expressionReferenceList[codeMode];
while (theReferences != NULL) {
outputReference(&(theReferences->relocation));
theReferences = theReferences->nextReference;
}
}
}
void
outputOneSymbol(symbolTableEntryType *symbol)
{
byte symbolClass;
valueType *symbolValue;
valueType *evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
if (symbol->context->usage == DEFINE_SYMBOL)
symbolValue = evaluateIdentifier(symbol, FALSE, NO_FIXUP_OK);
else
symbolValue = symbol->context->value;
if (symbolValue->kindOfValue == ABSOLUTE_VALUE)
symbolClass = SYMBOL_ABSOLUTE;
else if (symbolValue->kindOfValue == RELOCATABLE_VALUE)
symbolClass = SYMBOL_RELOCATABLE;
else
symbolClass = SYMBOL_UNDEFINED;
if (isExternal(symbol))
symbolClass |= SYMBOL_EXTERNAL;
else if (symbolClass == SYMBOL_UNDEFINED)
symbolClass = SYMBOL_ABSOLUTE;
outputByte(symbolClass);
outputBigword(symbolValue->value);
outputString(symbol->symbolName);
}
void
outputSymbolTableInfo(void)
{
int i;
symbolTableEntryType *symb;
outputBigword(symbolTableSize);
outputBigword(symbolTableStringSize);
for (i=0; i<HASH_TABLE_SIZE; i++)
for (symb=symbolTable[i]; symb!=NULL; symb=symb->nextSymbol)
if (isObjectSymbol(symb))
outputOneSymbol(symb);
}
int
symbolCompare(symbolTableEntryType **symbol1, symbolTableEntryType **symbol2)
{
return(strcmplc((*symbol1)->symbolName, (*symbol2)->symbolName));
}
bool
shouldDumpSymbol(symbolTableEntryType *symbol)
{
return(symbolTableDumpOn == 2
|| (symbol->context->usage != BUILT_IN_FUNCTION_SYMBOL
&& (symbol->context->usage != DEFINE_SYMBOL
|| symbol->context->referenceCount != 0
|| showAllSymbolsFlag
)
&& symbol->symbolName[0] != '$'
&& symbol->symbolName[0] != '_'
)
);
}
void
dumpSymbolTable(void)
{
int i;
symbolTableEntryType *symb;
symbolTableEntryType **symbolVector;
int numberOfSymbols;
int symbolPtr;
valueType *value;
valueType *evaluateIdentifier(symbolTableEntryType *identifier, bool isTopLevel, fixupKindType kindOfFixup);
void printValueTersely(valueType *value);
numberOfSymbols = 0;
for (i=0; i<HASH_TABLE_SIZE; i++)
for (symb=symbolTable[i]; symb!=NULL; symb=symb->nextSymbol) {
if (symb->context != NULL && symb->context->value != NULL &&
(symb->context->value->kindOfValue !=
UNDEFINED_VALUE || symb->context->usage ==
LABEL_SYMBOL || symb->context->usage ==
EXTERNAL_SYMBOL || symb->context->usage ==
UNKNOWN_SYMBOL || symb->context->usage ==
NESTED_UNKNOWN_SYMBOL)) {
if (shouldDumpSymbol(symb)) {
numberOfSymbols++;
}
}
}
symbolVector = (symbolTableEntryType **)malloc(
sizeof(symbolTableEntryType *) * numberOfSymbols);
symbolPtr = 0;
for (i=0; i<HASH_TABLE_SIZE; i++)
for (symb=symbolTable[i]; symb!=NULL; symb=symb->nextSymbol) {
if (symb->context != NULL && symb->context->value != NULL &&
(symb->context->value->kindOfValue !=
UNDEFINED_VALUE || symb->context->usage ==
LABEL_SYMBOL || symb->context->usage ==
EXTERNAL_SYMBOL || symb->context->usage ==
UNKNOWN_SYMBOL || symb->context->usage ==
NESTED_UNKNOWN_SYMBOL)) {
if (shouldDumpSymbol(symb)) {
symbolVector[symbolPtr++] = symb;
}
}
}
qsort(symbolVector, numberOfSymbols, sizeof(symbolTableEntryType *),
symbolCompare);
for (symbolPtr=0; symbolPtr<numberOfSymbols; symbolPtr++) {
symb = symbolVector[symbolPtr];
if (hackFlag != 0) {
if (hackableSymbol(symb) && (isExternal(symb) ||
hackFlag == 1)) {
value = evaluateIdentifier(symb, TRUE,
NO_FIXUP_OK);
fprintf(symbolDumpFileOutput,
"define %s = 0x%x\n", symb->
symbolName, value->value);
}
} else if (symb->context->usage == FUNCTION_SYMBOL) {
fprintf(symbolDumpFileOutput, "%-20s = FUNCTION\n",
symb->symbolName);
} else if (symbolTableDumpOn == 2 || symb->context->usage !=
BUILT_IN_FUNCTION_SYMBOL) {
value = evaluateIdentifier(symb, TRUE, NO_FIXUP_OK);
fprintf(symbolDumpFileOutput, "%-20s = ", symb->
symbolName);
printValueTersely(value);
fprintf(symbolDumpFileOutput, " [%d]", symb->
context->referenceCount - 1);
if (isExternal(symb))
fprintf(symbolDumpFileOutput, " ext");
fprintf(symbolDumpFileOutput, "\n");
}
}
free(symbolVector);
}
bool
hackableSymbol(symbolTableEntryType *symbol)
{
return(symbol->context->usage == DEFINE_SYMBOL || symbol->context->
usage == LABEL_SYMBOL);
}
void
printValueTersely(valueType *value)
{
static char *valueKindTable[NUM_OF_VALUE_KINDS] = {
"ABS",
"DAT",
"REL",
"BSS",
"STT",
"FLD",
"MAC",
"OPN",
"STR",
"CND",
"UND",
"FUN",
"BLK",
"BIF",
"FAL",
};
if (value != NULL)
fprintf(symbolDumpFileOutput, "%s: %#6x %d", valueKindTable[
(int)value->kindOfValue], value->value, value->value);
else
fprintf(symbolDumpFileOutput, "(no value)");
}
void
outputReservations(void)
{
while (reservationList != NULL) {
outputWord(reservationList->startAddress);
outputWord(reservationList->blockSize);
reservationList = reservationList->nextReservation;
}
}
void
outputExpressionBuffer(void)
{
int i;
outputBigword(expressionBufferSize);
if (debug || emitPrint)
printExpressionBuffer();
for (i=0; i<expressionBufferSize; ++i)
outputByte(expressionBuffer[i]);
}
void
outputOneExpression(expressionType *expression)
{
expressionType *newExpression;
expressionType *generateFixupExpression(expressionType *expression);
bool encodeExpression(expressionType *expression);
expressionBufferSize = 0;
if (expression == NULL) {
encodeRelocatableNumber(0);
outputExpressionBuffer();
} else {
newExpression = generateFixupExpression(expression);
freeExpression(expression);
if (encodeExpression(newExpression))
outputExpressionBuffer();
}
}
void
outputExpressions(void)
{
int codeMode;
expressionReferenceListType *theReferences;
encodingFunction = FALSE;
outputBigword(referenceCount);
for (codeMode=0; codeMode<=1; codeMode++) {
theReferences = expressionReferenceList[codeMode];
while (theReferences != NULL) {
outputOneExpression(theReferences->expressionReferenced);
theReferences = theReferences->nextReference;
}
}
if (haveUserStartAddress && fixupStartAddress)
outputOneExpression(startAddress);
}
void
outputOneFunction(functionDefinitionType *function)
{
argumentDefinitionListType *argumentList;
bool encodeBlock(blockType *block);
int countArguments(functionDefinitionType *function);
outputByte((byte)countArguments(function));
argumentList = function->arguments;
while (argumentList != NULL) {
outputBigword(argumentList->theArgument->ordinal);
argumentList = argumentList->nextArgument;
}
expressionBufferSize = 0;
if (encodeBlock(function->body))
outputExpressionBuffer();
}
void
outputFunctions(void)
{
outputBigword(externalFunctionCount);
encodingFunction = TRUE;
while (externalFunctionCount-- > 0) {
outputOneFunction(externalFunctionList);
externalFunctionList = externalFunctionList->
nextExternalFunction;
}
}