linux下用lex/yacc实现的一个小汇编器,for 体系实习2,实习中唯一可以拿的出来的东西

上学期在编译实习课上在Window环境中用Lex/yacc完成了一个不大不小的Cm(C minus,呵呵,比C小多了)编译器, 而今天做体系实习2,要求设计一个新的指令系统,然后写汇编,再到二进制,再到simplescalar执行.汇编到二进制要是手工就很麻烦了.

由于汇编到二进制,基本上是直接翻译就可,所以可以使用awk来完成.但我花了一个通宵的时间(也不算,还做了别的事情),在Linux环境下使用GNU的lex(flex)和Yacc(bison),写了一个简单的汇编器,贴出来,让初学者看看,如果你是高手,就找找毛病啦,我的没有进行错误处理,默认输入是stdin,并且是正确的.

首先先看一个写好的简单汇编代码.


DATA SEG:


10


10


9


8


7


6


5


4


3


2


1


DATA END




CODE SEG:


addi $4, $0, 512 #当然也可以写成 addi $4, $0, 0x200


lw $3, $4, 0 #还可以写成 lw $3, 0($4)


add $2, $3, $0


addi $1, $4, 4


swi 2


addi $5, $0, 1


add $11, $3, $3


add $11, $11, $11


add $11, $11, $4


addi $11, $11, 4


addi $6, $4, 4






L4: slt $9, $6, $11


beq $9, $0, L1


lw $8, $6, 0 #$8=key


addi $7, $6, -4 #A+j = A+i -4


L3: slt $9, $4, $7


beq $9, $0, L2


lw $10, $7, 0


slt $9, $8, $10


beq $9, $0, L2 #$


sw $10, $7, 4 #


addi $7, $7, -4


beq $0, $0, L3


L2: sw $8, $7, 4


addi $6, $6, 4


beq $0, $0, L4


L1: swi 2 #swi 2为系统调用,显示内存中的一段数据,$1为基址,$2为长度


swi 1 #swi 1为系统调用,退出程序,是我们自定义的


CODE END





呵呵,是一个Insert Sort排序,对上面的十个数排序.

要生成二进制代码和二进制文件.我的Lex/Yacc的程序是在控制台里运行,标准输入输出.文件只需使用管道就好.

下面首先是lex文件:

%{
#include "myp.tab.h"
extern "C"{
int yywrap(void);
int yylex(void);
}
%}
%x cc //用来处理注释
%%
"0x" { return HEX; } //处理16进制
"CODE SEG" { return CODEBEG; }
"CODE END" { return CODEEND; }
"DATA SEG" { return DATABEG; }
"DATA END" { return DATAEND; }
"lw" { return LW; }
"sw" { return SW; }
"add" { return ADD; }
"addi" { return ADDI; }
"sub" { return SUB; }
"subi" { return SUBI; }
"mult" { return MULT; }
"multi" { return MULTI; }
"swi" { return SWI; }
"jmp" { return JMP; }
"slt" { return SLT; }
"beq" { return BEQ; }
"bne" { return BNE; }
"swp" { return SWP; }
[0-9]+ {
yylval.ival = atoi(yytext);
return NUMBER;
}
[a-zA-Z_][0-9a-zA-Z_]* {
strcpy(yylval.imm,yytext);
return ID;
}
"(" { return '('; }
")" { return ')'; }
":" { return ':'; }
"," { return ','; }
"$" { return '$'; }
"-" { return '-'; }
[ /t]|[/n] ;
"#" { BEGIN cc; }
<cc>(.)* { ; }
<cc>" " { BEGIN 0; }

%%
int yywrap(void)
{
return 1;
}

呵呵,下面是Yacc文件

%{
#include<iostream>
#include<string>
#include<fstream>
#include "src/func.h"
//#include "inc/func.cpp"
using namespace std;
extern "C"{
void yyerror(const char *s);
extern int yylex(void);
}
//extern int yylex();
//mylexer lexer;

char bin[MAX][33]; //用来记录生成的01字符串结果
int binNum = 0; //记录指令条数
int data[MAX]; //记录数据段数据
int dataNum = 0; //数据段数目
int curPC = 0; //当前处理的PC值
int dataInd = 0; //
char pindex[max][33]; //标签的名称
int indPo[max]; //用来记录标签对应的位置,这里是PC值,不过因为PC值和当前的指令位置有4倍关系
int indexNum = 0; //记录标签的数目
//条件转移时
char backId[max][33]; //需要回填的标签
int backPo[max]; //要回填的标签所在的指令位置
int backPC[max]; //要回填的标签所在的PC值
int backNum = 0; //要回填的标签数目

//非条件转移,因为只是为了简单的实现InsertSort函数,所以现在的指令系统中没有非条件转移指令
//不过设计时加上了

char jbackId[max][33]; //要回填的JMP标签
int jbackPo[max]; //要回填的JMP标签位置
int jbackNum = 0; //回填的JMP数目
%}

%union {
char imm[33];
char opName[6];
int ival;
}
%start PROGRAM
%token ADDI ADD SUB SUBI LW SWI SW MULT MULTI DATABEG DATAEND CODEBEG CODEEND BEQ BNE SLT JMP SWP HEX
%token<imm> ID
%type<opName> I_OP R_OP J_OP
%token<ival> NUMBER
%type<ival>IMM
%%

PROGRAM: {
// cout<<"world"<<endl;
}DATASEG CODESEG{
fillback();
//cout<<"fillback ok"<<endl;
int i;
for(i = 0;i< binNum;i++)
cout<<bin[i]<<endl;

}
;
DATASEG: DATABEG ':' DATA DATAEND{
int i = 0;
char temp[33];
for(i = 0;i < dataNum; i++){
int2bin32(data[i],temp);
strcpy(bin[i+2],temp);
}
binNum = dataNum + 2;
// printf("data ok ");
}
;
DATA: IMM {data[dataNum++] = $1;} DATA
|
;
CODESEG:CODEBEG ':' CODE CODEEND{
// cout<<"CODESEG OK"<<endl;
}
;
CODE: STATE CODE
|
;
STATE: ID {
strcpy(pindex[indexNum],$1);
indPo[indexNum++] = curPC;
} ':' COMMAND
{curPC += 4;binNum++;}
| COMMAND {curPC += 4;binNum++;}
;
COMMAND:I_COM
|R_COM
|J_COM
;
I_COM:I_OP '$' NUMBER ',' IMM '(' '$' NUMBER ')'
{
char temp[17];
strcat(bin[binNum],$1);
int2bin5($3,temp);
strcat(bin[binNum],temp);
int2bin5($8,temp);
strcat(bin[binNum],temp);
int2bin16($5,temp);
strcat(bin[binNum],temp);
}
|I_OP '$' NUMBER ',' '$' NUMBER ',' IMM
{
char temp[17];
strcat(bin[binNum], $1);
int2bin5($3,temp);
strcat(bin[binNum],temp);
int2bin5($6,temp);
strcat(bin[binNum],temp);
int2bin16($8, temp);
strcat(bin[binNum],temp);
}
| I_OP '$' NUMBER ',' '$' NUMBER ',' ID
{
char temp[17];

strcpy(bin[binNum],$1);
int2bin5($3,temp);
strcat(bin[binNum],temp);
int2bin5($6,temp);
strcat(bin[binNum],temp);
strcpy(backId[backNum],$8);
backPC[backNum] = curPC;
backPo[backNum++] = binNum;

}
| I_OP '$' NUMBER ',' '$' NUMBER
{
// cout<<"swp"<<endl;
char temp[17];
strcpy(bin[binNum],$1);
int2bin5($3,temp);
strcat(bin[binNum], temp);
int2bin5($6,temp);
strcat(bin[binNum],temp);
strcat(bin[binNum],"0000000000000000");
}
;
R_COM: R_OP '$' NUMBER ',' '$' NUMBER ',' '$' NUMBER
{
char temp[6];
strcpy(bin[binNum],$1);
int2bin5($3,temp);
strcat(bin[binNum],temp);
int2bin5($6,temp);
strcat(bin[binNum],temp);
int2bin5($9,temp);
strcat(bin[binNum],temp);
strcat(bin[binNum],"00000000000");
}
;
J_COM: J_OP ID{
strcpy(bin[binNum],$1);
strcpy(jbackId[jbackNum],$2);
jbackPo[jbackNum] = binNum;
}
| J_OP NUMBER{
strcpy(bin[binNum],$1);
char temp[27];
if(!int2bin26($2,temp))
cout<<"J_op Number:failed"<<endl;
strcat(bin[binNum],temp);
}
;
I_OP: ADDI { int2bin6(opAddi,$$);}
| SUBI { int2bin6(opSubi,$$);}
| MULTI { int2bin6(opMulti,$$);}
| LW { int2bin6(opLw,$$);}
| SW { int2bin6(opSw,$$);}
| BEQ { int2bin6(opBeq,$$);}
| BNE { int2bin6(opBne,$$);}
| SWP { int2bin6(opSwp,$$);}
;
R_OP: ADD { int2bin6(opAdd,$$);}
| SUB { int2bin6(opSub,$$);}
| MULT { int2bin6(opMult,$$);}
| SLT { int2bin6(opSlt,$$);}
;
J_OP: JMP { int2bin6(opJmp,$$);}
| SWI { int2bin6(opSwi,$$);}
;
IMM: NUMBER { $$ = $1;}
| HEX NUMBER { $$ = hex2dec($2); }
| '-' NUMBER { $$ = 0-$2;}
;
%%
void yyerror(const char*s)
{
extern int yylineno;
cout<<"error: "<<s<<": line"<<yylineno<<endl;
}
int main(int args,char *argv[])
{
/* parse parser;
if(args<=2)
cout<<"no file indicated"<<endl;
ifstream *fin = new ifstream(argv[1]);
if(!fin){
cout<<"Can't open file: "<<argv[1]<<endl;
return 1;
}
lexer.yyin = fin;
int n = 1;
if(parser.yycreate(&lexer)){
if(lexer.yycreate(&parser)){
n = parser.yyparser();
}
}
*/
// printf("hello ");
yyparse();
return 0;
}

然后是func.cpp和func.h文件,两个文件放在src子目录里面

func.h


#ifndef FUNC_H


#define FUNC_H


#define MAX 1000


#define max 100




#define opAdd 1


#define opAddi 2


#define opSlt 3


#define opBeq 4


#define opLw 5


#define opSw 6


#define opSwi 7


#define opSwp 8




#define opBne 0


#define opJmp 0


#define opSub 0


#define opSubi 0


#define opMult 0


#define opMulti 0








bool int2bin5(int a, char *b);


bool int2bin16(int a, char *b);


bool int2bin26(int a,char *b);


bool int2bin6(int a,char *b);


bool int2bin32(int a,char *b);


bool fillback();


int hex2dec(int a);


#endif



func.cpp


#include "func.h"
#include<iostream>
using namespace std;
#define MAX 1000
#define max 100
bool int2bin5(int a,char *b) //regNum 转化寄存器号成5位01字符串
{
int i = 0;
unsigned int base = 16;
for(i = 0;i< 5;i++){
b[i]=( a&base ?'1':'0');
base /=2;
}
b[i] = '/0';
return true;
}
bool int2bin6(int a,char *b) //opCode,操作码 占六位
{
int i = 0;
unsigned int base = 32;
for(i = 0;i< 6;i++){
b[i] = (a&base?'1':'0');
base/=2;
}
b[i] = '/0';
return true;
}
bool int2bin26(int a,char *b) //J型指令的立即数转换
{
int i = 0;
unsigned int base;
base = (1<<25);
if(a>0&&(a&base))
return false;
if(a<0&&!(a&base))
return false;
for(i = 0;i<26;i++){
b[i] = (a&base?'1':'0');
base >>=1;
}
b[i] = '/0';
return true;

}
bool int2bin16(int a,char *b) //I型指令的立即数转换
{
int i = 0;
unsigned int base = (1<<15);
if(a>0&&(a&base))
return false;
if(a<0&&!(a&base))
return false;
for(i = 0;i< 16;i++){
b[i] = (a&base?'1':'0');
base>>=1;
}
b[i] = '/0';
return false;
}
bool int2bin32(int a,char *b) //数据段的数据转换
{
// cout<<"int2bin32:"<<a<<endl;
int i = 0;
unsigned int base = (1<<31);
if(a>0&&(a&base))
return false;
if(a<0&&!(a&base))
return false;
for(i = 0;i< 32;i++){
b[i] = (a&base?'1':'0');
// cout<<base<<endl;
base>>=1;
}
b[i] = '/0';
//cout<<b<<endl;
return false;
}

bool fillback() //回填
{

extern char pindex[max][33],bin[MAX][33],
backId[max][33],jbackId[max][33];
extern int backPo[max], backNum,backPC[max];
extern int jbackPo[max],jbackNum;
extern int indPo[max],indexNum;
extern int dataNum,binNum;
//cout<<"fillback begins"<<endl;
int i = 0,j = 0, offset;
char temp[33];
//cout<<"back fill Num:"<<backNum<<" and indexNum is "<<indexNum<<endl;
for(i = 0;i < backNum;i++){
//cout<<"This time "<<backId[i]<<endl;
for(j = 0;j < indexNum;j++){
if(strcmp(backId[i],pindex[j])==0)
break;
}
if(j == indexNum){
cout<<backId[i]<<" not found"<<endl;
return false;
}
offset = (indPo[j]-backPC[i])/4;
int2bin16(offset,temp);
strcat(bin[backPo[i]],temp);
//cout<<i<<"hello"<<endl;
}

//cout<<"backfill ok"<<endl;

//非条件转移
for(i = 0;i< jbackNum;i++){
for(j = 0;j< indexNum;j++){
if(strcmp(jbackId[i],pindex[j])==0)
break;
}
if(j == indexNum){
cout<<jbackId[i]<<"not found"<<endl;
return false;
}
int2bin26(indPo[j],temp);
strcat(bin[jbackPo[i]],temp);
}
//完成程序开头的设置,第一个为指令数目,第二个是起始地址
// cout<<"jback ok"<<endl;
int2bin32(binNum -2,temp);
strcpy(bin[0],temp);
int2bin32(0x200 + dataNum*4,temp);
strcpy(bin[1],temp);
return true;
}
int hex2dec(int a) //16进制处理
{
int res = 0;
int base = 1;
while(a!=0){
res += (a%10)*base;
base *= 16;
a /= 10;
}
// cout<<res<<endl;
return res;
}

接着就是Makefile了

LEX=flex
YACC=bison
CPP=g++
CC=gcc
all:myasm
myasm:lex.yy.o myp.tab.o func.o
$(CPP) lex.yy.o myp.tab.o func.o -o myasm

func.o:src/func.cpp src/func.h
$(CPP) -c src/func.cpp -o func.o
lex.yy.o:lex.yy.c myp.tab.h
$(CPP) -c lex.yy.c

myp.tab.o:myp.tab.c
$(CPP) -c myp.tab.c

myp.tab.c myp.tab.h:myp.y
$(YACC) -d myp.y

lex.yy.c:myassm.l myp.tab.h
$(LEX) myassm.l
clean:
rm -f *.o *.c *.h
rm -f *.bin *.txt

嘿嘿,这就是整个代码,在debian 3.1r5,gcc g++版本为4.1.2,flex,bison 环境下运行很正常.