URL
https://opencores.org/ocsvn/raptor64/raptor64/trunk
Subversion Repositories raptor64
Compare Revisions
- This comparison shows the changes necessary to convert path
/
- from Rev 50 to Rev 51
- ↔ Reverse comparison
Rev 50 → Rev 51
/raptor64/trunk/software/c64/source/GenerateFunction.c
56,8 → 56,8
while( lc_auto & 7 ) /* round frame size to word */ |
++lc_auto; |
if (sym->IsInterrupt) { |
GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(30*8)); |
GenerateDiadic(op_sm,0,make_indirect(30), make_mask(0x9FFFFFFE)); |
//GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(30*8)); |
//GenerateDiadic(op_sm,0,make_indirect(30), make_mask(0x9FFFFFFE)); |
} |
if (!sym->IsNocall) { |
GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(24)); |
65,7 → 65,9
if (sym->IsLeaf) |
GenerateDiadic(op_sw,0,makereg(27),make_indirect(30)); |
else { |
GenerateDiadic(op_sm, 0, make_indirect(30), make_mask(0x98000000)); |
GenerateDiadic(op_sw, 0, makereg(27), make_indexed(0,30)); |
GenerateDiadic(op_sw, 0, makereg(28), make_indexed(8,30)); |
GenerateDiadic(op_sw, 0, makereg(31), make_indexed(16,30)); |
GenerateDiadic(op_lea,0,makereg(28),make_label(throwlab)); |
} |
GenerateDiadic(op_mov,0,makereg(27),makereg(30)); |
85,8 → 87,8
} |
} |
else { |
GenerateDiadic(op_lw,0,makereg(31),make_indexed(16,27)); // load throw return address from stack into LR |
GenerateDiadic(op_sw,0,makereg(31),make_indirect(27)); // and store it back (so it can be loaded with the lm) |
GenerateDiadic(op_lw,0,makereg(31),make_indexed(8,27)); // load throw return address from stack into LR |
GenerateDiadic(op_sw,0,makereg(31),make_indexed(16,27)); // and store it back (so it can be loaded with the lm) |
GenerateDiadic(op_bra,0,make_label(retlab),NULL); // goto regular return cleanup code |
} |
} |
99,6 → 101,7
AMODE *ap; |
int nn; |
int lab1; |
int cnt; |
|
if( stmt != NULL && stmt->exp != NULL ) |
{ |
124,13 → 127,14
return; |
// Restore registers used as register variables. |
if( save_mask != 0 ) { |
if (bitsset(save_mask) < 2) { |
for (nn = 31; nn >=1 ; nn--) |
if (save_mask & (1 << nn)) |
GenerateTriadic(op_lw,0,makereg(nn),make_indirect(30),NULL); |
cnt = (bitsset(save_mask)-1)*8; |
for (nn = 31; nn >=1 ; nn--) { |
if (save_mask & (1 << nn)) { |
GenerateTriadic(op_lw,0,makereg(nn),make_indexed(cnt,30),NULL); |
cnt -= 8; |
} |
} |
else |
GenerateTriadic(op_lm,0,make_indirect(30),make_mask(save_mask),NULL); |
GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(popcnt(save_mask)*8)); |
} |
// Unlink the stack |
// For a leaf routine the link register and exception link register doesn't need to be saved/restored. |
137,8 → 141,11
GenerateDiadic(op_mov,0,makereg(30),makereg(27)); |
if (sym->IsLeaf) |
GenerateDiadic(op_lw,0,makereg(27),make_indirect(30)); |
else |
GenerateDiadic(op_lm,0,make_indirect(30),make_mask(0x98000000)); |
else { |
GenerateDiadic(op_lw,0,makereg(27),make_indirect(30)); |
GenerateDiadic(op_lw,0,makereg(28),make_indexed(8,30)); |
GenerateDiadic(op_lw,0,makereg(31),make_indexed(16,30)); |
} |
//if (isOscall) { |
// GenerateDiadic(op_move,0,makereg(0),make_string("_TCBregsave")); |
// gen_regrestore(); |
146,10 → 153,10
// Generate the return instruction. For the Pascal calling convention pop the parameters |
// from the stack. |
if (sym->IsInterrupt) { |
GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(24)); |
GenerateDiadic(op_lm,0,make_indirect(30),make_mask(0x9FFFFFFE)); |
GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(popcnt(0x9FFFFFFE)*8)); |
GenerateDiadic(op_iret,0,NULL,NULL); |
//GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(24)); |
//GenerateDiadic(op_lm,0,make_indirect(30),make_mask(0x9FFFFFFE)); |
//GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(popcnt(0x9FFFFFFE)*8)); |
GenerateMonadic(op_iret,0,NULL); |
return; |
} |
if (sym->IsPascal) |
232,10 → 239,10
if (sym->tp->btp->type==bt_void) |
; |
else |
GenerateTriadic(op_or,0,result,makereg(1),makereg(0)); |
GenerateDiadic(op_mov,0,result,makereg(1)); |
} |
else |
GenerateTriadic(op_or,0,result,makereg(1),makereg(0)); |
GenerateDiadic(op_mov,0,result,makereg(1)); |
return result; |
} |
|
/raptor64/trunk/software/c64/source/ParseExpressions.c
214,6 → 214,7
{ |
SYM *sp; |
TYP *tp; |
char stnm[200]; |
sp = gsearch(lastid); |
if( sp == NULL ) { |
while( isspace(lastch) ) |
242,8 → 243,19
} |
switch( sp->storage_class ) { |
case sc_static: |
*node = makeinode(en_labcon,sp->value.i); |
(*node)->constflag = TRUE; |
if (sp->tp->type==bt_func || sp->tp->type==bt_ifunc) { |
strcpy(stnm,GetNamespace()); |
strcat(stnm,"_"); |
strcat(stnm,sp->name); |
*node = makesnode(en_nacon,litlate(stnm)); |
(*node)->constflag = TRUE; |
//*node = makesnode(en_nacon,sp->name); |
//(*node)->constflag = TRUE; |
} |
else { |
*node = makeinode(en_labcon,sp->value.i); |
(*node)->constflag = TRUE; |
} |
break; |
case sc_global: |
case sc_external: |
327,9 → 339,15
*/ |
TYP *ParsePrimaryExpression(ENODE **node) |
{ |
ENODE *pnode, *qnode, *rnode, *snode; |
ENODE *pnode, *qnode, *rnode, *snode, *rnode1, *pnode1, *qnode1, *qnode2; |
__int64 i ; |
int sza[10]; |
int brcount; |
SYM *sp; |
TYP *tptr; |
brcount = 0; |
qnode1 = NULL; |
qnode2 = NULL; |
switch( lastst ) { |
|
case id: |
343,7 → 361,7
break; |
case sconst: |
tptr = &stdstring; |
pnode = makenode(en_labcon,stringlit(laststr),NULL); |
pnode = makenodei(en_labcon,NULL,stringlit(laststr)); |
pnode->constflag = TRUE; |
NextToken(); |
break; |
372,6 → 390,7
for(;;) { |
switch( lastst ) { |
case openbr: /* build a subscript reference */ |
brcount++; |
if (tptr==NULL) { |
error(ERR_UNDEFINED); |
goto fini; |
381,16 → 400,43
else |
tptr = tptr->btp; |
NextToken(); |
qnode = makeinode(en_icon,tptr->size); |
qnode->constflag = TRUE; |
expression(&rnode); |
/* |
if (tptr->val_flag && (tptr->size==1 || tptr->size==2 || tptr->size==4 || tptr->size==8)) { |
expression(&rnode); |
pnode = makenode(en_add,rnode,pnode); |
pnode->constflag = rnode->constflag && pnode->p[1]->constflag; |
pnode->scale = tptr->size; |
} |
else { |
sza[brcount-1] = tptr->size; |
qnode = makeinode(en_icon,tptr->size); |
// swap sizes for array indexing |
if (brcount==3) { |
qnode->i = sza[0]; |
qnode2->i = sza[1]; |
qnode1->i = sza[2]; |
} |
else if (brcount==2) { |
qnode->i = sza[0]; |
qnode1->i = sza[1]; |
} |
if (qnode1==NULL) |
qnode1 = qnode; |
else |
qnode2 = qnode; |
qnode->constflag = TRUE; |
expression(&rnode); |
needpunc(closebr); |
/* |
* we could check the type of the expression here... |
*/ |
qnode = makenode(en_mulu,qnode,rnode); |
qnode->constflag = rnode->constflag && qnode->p[0]->constflag; |
pnode = makenode(en_add,qnode,pnode); |
pnode->constflag = qnode->constflag && pnode->p[1]->constflag; |
qnode = makenode(en_mulu,qnode,rnode); |
qnode->constflag = rnode->constflag && qnode->p[0]->constflag; |
pnode = makenode(en_add,qnode,pnode); |
pnode->constflag = qnode->constflag && pnode->p[1]->constflag; |
pnode->scale = 1; |
//if( tptr->val_flag == 0 ) |
// tptr = deref(&pnode,tptr); |
} |
////snode = makenode(en_mul,qnode,rnode); |
////snode->constflag = rnode->constflag && snode->p[0]->constflag; |
////pnode = makenode(en_add,snode,pnode); |
397,7 → 443,7
////pnode->constflag = snode->constflag && pnode->p[1]->constflag; |
if( tptr->val_flag == FALSE ) |
tptr = deref(&pnode,tptr); |
needpunc(closebr); |
// needpunc(closebr); |
break; |
|
case pointsto: |
655,15 → 701,29
else |
i = 1; |
if( lastst == autoinc) { |
if( IsLValue(ep1) ) |
ep1 = makenodei(en_ainc,ep1,i); |
if( IsLValue(ep1) ) { |
if (tp->type == bt_pointer) |
ep2 = makeinode(en_icon,tp->btp->size); |
else |
ep2 = makeinode(en_icon,1); |
ep2->constflag = TRUE; |
ep1 = makenode(en_asadd,ep1,ep2); |
// ep1 = makenodei(en_ainc,ep1,i); |
} |
else |
error(ERR_LVALUE); |
NextToken(); |
} |
else if( lastst == autodec ) { |
if( IsLValue(ep1) ) |
ep1 = makenodei(en_adec,ep1,i); |
if( IsLValue(ep1) ) { |
if (tp->type == bt_pointer) |
ep2 = makeinode(en_icon,tp->btp->size); |
else |
ep2 = makeinode(en_icon,1); |
ep2->constflag = TRUE; |
ep1 = makenode(en_assub,ep1,ep2); |
// ep1 = makenodei(en_adec,ep1,i); |
} |
else |
error(ERR_LVALUE); |
NextToken(); |
/raptor64/trunk/software/c64/source/Gen.h
21,6 → 21,7
unsigned int tempflag : 1; |
int deep; /* stack depth on allocation */ |
struct enode *offset; |
__int8 scale; |
} AMODE; |
|
/* output code structure */ |
41,7 → 42,7
op_tas, op_bmi, op_subu, op_lwr, op_swc, op_loop, op_iret, |
op_sext32,op_sext16,op_sext8, op_dw, op_cache, |
op_subui, op_addui, op_sei, |
op_sw, op_sh, op_sc, op_sb, |
op_sw, op_sh, op_sc, op_sb, op_outb, op_inb, op_inbu, |
op_call, op_jal, op_beqi, op_bnei, |
op_lw, op_lh, op_lc, op_lb, op_ret, op_sm, op_lm, |
op_rts, op_bra, op_bf, op_beq, op_bne, op_blt, op_ble, op_bgt, op_bge, |
/raptor64/trunk/software/c64/source/GenerateStatement.c
526,49 → 526,99
{ |
int lab1, lab2, lab3, lab4; |
AMODE *ap1, *ap2; |
AMODE *ap; |
|
lab1 = nextlabel++; |
ap1 = GetTempRegister(); |
ap2 = GetTempRegister(); |
if (stmt->exp) { |
lab2 = nextlabel++; |
GenerateTriadic(op_ori,0,ap2,makereg(0),make_immed(stmt->exp)); |
GenerateLabel(lab1); |
GenerateTriadic(op_beq,0,ap2,makereg(0),make_label(lab2)); |
GenerateTriadic(op_subui,0,ap2,ap2,make_immed(1)); |
GenerateTriadic(op_lwr,0,ap1,make_string(stmt->label),NULL); |
GenerateTriadic(op_bne,0,ap1,makereg(0),make_label(lab1),NULL); |
GenerateTriadic(op_not,0,ap1,ap1,NULL); |
GenerateTriadic(op_swc,0,ap1,make_string(stmt->label),NULL); |
GenerateTriadic(op_bnr,0,make_label(lab1),NULL,NULL); |
} |
else { |
lab2 = nextlabel++; |
lab3 = nextlabel++; |
|
if( stmt != NULL && stmt->exp != NULL ) |
{ |
initstack(); |
ap1 = GetTempRegister(); |
ap2 = GetTempRegister(); |
ap = GenerateExpression(stmt->exp,F_REG,8); |
if (stmt->initExpr) |
GenerateTriadic(op_ori, 0, ap1,makereg(0),make_immed(stmt->initExpr)); |
GenerateLabel(lab1); |
GenerateTriadic(op_lwr,0,ap1,make_string(stmt->label),NULL); |
GenerateTriadic(op_bne,0,ap1,makereg(0),make_label(lab1),NULL); |
GenerateTriadic(op_not,0,ap1,ap1,NULL); |
GenerateTriadic(op_swc,0,ap1,make_string(stmt->label),NULL); |
GenerateTriadic(op_bnr,0,make_label(lab1),NULL,NULL); |
if (stmt->initExpr) { |
GenerateTriadic(op_sub, 0, ap1, ap1, make_immed(1)); |
GenerateTriadic(op_beq, 0, ap1, makereg(0), make_label(lab2)); |
} |
GenerateDiadic(op_inbu, 0, ap2, make_indexed(stmt->incrExpr,ap->preg)); |
GenerateTriadic(op_beq, 0, ap2, makereg(0), make_label(lab1)); |
ReleaseTempRegister(ap2); |
GenerateStatement(stmt->s1); |
// unlock |
GenerateDiadic(op_outb, 0, makereg(0), make_indexed(stmt->incrExpr,ap->preg)); |
if (stmt->initExpr) { |
GenerateTriadic(op_bra,0,make_label(lab3),NULL,NULL); |
GenerateLabel(lab2); |
GenerateStatement(stmt->s2); |
GenerateLabel(lab3); |
} |
else { |
printf("Warning: The lockfail code is unreachable because spinlock tries are infinite.\r\n"); |
} |
} |
ReleaseTempRegister(ap1); |
ReleaseTempRegister(ap2); |
GenerateStatement(stmt->s1); |
GenerateDiadic(op_sb,0,makereg(0),make_string(stmt->label)); |
if (stmt->exp) { |
lab3 = nextlabel++; |
GenerateTriadic(op_bra,0,make_label(lab3),NULL,NULL); |
GenerateLabel(lab2); |
GenerateStatement(stmt->s2); |
GenerateLabel(lab3); |
} |
else { |
printf("Warning: The lockfail code is unreachable because spinlock tries are infinite.\r\n"); |
} |
|
//ap1 = GetTempRegister(); |
//ap2 = GetTempRegister(); |
//if (stmt->exp) { |
// lab2 = nextlabel++; |
// GenerateTriadic(op_ori,0,ap2,makereg(0),make_immed(stmt->exp)); |
// GenerateLabel(lab1); |
// GenerateTriadic(op_beq,0,ap2,makereg(0),make_label(lab2)); |
// GenerateTriadic(op_subui,0,ap2,ap2,make_immed(1)); |
// GenerateTriadic(op_lwr,0,ap1,make_string(stmt->label),NULL); |
// GenerateTriadic(op_bne,0,ap1,makereg(0),make_label(lab1),NULL); |
// GenerateTriadic(op_not,0,ap1,ap1,NULL); |
// GenerateTriadic(op_swc,0,ap1,make_string(stmt->label),NULL); |
// GenerateTriadic(op_bnr,0,make_label(lab1),NULL,NULL); |
//} |
//else { |
// GenerateLabel(lab1); |
// GenerateTriadic(op_lwr,0,ap1,make_string(stmt->label),NULL); |
// GenerateTriadic(op_bne,0,ap1,makereg(0),make_label(lab1),NULL); |
// GenerateTriadic(op_not,0,ap1,ap1,NULL); |
// GenerateTriadic(op_swc,0,ap1,make_string(stmt->label),NULL); |
// GenerateTriadic(op_bnr,0,make_label(lab1),NULL,NULL); |
//} |
//ReleaseTempRegister(ap1); |
//ReleaseTempRegister(ap2); |
//GenerateStatement(stmt->s1); |
//GenerateDiadic(op_sb,0,makereg(0),make_string(stmt->label)); |
//if (stmt->exp) { |
// lab3 = nextlabel++; |
// GenerateTriadic(op_bra,0,make_label(lab3),NULL,NULL); |
// GenerateLabel(lab2); |
// GenerateStatement(stmt->s2); |
// GenerateLabel(lab3); |
//} |
//else { |
// printf("Warning: The lockfail code is unreachable because spinlock tries are infinite.\r\n"); |
//} |
} |
|
void GenerateSpinUnlock(struct snode *stmt) |
{ |
GenerateDiadic(op_sb,0,makereg(0),make_string(stmt->label)); |
AMODE *ap; |
|
if( stmt != NULL && stmt->exp != NULL ) |
{ |
initstack(); |
ap = GenerateExpression(stmt->exp,F_REG|F_IMMED,8); |
// Force return value into register 1 |
if( ap->preg != 1 ) { |
if (ap->mode == am_immed) |
GenerateTriadic(op_ori, 0, makereg(1),makereg(0),ap); |
else |
GenerateDiadic(op_mov, 0, makereg(1),ap); |
GenerateDiadic(op_outb, 0, makereg(0),make_indexed(stmt->incrExpr,1)); |
} |
} |
|
// GenerateDiadic(op_sb,0,makereg(0),make_string(stmt->label)); |
} |
/* |
* genstmt will generate a statement and follow the next pointer |
/raptor64/trunk/software/c64/source/Expr.h
46,6 → 46,7
__int8 constflag; |
__int8 bit_width; |
__int8 bit_offset; |
__int8 scale; |
// The following could be in a value union |
__int64 i; |
double f; |
/raptor64/trunk/software/c64/source/Preprocessor.c
31,7 → 31,7
*******************************************************/ |
|
FILE *inclfile[10]; |
int incldepth = 0; |
//int incldepth = 0; |
int inclline[10]; |
char *lptr; |
extern char inpline[132]; |
82,6 → 82,7
rv = getline(incldepth == 0); |
} |
else { |
_splitpath(laststr,NULL,NULL,nmspace[incldepth],NULL); |
rv = getline(incldepth == 1); |
lineno = -32768; /* dont list include files */ |
} |
/raptor64/trunk/software/c64/source/C.h
140,6 → 140,8
#define ERR_ASMTOOLONG 32 |
#define ERR_TOOMANYCASECONSTANTS 33 |
#define ERR_CATCHSTRUCT 34 |
#define ERR_SEMA_INCR 35 |
#define ERR_SEMA_ADDR 36 |
|
/* alignment sizes */ |
|
/raptor64/trunk/software/c64/source/err.c
33,6 → 33,7
"Floating point", |
"Illegal type", |
"Undefined symbol", |
"Duplicate symbol", |
"Bad punctuation", |
"Identifier expected", |
"No initializer", |
60,7 → 61,9
"Expression too complex", |
"Asm statement too long - break into multiple statements", |
"Too many case constants", |
"Attempting to catch a structure - aggregates may not be caught - use a pointer to struct" |
"Attempting to catch a structure - aggregates may not be caught - use a pointer to struct", |
"Semaphore increment / decrement limited to 1 to 15." |
"Semaphore address must be 16 byte aligned." |
}; |
|
char *errtext(int errnum) |
/raptor64/trunk/software/c64/source/Intexpr.c
28,9 → 28,9
robfinch@opencores.org |
*******************************************************/ |
|
int GetIntegerExpression() /* simple integer value */ |
__int64 GetIntegerExpression() /* simple integer value */ |
{ |
int temp; |
__int64 temp; |
SYM *sp; |
|
if(lastst == id) { |
/raptor64/trunk/software/c64/source/Outcode.c
35,7 → 35,7
/* variable initialization */ |
|
enum e_gt { nogen, bytegen, chargen, halfgen, wordgen, longgen }; |
enum e_sg { noseg, codeseg, dataseg }; |
//enum e_sg { noseg, codeseg, dataseg, bssseg, idataseg }; |
|
int gentype = nogen; |
int curseg = noseg; |
45,8 → 45,8
char *s; |
int ov; |
} opl[] = |
{ {"move",op_move}, {"add",op_add}, {"addu", op_addu}, {"mov", op_mov}, |
{"add",op_addi}, {"sub",op_sub}, {"subu", op_subu}, |
{ {"move",op_move}, {"addu",op_add}, {"addu", op_addu}, {"mov", op_mov}, |
{"add",op_addi}, {"subu",op_sub}, {"subu", op_subu}, |
{"subi",op_subi}, {"and",op_and}, |
{"sext8",op_sext8}, {"sext16", op_sext16}, {"sext32", op_sext32}, |
{"subui",op_subui}, {"shru", op_shru}, {"divsi", op_divsi}, {"not", op_not}, |
72,7 → 72,7
{"bra",op_bra}, {"pea",op_pea}, |
{"cmp",op_cmpi}, {"tst",op_tst}, |
{"stop", op_stop}, |
{"bmi", op_bmi}, |
{"bmi", op_bmi}, {"outb", op_outb}, {"inb", op_inb}, {"inbu", op_inbu}, |
{"dc",op_dc}, |
{"",op_empty}, {"",op_asm}, |
{0,0} }; |
189,16 → 189,22
fprintf(output,"******[a%d]",ap->preg); |
break; |
case am_indx: |
PutConstant(ap->offset); |
if (ap->offset->i != 0) |
PutConstant(ap->offset); |
fprintf(output,"[%s]",RegMoniker(ap->preg)); |
break; |
case am_indx2: |
PutConstant(ap->offset); |
fprintf(output,"[%s+%s]",RegMoniker(ap->preg),RegMoniker(ap->sreg)); |
if (ap->offset->i != 0) |
PutConstant(ap->offset); |
if (ap->scale==1) |
fprintf(output,"[%s+%s]",RegMoniker(ap->sreg),RegMoniker(ap->preg)); |
else |
fprintf(output,"[%s+%s*%d]",RegMoniker(ap->sreg),RegMoniker(ap->preg),ap->scale); |
break; |
case am_indx3: |
PutConstant(ap->offset); |
fprintf(output,"[%s+%s]",RegMoniker(ap->preg),RegMoniker(ap->sreg)); |
if (ap->offset->i != 0) |
PutConstant(ap->offset); |
fprintf(output,"[%s+%s]",RegMoniker(ap->sreg),RegMoniker(ap->preg)); |
break; |
case am_mask: |
put_mask(ap->offset); |
317,7 → 323,7
|
void genhalf(int val) |
{ |
if( gentype == bytegen && outcol < 60) { |
if( gentype == halfgen && outcol < 60) { |
fprintf(output,",%d",val & 0xffffffff); |
outcol += 10; |
} |
337,7 → 343,7
} |
else { |
nl(); |
fprintf(output,"\tdw\t%I64d",val); |
fprintf(output,"\tdh\t%I64d",val); |
gentype = wordgen; |
outcol = 33; |
} |
344,7 → 350,8
} |
|
void GenerateLong(__int64 val) |
{ if( gentype == longgen && outcol < 56) { |
{ |
if( gentype == longgen && outcol < 56) { |
fprintf(output,",%I64d",val); |
outcol += 10; |
} |
408,7 → 415,7
{ |
struct slit *lp; |
|
++global_flag; /* always AllocateRegisterVars from global space. */ |
++global_flag; /* always allocate from global space. */ |
lp = (struct slit *)xalloc(sizeof(struct slit)); |
lp->label = nextlabel++; |
lp->str = litlate(s); |
474,4 → 481,28
} |
} |
|
|
void seg(int sg) |
{ |
if( curseg != sg) { |
nl(); |
switch(sg) { |
case bssseg: |
fprintf(output,"\tbss\n"); |
fprintf(output,"\talign\t8\n"); |
break; |
case dataseg: |
fprintf(output,"\tdata\n"); |
fprintf(output,"\talign\t8\n"); |
break; |
case idataseg: |
fprintf(output,"\tidata\n"); |
fprintf(output,"\talign\t8\n"); |
break; |
case codeseg: |
fprintf(output,"\tcode\n"); |
fprintf(output,"\talign\t16\n"); |
break; |
} |
curseg = sg; |
} |
} |
/raptor64/trunk/software/c64/source/Analyze.c
242,6 → 242,8
case en_eq: case en_ne: |
case en_gt: case en_ge: |
case en_lt: case en_le: |
case en_ugt: case en_uge: |
case en_ult: case en_ule: |
case en_asmul: case en_asdiv: |
case en_asmod: case en_aslsh: |
case en_asrsh: |
307,6 → 309,7
break; |
case st_spinlock: |
scan(block->s1); |
scan(block->s2); |
break; |
} |
block = block->next; |
372,6 → 375,7
int reg, mask, rmask; |
AMODE *ap, *ap2; |
int nn; |
int cnt; |
|
reg = 11; |
mask = 0; |
381,7 → 385,7
while( csp != NULL ) { |
if( OptimizationDesireability(csp) < 3 ) // was < 3 |
csp->reg = -1; |
// else if( csp->duses > csp->uses / 8 && reg < 18 ) // was / 4 |
// else if( csp->duses > csp->uses / 4 && reg < 18 ) |
else if( reg < 18 ) // was / 4 |
csp->reg = reg++; |
else |
394,17 → 398,18
csp = csp->next; |
} |
if( mask != 0 ) { |
if (bitsset(rmask) < 2) { |
for (nn = 0; nn < 32; nn++) |
if (rmask & (0x80000000 >> nn)) { |
GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(8)); |
GenerateTriadic(op_sw,0,makereg(nn&31),make_indirect(30),NULL); |
} |
cnt = 0; |
GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(bitsset(rmask)*8)); |
for (nn = 0; nn < 32; nn++) { |
if (rmask & (0x80000000 >> nn)) { |
GenerateTriadic(op_sw,0,makereg(nn&31),make_indexed(cnt,30),NULL); |
cnt+=8; |
} |
} |
else { |
GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(popcnt(mask)*8)); |
GenerateDiadic(op_sm,0,make_indirect(30),make_mask(mask),NULL); |
} |
//else { |
// GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(popcnt(mask)*8)); |
// GenerateDiadic(op_sm,0,make_indirect(30),make_mask(mask),NULL); |
//} |
} |
save_mask = mask; |
csp = olist; |
495,6 → 500,8
case en_eq: case en_ne: |
case en_lt: case en_le: |
case en_gt: case en_ge: |
case en_ult: case en_ule: |
case en_ugt: case en_uge: |
case en_cond: case en_void: |
case en_asadd: case en_assub: |
case en_asmul: case en_asdiv: |
/raptor64/trunk/software/c64/source/ParseDeclarations.c
334,6 → 334,7
head = temp1; |
if( lastst == closepa) { |
NextToken(); |
temp1->type = bt_ifunc; // this line wasn't present |
if(lastst == begin) |
temp1->type = bt_ifunc; |
} |
380,6 → 381,7
{ |
SYM *sp, *sp1, *sp2; |
TYP *dhead; |
char stnm[200]; |
|
static long old_nbytes; |
int nbytes; |
393,7 → 395,7
ParseDeclarationPrefix(ztype==bt_union); |
if( declid != 0) { /* otherwise just struct tag... */ |
sp = allocSYM(); |
sp->name = declid; |
sp->name = declid; |
sp->storage_class = al; |
if (bit_width > 0 && bit_offset > 0) { |
// share the storage word with the previously defined field |
413,8 → 415,9
} |
++nbytes; |
} |
if( al == sc_static) |
if( al == sc_static) { |
sp->value.i = nextlabel++; |
} |
else if( ztype == bt_union) |
sp->value.i = ilc; |
else if( al != sc_auto ) |
526,8 → 529,12
break; |
case kw_extern: |
NextToken(); |
if (lastst==kw_oscall || lastst==kw_interrupt || lastst==kw_nocall) |
if (lastst==kw_pascal) { |
isPascal = TRUE; |
NextToken(); |
} |
else if (lastst==kw_oscall || lastst==kw_interrupt || lastst==kw_nocall) |
NextToken(); |
++global_flag; |
declare(&gsyms,sc_external,0,bt_struct); |
--global_flag; |
/raptor64/trunk/software/c64/source/MemoryManagement.c
124,7 → 124,7
int blkcnt; |
bp1 = glbblk; |
blkcnt = 0; |
while( bp1 != 0 ) { |
while( bp1 != NULL ) { |
bp2 = bp1->next; |
free(bp1); |
++blkcnt; |
136,7 → 136,7
// gsyms.tail = NULL; |
memset(gsyms,0,sizeof(gsyms)); |
printf(" releasing %d bytes global tables.\n",blkcnt * BLKSIZE); |
strtab = 0; /* clear literal table */ |
strtab = NULL; /* clear literal table */ |
} |
|
SYM *allocSYM() { return (SYM *)xalloc(sizeof(SYM)); }; |
/raptor64/trunk/software/c64/source/Initializers.c
39,13 → 39,21
int InitializeArray(TYP *tp); |
|
void doinit(SYM *sp) |
{ |
dseg(); /* initialize into data segment */ |
nl(); /* start a new line in object */ |
if(sp->storage_class == sc_static) |
{ |
if (sp->storage_class == sc_static || lastst==assign) { |
seg(dataseg); /* initialize into data segment */ |
nl(); /* start a new line in object */ |
} |
else { |
seg(bssseg); /* initialize into data segment */ |
nl(); /* start a new line in object */ |
} |
if(sp->storage_class == sc_static) { |
put_label(sp->value.i); |
else |
} |
else { |
gen_strlab(sp->name); |
} |
if( lastst != assign) { |
genstorage(sp->tp->size); |
} |
/raptor64/trunk/software/c64/source/ParseFunction.c
175,11 → 175,19
|
void ParseFunctionBody(SYM *sp) |
{ |
char lbl[200]; |
|
needpunc(begin); |
ParseAutoDeclarations(); |
cseg(); |
if (sp->storage_class == sc_static) |
put_label((unsigned int) sp->value.i); |
{ |
strcpy(lbl,GetNamespace()); |
strcat(lbl,"_"); |
strcat(lbl,sp->name); |
gen_strlab(lbl); |
} |
// put_label((unsigned int) sp->value.i); |
else |
gen_strlab(sp->name); |
currentFn = sp; |
/raptor64/trunk/software/c64/source/CodeGenerator.c
295,6 → 295,7
ap1->mode = am_indx2; |
ap1->sreg = ap2->preg; |
ap1->offset = makeinode(en_icon,0); |
ap1->scale = node->scale; |
return ap1; |
} |
ap1 = GenerateExpression(node->p[0],F_REG | F_IMMED,8); |
322,6 → 323,7
ap1->mode = am_indx2; /* make indirect */ |
ap1->sreg = ap2->preg; |
ap1->offset = makeinode(en_icon,0); |
ap1->scale = node->scale; |
// ReleaseTempRegister(ap2); /* release any temps in ap2 */ |
// ReleaseTempRegister(ap1); |
return ap1; /* return indirect */ |
478,17 → 480,19
*/ |
AMODE *GenerateModDiv(ENODE *node,int flags,int size, int op) |
{ |
AMODE *ap1, *ap2; |
AMODE *ap1, *ap2, *ap3; |
|
if( node->p[0]->nodetype == en_icon ) |
swap_nodes(node); |
ap1 = GenerateExpression(node->p[0],F_REG,8); |
ap2 = GenerateExpression(node->p[1],F_REG | F_IMMED,8); |
GenerateTriadic(op,0,ap1,ap1,ap2); |
GenerateDiadic(op_ext,0,ap1,0); |
MakeLegalAmode(ap1,flags,4); |
ap3 = GetTempRegister(); |
GenerateTriadic(op,0,ap3,ap1,ap2); |
// GenerateDiadic(op_ext,0,ap3,0); |
MakeLegalAmode(ap3,flags,4); |
ReleaseTempRegister(ap1); |
ReleaseTempRegister(ap2); |
return ap1; |
return ap3; |
} |
|
/* |
/raptor64/trunk/software/c64/source/ParseStatements.c
234,22 → 234,33
snp = NewStatement(st_spinlock, TRUE); |
if (lastst==openpa) |
NextToken(); |
if( lastst != id ) { |
error(ERR_IDEXPECT); |
return 0; |
} |
if( (sp = search(lastid,&gsyms[0])) == NULL ) { |
error( ERR_UNDEFINED ); |
return 0; |
} |
NextToken(); |
if( NonCommaExpression(&(snp->exp)) == 0 ) |
error(ERR_EXPREXPECT); |
snp->incrExpr = 1; |
snp->initExpr = 0; |
//if( lastst != id ) { |
// error(ERR_IDEXPECT); |
// return 0; |
// } |
// if( (sp = search(lastid,&gsyms[0])) == NULL ) { |
// error( ERR_UNDEFINED ); |
// return 0; |
// } |
// NextToken(); |
if (lastst==comma) { |
NextToken(); |
snp->exp = GetIntegerExpression(); |
snp->incrExpr = GetIntegerExpression(); |
if (snp->incrExpr < 1 || snp->incrExpr > 15) |
error(ERR_SEMA_INCR); |
snp->incrExpr = (int)snp->incrExpr & 15; |
} |
if (lastst==comma) { |
NextToken(); |
snp->initExpr = GetIntegerExpression(); |
} |
if (lastst==closepa) |
NextToken(); |
snp->label = sp->name; |
// snp->label = sp->name; |
snp->next = 0; |
snp->s1 = ParseStatement(); |
if (lastst==kw_lockfail) { |
265,20 → 276,30
SYM *sp; |
|
snp = NewStatement(st_spinunlock, TRUE); |
snp->incrExpr = 1; |
if (lastst==openpa) |
NextToken(); |
if( lastst != id ) { |
error(ERR_IDEXPECT); |
return 0; |
} |
if( (sp = search(lastid,&gsyms[0])) == NULL ) { |
error( ERR_UNDEFINED ); |
return 0; |
} |
if( expression(&(snp->exp)) == 0 ) |
error(ERR_EXPREXPECT); |
if (lastst==comma) { |
NextToken(); |
snp->incrExpr = GetIntegerExpression(); |
if (snp->incrExpr < 1 || snp->incrExpr > 15) |
error(ERR_SEMA_INCR); |
snp->incrExpr = (int)snp->incrExpr & 15; |
} |
//if( lastst != id ) { |
// error(ERR_IDEXPECT); |
// return 0; |
//} |
// if( (sp = search(lastid,&gsyms[0])) == NULL ) { |
// error( ERR_UNDEFINED ); |
//return 0; |
// } |
NextToken(); |
if (lastst==closepa) |
NextToken(); |
snp->label = sp->name; |
//snp->label = sp->name; |
snp->next = 0; |
return snp; |
} |
/raptor64/trunk/software/c64/source/Register.c
100,23 → 100,61
printf("DIAG - register stack underflow.\r\n"); |
} |
|
//int SaveTempRegs() |
//{ |
// if (popcnt(regmask)==1) { |
// GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(8)); |
// GenerateTriadic(op_sw,0,make_mask(regmask),make_indirect(30),NULL); |
// } |
// else if (regmask != 0) { |
// GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(popcnt(regmask)*8)); |
// GenerateTriadic(op_sm,0,make_indirect(30),make_mask(regmask),NULL); |
// } |
// return regmask; |
//} |
// |
|
int SaveTempRegs() |
{ |
int n; |
int rm; |
|
if (regmask != 0) { |
GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(popcnt(regmask)*8)); |
GenerateTriadic(op_sm,0,make_indirect(30),make_mask(regmask),NULL); |
for (n = 1, rm = regmask; rm != 0; n = n + 1,rm = rm >> 1) |
if (rm & 1) |
GenerateDiadic(op_sw,0,makereg(n),make_indexed((popcnt(rm)-1)*8,30)); |
} |
return regmask; |
} |
|
|
void RestoreTempRegs(int rgmask) |
{ |
int n; |
int rm; |
|
if (rgmask != 0) { |
GenerateTriadic(op_lm,0,make_indirect(30),make_mask(rgmask),NULL); |
for (n = 1, rm = rgmask; rm != 0; n = n + 1,rm = rm >> 1) |
if (rm & 1) |
GenerateDiadic(op_lw,0,makereg(n),make_indexed((popcnt(rm)-1)*8,30)); |
GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(popcnt(rgmask)*8)); |
} |
} |
|
|
//void RestoreTempRegs(int rgmask) |
//{ |
// if (popcnt(rgmask)==1) { |
// GenerateTriadic(op_lw,0,make_mask(rgmask),make_indirect(30),NULL); |
// GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(8)); |
// } |
// else if (rgmask != 0) { |
// GenerateTriadic(op_lm,0,make_indirect(30),make_mask(rgmask),NULL); |
// GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(popcnt(rgmask)*8)); |
// } |
//} |
// |
void ReleaseTempRegister(struct amode *ap) |
{ |
if (ap==NULL) { |
/raptor64/trunk/software/c64/source/Cglbdef.c
32,7 → 32,8
FILE *input = 0, |
*list = 0, |
*output = 0; |
|
FILE *outputG = 0; |
int incldepth = 0; |
int lineno = 0; |
int nextlabel = 0; |
int lastch = 0; |
45,7 → 46,7
TABLE gsyms[257],// = {0,0}, |
lsyms = {0,0}; |
SYM *lasthead = NULL; |
struct slit *strtab = 0; |
struct slit *strtab = NULL; |
int lc_static = 0; |
int lc_auto = 0; |
struct snode *bodyptr = 0; |
63,3 → 64,7
SYM *currentFn = NULL; |
int callsFn = FALSE; |
|
char nmspace[20][100]; |
|
|
|
/raptor64/trunk/software/c64/source/Cmain.c
34,9 → 34,11
int openfiles(char *); |
void closefiles(); |
|
char infile[20], |
listfile[20], |
outfile[20]; |
char infile[32], |
listfile[32], |
outfile[32], |
outfileG[32]; |
|
extern TABLE tagtable; |
int mainflag; |
extern int total_errors; |
75,12 → 77,16
|
int openfiles(char *s) |
{ |
int ofl; |
int ofl,oflg; |
int i; |
strcpy(infile,s); |
strcpy(listfile,s); |
strcpy(outfile,s); |
strcpy(outfileG,s); |
_splitpath(s,NULL,NULL,nmspace[0],NULL); |
makename(listfile,".lis"); |
makename(outfile,".s"); |
makename(outfileG,".sg"); |
if( (input = fopen(infile,"r")) == 0) { |
printf(" cant open %s\n",infile); |
return 0; |
92,15 → 98,29
fclose(input); |
return 0; |
} |
oflg = _creat(outfileG,-1); |
if( oflg < 0 ) |
{ |
printf(" cant create %s\n",outfileG); |
fclose(input); |
return 0; |
} |
if( (output = _fdopen(ofl,"w")) == 0) { |
printf(" cant open %s\n",outfile); |
fclose(input); |
return 0; |
} |
if( (outputG = _fdopen(oflg,"w")) == 0) { |
printf(" cant open %s\n",outfileG); |
fclose(input); |
fclose(output); |
return 0; |
} |
if( (list = fopen(listfile,"w")) == 0) { |
printf(" cant open %s\n",listfile); |
fclose(input); |
fclose(output); |
fclose(outputG); |
return 0; |
} |
return 1; |
126,5 → 146,11
{ |
fclose(input); |
fclose(output); |
fclose(outputG); |
fclose(list); |
} |
|
char *GetNamespace() |
{ |
return nmspace[incldepth]; |
} |
/raptor64/trunk/software/c64/source/GenerateShift.c
31,7 → 31,7
|
AMODE *GenerateShift(ENODE *node,int flags, int size, int op) |
{ |
AMODE *ap1, *ap2; |
AMODE *ap1, *ap2, *ap3; |
|
ap1 = GenerateExpression(node->p[0],F_REG,size); |
ap2 = GenerateExpression(node->p[1],F_REG | F_IMMED,8); |
53,6 → 53,7
} |
break; |
} |
ap3 = GetTempRegister(); |
if (ap2->mode==am_immed) { |
switch(op) |
{ |
60,13 → 61,14
case op_shr: op = op_shri; break; |
case op_shru: op = op_shrui; break; |
} |
GenerateTriadic(op,0,ap1,ap1,make_immed(ap2->offset->i)); |
GenerateTriadic(op,0,ap3,ap1,make_immed(ap2->offset->i)); |
} |
else |
GenerateTriadic(op,0,ap1,ap1,ap2); |
GenerateTriadic(op,0,ap3,ap1,ap2); |
ReleaseTempRegister(ap1); |
ReleaseTempRegister(ap2); |
MakeLegalAmode(ap1,flags,size); |
return ap1; |
MakeLegalAmode(ap3,flags,size); |
return ap3; |
} |
|
|
/raptor64/trunk/software/c64/source/Cglbdec.h
21,7 → 21,8
extern FILE *input, |
*list, |
*output; |
|
extern FILE *outputG; |
extern int incldepth; |
extern int lineno; |
extern int nextlabel; |
extern int lastch; |
94,7 → 95,7
// Func.c |
extern void funcbody(SYM *sp); |
// Intexpr.c |
extern int GetIntegerExpression(); |
extern __int64 GetIntegerExpression(); |
// Expr.c |
extern ENODE *makenode(int nt, ENODE *v1, ENODE *v2); |
extern ENODE *makeinode(int nt, __int64 v1); |
117,7 → 118,7
extern void GenerateChar(int val); |
extern void genhalf(int val); |
extern void GenerateWord(__int64 val); |
extern void GenerateLong(int val); |
extern void GenerateLong(__int64 val); |
extern void genstorage(int nbytes); |
extern void GenerateReference(SYM *sp,int offset); |
extern void GenerateLabelReference(int n); |
147,5 → 148,8
extern AMODE *make_indirect(int i); |
extern AMODE *make_indexed(__int64 o, int i); |
extern void GenerateFalseJump(struct enode *node,int label); |
extern char *GetNamespace(); |
extern char nmspace[20][100]; |
enum e_sg { noseg, codeseg, dataseg, bssseg, idataseg }; |
|
|