lab13.2_TinyLinker_小型链接器

TinyLinker

1143111006 刘家豪1.实验目的

完成Linker.c文件，实现小型连接器功能，编译文件

2.相关知识

目标模块

当编译器和汇编器处理完一个模块，它们产生的目标模块，几乎是可运行的。

负载模组

链接器的输出被称为负载模块，因为，相对地址搬迁和外部地址解析，该模块已准备好被加载并运行。

A重新定位相对地址

B在解析外部引用

3实验思路

使用的结构体：

A提取file中的word

B 读取下一行

C通过两次process，对符号表和定义表进行遍历并修改，再寄地址上加偏移量，进行重定位

Process_one()用来建立符号表

process_two()用来重定位代码表，并修改代码的地址，以及打印错误情况

替换外部符号：

替换相对地址：

输出当前代码段以及打印相关错误（如果存在）：

打印警告信息（如果有）：

4.实验结果

测试9个输入文件输出9个output文件都满足要求：

5.Linker（linker.c源码）

#include

#include

#include

#include "linker.h"

FILE *in; //for read module

FILE *out; //for output link result

struct symbolMsg{

char sym[30];

int addr;

int module;

int errorCode;

}symbolTable[100];

struct CodeStr{

char type;

int opcode;

int errorCode;

char* symbol;

};

int offset;

void link(int test_num, const char *filename)

{

char outputfile[100];

char file[5000];

memset(outputfile, 0, 10);

sprintf(outputfile, "output-%d.txt", test_num);

in = fopen(filename, "r"); //open file for read,the file contains module that you should do with

out = fopen(outputfile, "w"); //open the "output" file to output link result

if(in==NULL||out==NULL)

{

fprintf(stderr, "can not open file for read or write\n");

exit(-1);

}

memset(symbolTable,0,sizeof(struct symbolMsg)*100);

memset(file,0,sizeof(file));

fread(file,sizeof(char),sizeof(file),in);

// printf("%s",file);

// return;

process_one(file);

process_two(file);

fclose(in);

fclose(out);

}

/*提取file中的word*/

char * nextWord(char* src,char* word,int wordsize)

{

int i=0,j=0;

memset(word,0,wordsize);

while(src[i] == ' ')i++;

for(j=0;src[i+j] != ' '&& src[i+j] != '\0' && j

if (src[i+j] == '\n')

{

j++;

break;

}

word[j] = src[i+j];

}

return src+i+j;

}

char * nextLine(char* start)

{

int i=0;

while(start[i] != '\n')

i++;

return &start[i +1];

}

/*you must implement this function*/

void process_one(char* start)

{

char word[20];

int Index,k;

int module = 1;

char* errorMsg = NULL;

Index=0;

while(*start != '\0')

{

int num=0;

start = nextWord(start,word,sizeof(word));

num = atoi(word);

for(k=0;k

{

int i=0;

start = nextWord(start,word,sizeof(word));

for(i=0;i

if (i < Index)

{ // error: symbol is multiply defined, print an error message and use the value giveninthe first definition.

symbolTable[i].errorCode = 2;

continue;

}

strcpy(symbolTable[Index].sym,word);

start = nextWord(start,word,sizeof(word));

symbolTable[Index].addr = atoi(word);

symbolTable[Index++].module = module;

}

start = nextLine(start);

start = nextWord(start,word,sizeof(word));

num = atoi(word);

for(k=Index-1;symbolTable[k].module == module;k--)

{ // error: If an address appearing in a definition exceeds the size of the module, print an error message and treat the address given as 0(relative).

if (symbolTable[k].addr >= num)

{

symbolTable[k].errorCode = 1;

symbolTable[k].addr =0;

}

symbolTable[k].addr += offset;

}

offset += num;

start = nextLine(start);

start = nextLine(start);

module++; // next module

}

fwrite("Symbol Table\n",sizeof(char),strlen("Symbol Table\n"),out);

errorMsg = (char*)malloc(100);

for(k=0;k

{

memset(errorMsg,0,100);

if (1 == symbolTable[k].errorCode)

{

sprintf(errorMsg,"Error: The value of %s is outside module %d; zero (relative) used",symbolTable[k].sym,symbolTable[k].module);

}

else if(2 == symbolTable[k].errorCode)

{

sprintf(errorMsg,"Error: This variable is multiply defined; first value used.");

}

// output symbolTable & error msg

fprintf(out,"%s=%d %s\n",symbolTable[k].sym,symbolTable[k].addr,errorMsg);

}

free(errorMsg);

fwrite("\nMemory Map\n",sizeof(char),strlen("\nMemory Map\n"),out);

fflush(out);

}

/*you must implement this function*/

void process_two(char* start)

{

char word[20];

struct CodeStr* code;

char* useList; // 引用列表

char *errorMsg =NULL;

int i=0;

int memMapNumber =0;

int num=0,codeCount; // num of codes in a module

int curOffset;

offset = 0;

while(*start != '\0')

{

curOffset = offset;

//第一行定义列表(eg: 1 xy 2)

start = nextLine(start);

//第二行引用列表

useList = start;

start = nextLine(start);

//第三行代码段(num type opcode type opcode ...)

start = nextWord(start,word,sizeof(word));

codeCount = atoi(word);

offset += codeCount ;

code = (struct CodeStr*) malloc(sizeof(struct CodeStr)*codeCount);

for(i=0;i

{

start = nextWord(start,word,sizeof(word));

code[i].type = *word;

start = nextWord(start,word,sizeof(word));

code[i].opcode = atoi(word);

code[i].errorCode =0;

}

// 第四行空行

start = nextLine(start);

// 替换外部符号

useList = nextWord(useList,word,sizeof(word));

num = atoi(word);

for(i=0; i

{

int lineOffset;//外部符号在该行中的偏移量

useList = nextWord(useList,word,sizeof(word));// symbol

//从符号表查找相应符号以获得绝对地址

for(i=0;symbolTable[i].sym[0] !='\0' &&

strcmp(symbolTable[i].sym,word)!=0;i++);

if (symbolTable[i].sym[0] != '\0')

{

symbolTable[i].addr |= (1<<8);//标记该符号已使用

///////////////////////////

}

useList = nextWord(useList,word,sizeof(word));// offset

lineOffset = atoi(word);

//替换符号

while(lineOffset != 777)

{

int temp;

temp = code[lineOffset].opcode %1000;

code[lineOffset].opcode = (code[lineOffset].opcode/1000)*1000 + symbolTable[i].addr%(1<<8);

if (code[lineOffset].type != 'E')

{ // error: If an address on a use list is not type E,print an error message and treat the address as type E

code[lineOffset].errorCode =2;

}

else if (symbolTable[i].sym[0] == '\0')

{ // error: If a symbol is used but not defined, print an error message and use the value zero.

code[lineOffset].errorCode =1;

}

else if (temp >= num)

{ // error: If an ddress appearing in a use list exceeds the size of the module, print an error message and treat the address as the sentinel ending the list.

code[lineOffset].errorCode =4;

break;

}

else

code[lineOffset].errorCode = -1; // 标记该操作码出现在了使用链中code[lineOffset].symbol = symbolTable[i].sym;

lineOffset = temp;

}

}

//替换相对地址

for (i=0;i

{

if (0 ==code[i].errorCode && 'R' ==code[i].type) //替换相对地址

{

code[i].opcode += curOffset;

}

}

//检查是否有不在使用链中的e类型操作码将其视作立即数

for (i=0;i

{

if ('E' == code[i].type && 0 == code[i].errorCode)

{ // error: If a type E address is not on a use list, print an error message and treat the address as type I

code[i].errorCode = 3;

}

}

//输出当前代码段

errorMsg = (char *)malloc(100);

for(i=0;i

{

memset(errorMsg,0,100);

switch(code[i].errorCode)

{

case 1: //符号未定义

sprintf(errorMsg,"Error: %s is not defined; zero used.",code[i].symbol);

break;

case 2: //非e类型出现在使用链中

sprintf(errorMsg,"Error: %c type address on use chain; treated as E type.",code[i].type);

break;

case 3: //未出现在使用链中的e类型

strcpy(errorMsg,"Error: E type address not on use chain; treated as I type.");

break;

case 4: //符号偏移量超过模块大小

strcpy(errorMsg,"Error: Pointer in use chain exceeds module size; chain terminated.");

break;

}

fprintf(out,"%d:\t%d %s\n",memMapNumber++,code[i].opcode,errorMsg);

}

free(errorMsg);

free(code);

}

fprintf(out,"\n");

for(i=0; symbolTable[i].sym[0] != '\0';i++)

{ // If a symbol is defined but not used, print a warning message and continue if (0 == symbolTable[i].addr /(1<<8))

{

fprintf(out,"Warning: %s was defined in module %d but never

used.\n",symbolTable[i].sym,symbolTable[i].module);

}

}

}