OpenCores
URL https://opencores.org/ocsvn/raptor64/raptor64/trunk

Subversion Repositories raptor64

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /raptor64
    from Rev 50 to Rev 51
    ↔ Reverse comparison
  •

Rev 50 → Rev 51

/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;
}
 
/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();
/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,
/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
/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;
/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 */
}
/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 */
 
/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)
/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) {
/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;
}
}
/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:
/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;
/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)); };
/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);
}
/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;
/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;
}
 
/*
/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;
}
/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) {
/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];
 
 
 
/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];
}
/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;
}
 
 
/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 };
 


powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.