NetBoot/vasm-1/cpus/test/cpu.c
2020-06-20 09:33:04 +08:00

307 lines
6.8 KiB
C

/* cpu.c example cpu-description file */
/* (c) in 2002 by Volker Barthelmann */
#include "vasm.h"
char *cpu_copyright="vasm test cpu backend (c) in 2002 Volker Barthelmann";
/* example machine.
valid Registers: R0-R3
valid extensions: .b/.w (default .w)
Instruction format:
XCCCCCCC 11112222 [32bit op1] [32bit op2]
X: set if byte-extension
C: instruction code
1/2: operand 1/2 type
0-3 register
4-7 register indirect (32bit offset follows)
8 absolute (32bit value follows)
9 immediate (32bit value follows)
Special case for addq: 1111: immediate 0-15
Special case for bra: 11112222: 0-255 relative offset
*/
char *cpuname="test";
int bitsperbyte=8;
int bytespertaddr=4;
mnemonic mnemonics[]={
"move",{OP_ALL,OP_REG},{CPU_ALL,0x0},
"move",{OP_REG,OP_ALL_DEST},{CPU_ALL,0x1},
"add",{OP_ALL,OP_REG},{CPU_ALL,0x2},
"add",{OP_REG,OP_ALL_DEST},{CPU_ALL,0x3},
"add",{OP_IMM32,OP_MEM},{CPU_ALL,0x4},
"addq",{OP_IMM32,OP_ALL_DEST},{CPU_ALL,0x5},
"jmp",{OP_ABS,0},{CPU_ALL,0x6},
"bra",{OP_ABS,0},{CPU_ALL,0x7},
};
int mnemonic_cnt=sizeof(mnemonics)/sizeof(mnemonics[0]);
char *parse_instruction(char *s,int *inst_len,char **ext,int *ext_len,
int *ext_cnt)
/* parse instruction and save extension locations */
{
char *inst = s;
while (*s && *s!='.' && !isspace((unsigned char)*s))
s++;
*inst_len = s - inst;
if (*s =='.') {
/* extension present */
ext[*ext_cnt] = ++s;
while (*s && *s!='.' && !isspace((unsigned char)*s))
s++;
ext_len[*ext_cnt] = s - ext[*ext_cnt];
*ext_cnt += 1;
}
return s;
}
int set_default_qualifiers(char **q,int *q_len)
/* fill in pointers to default qualifiers, return number of qualifiers */
{
q[0] = "w";
q_len[0] = 1;
return 1;
}
/* Does not do much useful parsing yet. */
int parse_operand(char *p,int len,operand *op,int requires)
{
p=skip(p);
if(len==2&&(p[0]=='r'||p[0]=='R')&&p[1]>='0'&&p[1]<='3'){
op->type=OP_REG;
op->basereg=p[1]-'0';
}else if(p[0]=='#'){
op->type=OP_IMM32;
p=skip(p+1);
op->offset=parse_expr(&p);
}else{
int parent=0;
expr *tree;
op->type=-1;
if(*p=='('){
parent=1;
p=skip(p+1);
}
tree=parse_expr(&p);
if(!tree)
return 0;
p=skip(p);
if(parent){
if(*p==','){
p=skip(p+1);
if((*p!='r'&&*p!='R')||p[1]<'0'||p[1]>'3'){
cpu_error(0);
return 0;
}
op->type=OP_REGIND;
op->basereg=p[1]-'0';
p=skip(p+2);
}
if(*p!=')'){
cpu_error(0);
return 0;
}else
p=skip(p+1);
}
if(op->type!=OP_REGIND)
op->type=OP_ABS;
op->offset=tree;
}
if(requires==op->type)
return 1;
if(requires==OP_ALL_DEST&&op->type!=OP_IMM32)
return 1;
if(requires==OP_MEM&&OP_ISMEM(op->type))
return 1;
if(requires==OP_ALL)
return 1;
return 0;
}
/* Return new instruction code, if instruction can be optimized
to another one. */
static int opt_inst(instruction *p,section *sec,taddr pc)
{
/* Ganz simples Beispiel. */
/* add->addq */
if((p->code==2||p->code==4)&&p->op[0]->type==OP_IMM32){
taddr val;
if(eval_expr(p->op[0]->offset,&val,sec,pc)&&val<16)
return 5;
}
/* jmp->bra */
if(p->code==6){
expr *tree=p->op[0]->offset;
if(tree->type==SYM&&tree->c.sym->sec==sec&&LOCREF(tree->c.sym)&&
tree->c.sym->pc-pc>=-128&&tree->c.sym->pc-pc<=127)
return 7;
}
return p->code;
}
static int operand_code(operand *p)
{
if(!p)
return 0;
if(p->type==OP_REG)
return p->basereg;
if(p->type==OP_REGIND)
return 4+p->basereg;
if(p->type==OP_ABS)
return 8;
if(p->type==OP_IMM32)
return 9;
ierror(0);
}
static char *fill_operand(operand *p,section *sec,taddr pc,char *d,rlist **relocs,int roffset)
{
taddr val;
if(!p||p->type==OP_REG)
return d;
/* FIXME: Test for valid operand, create reloc */
if(!eval_expr(p->offset,&val,sec,pc)){
symbol *base;
if (find_base(p->offset,&base,sec,pc)!=BASE_OK)
general_error(38);
else
add_nreloc(relocs,base,0,REL_ABS,16,roffset*8);
}
*d++=val>>24;
*d++=val>>16;
*d++=val>>8;
*d++=val;
return d;
}
/* Convert an instruction into a DATA atom including relocations,
if necessary. */
dblock *eval_instruction(instruction *p,section *sec,taddr pc)
{
/* Auch simpel. Fehlerchecks fehlen. */
size_t size=instruction_size(p,sec,pc);
dblock *db=new_dblock();
int c=opt_inst(p,sec,pc);
unsigned char *d;
taddr val;
db->size=size;
d=db->data=mymalloc(size);
*d=c;
if(p->qualifiers[0]){
if(c>5)
cpu_error(1,p->qualifiers[0]);
else if(!strcmp(p->qualifiers[0],"b"))
*d|=128;
else if(strcmp(p->qualifiers[0],"w"))
cpu_error(1,p->qualifiers[0]);
}
d++;
if(c==5){
/* addq */
taddr val;
if(!eval_expr(p->op[0]->offset,&val,sec,pc)||val>15)
cpu_error(0);
*d=((val<<4)|operand_code(p->op[1]));
return db;
}
if(c==7){
expr *tree=p->op[0]->offset;
if(!(tree->type==SYM&&tree->c.sym->sec==sec&&LOCREF(tree->c.sym)&&
tree->c.sym->pc-pc>=-128&&tree->c.sym->pc-pc<=127))
cpu_error(0);
else
*d=tree->c.sym->pc-pc;
return db;
}
*d=((operand_code(p->op[0])<<4)|operand_code(p->op[1]));
d++;
d=fill_operand(p->op[0],sec,pc,d,&db->relocs,d-db->data);
d=fill_operand(p->op[1],sec,pc,d,&db->relocs,d-db->data);
return db;
}
/* Create a dblock (with relocs, if necessary) for size bits of data. */
dblock *eval_data(operand *op,size_t bitsize,section *sec,taddr pc)
{
dblock *new=new_dblock();
taddr val;
new->size=(bitsize+7)/8;
new->data=mymalloc(new->size);
if(op->type!=OP_ABS)
ierror(0);
if(bitsize!=8&&bitsize!=16&&bitsize!=32)
cpu_error(2);
if(!eval_expr(op->offset,&val,sec,pc)&&bitsize!=32)
general_error(38);
if(bitsize==8){
new->data[0]=val;
}else if(bitsize==16){
new->data[0]=val>>8;
new->data[1]=val;
}else if(bitsize==32){
fill_operand(op,sec,pc,new->data,&new->relocs,0);
}
return new;
}
static taddr opsize(operand *p)
{
if(!p)
return 0;
if(p->type!=OP_REG)
return 4;
else
return 0;
}
/* Calculate the size of the current instruction; must be identical
to the data created by eval_instruction. */
size_t instruction_size(instruction *p,section *sec,taddr pc)
{
int c;
size_t size=2;
size+=opsize(p->op[0]);
size+=opsize(p->op[1]);
c=opt_inst(p,sec,pc);
if(c==5||c==7){
/* addq/bra */
size-=4;
}
return size;
}
operand *new_operand()
{
operand *new=mymalloc(sizeof(*new));
new->type=-1;
return new;
}
/* return true, if initialization was successfull */
int init_cpu()
{
return 1;
}
/* return true, if the passed argument is understood */
int cpu_args(char *p)
{
/* no args */
return 0;
}
/* parse cpu-specific directives; return pointer to end of
cpu-specific text */
char *parse_cpu_special(char *s)
{
/* no specials */
return s;
}