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

Subversion Repositories lwrisc

[/] [lwrisc/] [trunk/] [CTOOL/] [hexdasm.c] - Blame information for rev 7

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 7 mcupro 
#include "stdlib.h"
2 
#include "stdio.h"
3 
#include "string.h"
4 
 
5 
int func1(int in)
6 
{
7 
const int table[]={1,2,4,8,16,32,64,128,256,512,1024,2048};
8 
int i =0;
9 
if (in>=2048)return -1;
10 
for(;;i++)
11 
if ((in>table[i])&&(in<table[i+1])){
12 
return i+1;
13 
}
14 
}
15 
 
16 
 
17 
int getbit(unsigned int data,unsigned int index)
18 
{
19 
    unsigned int temp=1<<index ;
20 
    if(data&temp)
21 
    return 1 ;
22 
    else
23 
    return 0 ;
24 
}
25 
 
26 
char temp[100];
27 
char*ins12tostr(unsigned int ins)
28 
{
29 
    unsigned int i ;
30 
    for(i=0;i<100;++i)temp[i]=0 ;
31 
    for(i=0;i<=11;++i)
32 
    temp[i]=getbit(ins,11-i)+'0' ;
33 
    return temp ;
34 
}
35 
/*static volatile       unsigned char   WB_ADDR         @ 0x01;
36 
//static volatile       unsigned char   PCL             @ 0x02;
37 
static volatile       unsigned char     STATUS          @ 0x03;
38 
static                unsigned char     FSR             @ 0x04;
39 
static volatile       unsigned char     WB_DATA         @ 0x05;
40 
static volatile       unsigned char     WB_CTL          @ 0x06;*/
41 
static char reg_name[30];
42 
char*find_reg(unsigned int t)
43 
{
44 
    //puts(&ins[7]);
45 
    if(t==0)
46 
    {
47 
        //  printf("t=%d",t);
48 
        strcpy(reg_name,"WB_ADDR");
49 
        return reg_name ;
50 
    }
51 
    //    if(reg_no==0)strcpy(reg_name,"WB_CTL");
52 
    else if(t==1)
53 
    {
54 
        strcpy(reg_name,"TMR");
55 
        return reg_name ;
56 
    }
57 
    //    else if(reg_no==1)strcpy(reg_name,"WB_ADDR");
58 
    else if(t==2)
59 
    {
60 
        strcpy(reg_name,"PCL");
61 
        return reg_name ;
62 
    }
63 
    else if(t-3==0)
64 
    {
65 
        strcpy(reg_name,"STATUS");
66 
        return reg_name ;
67 
    }
68 
    else if(t==0+4)
69 
    {
70 
        strcpy(reg_name,"FSR");
71 
        return reg_name ;
72 
    }
73 
    else if(t==5+0)
74 
    {
75 
        strcpy(reg_name,"WB_DATA");
76 
        return reg_name ;
77 
    }
78 
    //else if(reg_no==5)strcpy(reg_name,"WB_WR_DATA");
79 
    else if(t==6+0)
80 
    {
81 
        strcpy(reg_name,"WB_CTL");
82 
        return reg_name ;
83 
    }
84 
    //else if(reg_no==6)strcpy(reg_name,"WB_RD_DATA");
85 
    else if(t==0+1+6)
86 
    {
87 
        strcpy(reg_name,"PORTC");
88 
        return reg_name ;
89 
    }
90 
    return NULL ;
91 
}
92 
 
93 
char hex[]=
94 
{
95 
    "0123456789abcdef"
96 
}
97 
;
98 
char*p,__hex[20]=
99 
{
100 
 
101 
}
102 
;
103 
unsigned char*bs2hs(char*bs)
104 
{
105 
    unsigned int t=0,i=0 ;
106 
    for(i=0;;++i)
107 
    {
108 
        if(bs[i]==0)break ;
109 
        t=t*2+bs[i]-'0' ;
110 
    }
111 
    //printf("now t==%d",t);
112 
    p=find_reg(t);
113 
    //if (t>=8) goto else
114 
    if(p!=NULL)
115 
    strcpy(__hex,p);
116 
    else
117 
    {
118 
        __hex[0]='0' ;
119 
        __hex[1]='x' ;
120 
        __hex[2]=hex[t/16];
121 
        __hex[3]=hex[t%16];
122 
        __hex[4]=0 ;
123 
    }
124 
    return __hex ;
125 
}
126 
 
127 
char _temp[100];
128 
//get file reg adderss from instruction!
129 
char*gen_ins_fa(char*ins)
130 
{//gen_ins_in(
131 
    strcpy(_temp,ins);
132 
    return bs2hs(&_temp[7]);
133 
}
134 
 
135 
//get bit data from instruction!
136 
unsigned int gen_ins_bd(char*ins)
137 
{
138 
//1111_1111_1111
139 
    unsigned int t=0 ;
140 
    if(ins[5+1]=='1')t+=1 ;
141 
    if(ins[4+1]=='1')t+=2 ;
142 
    if(ins[3+1]=='1')t+=4 ;
143 
    return t ;
144 
}
145 
 
146 
//get goto(and call) address data from instruction!
147 
unsigned int gen_ins_goto(char*ins)
148 
{
149 
//000_111111001
150 
    unsigned int t=0 ;
151 
    if(ins[11-0]=='1')t+=1;
152 
    if(ins[11-1]=='1')t+=2 ;
153 
    if(ins[11-2]=='1')t+=4;
154 
    if(ins[11-3]=='1')t+=8 ;
155 
    if(ins[11-4]=='1')t+=16;//1<<4 ;
156 
    if(ins[11-5]=='1')t+=32;//1<<5 ;
157 
    if(ins[11-6]=='1')t+=64;//1<<6 ;
158 
    if(ins[11-7]=='1')t+=128;//1<<7 ;
159 
    if(ins[11-8]=='1')t+=256;//1<<8 ;
160 
    return t ;
161 
}
162 
 
163 
//get instant data from instruction!
164 
unsigned int gen_ins_in(char*ins)
165 
{
166 
    unsigned int t=0 ;
167 
    if(ins[11-0]=='1')t+=1;
168 
    if(ins[11-1]=='1')t+=2 ;
169 
    if(ins[11-2]=='1')t+=4;//1<<3 ;
170 
    if(ins[11-3]=='1')t+=8;//1<<4 ;
171 
    if(ins[11-4]=='1')t+=16;//1<<4 ;
172 
    if(ins[11-5]=='1')t+=32;//1<<5 ;
173 
    if(ins[11-6]=='1')t+=64;//1<<6 ;
174 
    if(ins[11-7]=='1')t+=128;//1<<7 ;
175 
    // if(ins[11-8]=='1')t+=1<<8 ;
176 
    return t ;
177 
}
178 
 
179 
 
180 
unsigned int inscmp(char*src,char*dst)
181 
{
182 
    unsigned int i ;
183 
    for(i=0;i<=9;i++)
184 
    {
185 
        if(src[i]=='X')continue ;
186 
        else if(src[i]!=dst[i])return 0 ;
187 
    }
188 
    return 1 ;
189 
}
190 
 
191 
 
192 
unsigned int str2u12(char*str)
193 
{
194 
    unsigned int ret=0 ;
195 
    unsigned int i ;
196 
    for(i=0;i<=11;++i)
197 
    {
198 
        if(str[i]==0)return ret ;
199 
        ret=ret*10+str[i]-'0' ;
200 
    }
201 
    return ret ;
202 
}
203 
/*
204 
unsigned int getfno(char *ins,unsigned char start,
205 
unsigned char len)
206 
{
207 
unsigned int data = str2u12(ins);
208 
    unsigned int tmp1=0xffff<<len ;
209 
    unsigned int tmp2=data>>start ;
210 
    unsigned int ret ;
211 
    tmp1=~tmp1 ;
212 
    ret=tmp1&tmp2 ;
213 
    ret=ret&0xffff ;
214 
    return ret ;
215 
 
216 
unsigned int i,ret=0;
217 
for(i=11-start;i<len;++i)
218 
ret=ret+(ins[i]-'0')*2;
219 
return ret;
220 
}*/
221 
/*
222 
void test_main(void)
223 
{
224 
    printf("%d",getno(str2u12("0xff"),0,1));
225 
    getchar();
226 
}*/
227 
 
228 
 
229 
 
230 
char tmp_str[100]=
231 
{
232 
 
233 
}
234 
;
235 
void init_temp_str(void)
236 
{
237 
    int i ;
238 
    for(i=0;i<100;++i)
239 
    tmp_str[i]=0 ;
240 
}
241 
 
242 
char*op_ins_NOP(char*ins)
243 
{
244 
    init_temp_str();
245 
    sprintf(tmp_str,"NOP");
246 
    add_ins("NOP");
247 
    //ok
248 
    return tmp_str ;
249 
 
250 
}
251 
char*op_ins_MOVWF(char*ins)
252 
{
253 
    init_temp_str();
254 
    sprintf(tmp_str,"MOVWF %s",gen_ins_fa(ins));
255 
    add_ins("MOVWF");
256 
    //ok
257 
    return tmp_str ;
258 
}
259 
char*op_ins_CLRW(char*ins)
260 
{
261 
    init_temp_str();
262 
    sprintf(tmp_str,"CLRW");
263 
    add_ins("CLRW");
264 
    return tmp_str ;
265 
}
266 
char*op_ins_CLRF(char*ins)
267 
{
268 
    init_temp_str();
269 
    sprintf(tmp_str,"CLRF %s",gen_ins_fa(ins));
270 
    add_ins("CLRF");
271 
    return tmp_str ;
272 
}
273 
char*op_ins_SUBWFW(char*ins)
274 
{
275 
    init_temp_str();
276 
    sprintf(tmp_str,"SUBWFW %s",gen_ins_fa(ins));
277 
    add_ins("SUBWFW");
278 
    return tmp_str ;
279 
}
280 
char*op_ins_SUBWFF(char*ins)
281 
{
282 
    init_temp_str();
283 
    sprintf(tmp_str,"SUBWFF %s",gen_ins_fa(ins));
284 
    add_ins("WUBWFF");
285 
    return tmp_str ;
286 
}
287 
char*op_ins_DECFW(char*ins)
288 
{
289 
    init_temp_str();
290 
    sprintf(tmp_str,"DECFW %s",gen_ins_fa(ins));
291 
    add_ins("DECFW");
292 
    return tmp_str ;
293 
}
294 
char*op_ins_DECFF(char*ins)
295 
{
296 
    init_temp_str();
297 
    sprintf(tmp_str,"DECFF %s",gen_ins_fa(ins));
298 
    add_ins("DECFF");
299 
    return tmp_str ;
300 
}
301 
char*op_ins_IORWFW(char*ins)
302 
{
303 
    init_temp_str();
304 
    sprintf(tmp_str,"IORWFW %s",gen_ins_fa(ins));
305 
    add_ins("IORWFW");
306 
    return tmp_str ;
307 
}
308 
char*op_ins_IORWFF(char*ins)
309 
{
310 
    init_temp_str();
311 
    sprintf(tmp_str,"IORWFF %s",gen_ins_fa(ins));
312 
    add_ins("IORWFF");
313 
    return tmp_str ;
314 
}
315 
char*op_ins_ANDWFW(char*ins)
316 
{
317 
    init_temp_str();
318 
    sprintf(tmp_str,"ANDWFW %s",gen_ins_fa(ins));
319 
    add_ins("ANDWFW");
320 
    return tmp_str ;
321 
}
322 
char*op_ins_ANDWFF(char*ins)
323 
{
324 
    init_temp_str();
325 
    add_ins("ANDWFF");
326 
    sprintf(tmp_str,"ANDWFF %s",gen_ins_fa(ins));
327 
    return tmp_str ;
328 
}
329 
char*op_ins_XORWFW(char*ins)
330 
{
331 
    init_temp_str();
332 
    add_ins("XORWFW");
333 
    sprintf(tmp_str,"XORWFW %s",gen_ins_fa(ins));
334 
    return tmp_str ;
335 
}
336 
char*op_ins_XORWFF(char*ins)
337 
{
338 
    init_temp_str();
339 
    add_ins("XORWFF");
340 
    sprintf(tmp_str,"XORWFF %s",gen_ins_fa(ins));
341 
    return tmp_str ;
342 
}
343 
char*op_ins_ADDWFW(char*ins)
344 
{
345 
    init_temp_str();
346 
    add_ins("ADDWFW");
347 
    sprintf(tmp_str,"ADDWFW %s",gen_ins_fa(ins));
348 
    return tmp_str ;
349 
}
350 
char*op_ins_ADDWFF(char*ins)
351 
{
352 
    init_temp_str();
353 
    add_ins("ADDWFF");
354 
    sprintf(tmp_str,"ADDWFF %s",gen_ins_fa(ins));
355 
    return tmp_str ;
356 
}
357 
char*op_ins_MOVFW(char*ins)
358 
{
359 
    init_temp_str();
360 
    add_ins("MOVFW");
361 
    sprintf(tmp_str,"MOVFW %s",gen_ins_fa(ins));
362 
    return tmp_str ;
363 
 
364 
 
365 
}
366 
char*op_ins_MOVFF(char*ins)
367 
{
368 
    init_temp_str();
369 
    add_ins("MOVFF");
370 
    sprintf(tmp_str,"MOVFF %s",gen_ins_fa(ins));
371 
    return tmp_str ;
372 
}
373 
char*op_ins_COMFW(char*ins)
374 
{
375 
    init_temp_str();
376 
    add_ins("COMFW");
377 
    sprintf(tmp_str,"COMFW %s",gen_ins_fa(ins));
378 
    return tmp_str ;
379 
}
380 
char*op_ins_COMFF(char*ins)
381 
{
382 
    init_temp_str();
383 
    add_ins("COMFF");
384 
    sprintf(tmp_str,"COMFF %s",gen_ins_fa(ins));
385 
    return tmp_str ;
386 
}
387 
char*op_ins_INCFW(char*ins)
388 
{
389 
    init_temp_str();
390 
    add_ins("INCFW");
391 
    sprintf(tmp_str,"INCFW %s",gen_ins_fa(ins));
392 
    return tmp_str ;
393 
}
394 
char*op_ins_INCFF(char*ins)
395 
{
396 
    init_temp_str();
397 
    add_ins("INCFF");
398 
    sprintf(tmp_str,"INCFF %s",gen_ins_fa(ins));
399 
    return tmp_str ;
400 
}
401 
char*op_ins_DECFSZW(char*ins)
402 
{
403 
    init_temp_str();
404 
    add_ins("DECFSZW");
405 
    sprintf(tmp_str,"DECFSZW %s",gen_ins_fa(ins));
406 
    return tmp_str ;
407 
}
408 
char*op_ins_DECFSZF(char*ins)
409 
{
410 
    init_temp_str();
411 
    add_ins("DECFSZF");
412 
    sprintf(tmp_str,"DECFSZF %s  [%d]",gen_ins_fa(ins),gen_ins_bd(ins));
413 
    return tmp_str ;
414 
}
415 
char*op_ins_RRFW(char*ins)
416 
{
417 
    init_temp_str();
418 
    add_ins("RRFW");
419 
    sprintf(tmp_str,"RRFW %s",gen_ins_fa(ins));
420 
    return tmp_str ;
421 
}
422 
char*op_ins_RRFF(char*ins)
423 
{
424 
    init_temp_str();
425 
    add_ins("RRFF");
426 
    sprintf(tmp_str,"RRFF%s",gen_ins_fa(ins));
427 
    return tmp_str ;
428 
}
429 
char*op_ins_RLFW(char*ins)
430 
{
431 
    init_temp_str();
432 
    add_ins("RRFW");
433 
    sprintf(tmp_str,"RLFW %s",gen_ins_fa(ins));
434 
    return tmp_str ;
435 
}
436 
char*op_ins_RLFF(char*ins)
437 
{
438 
    init_temp_str();
439 
    add_ins("RLFF");
440 
    sprintf(tmp_str,"RLFF %s",gen_ins_fa(ins));
441 
    return tmp_str ;
442 
}
443 
char*op_ins_SWAPFW(char*ins)
444 
{
445 
    init_temp_str();
446 
    add_ins("SWAPFW");
447 
    sprintf(tmp_str,"SWAPFW %s",gen_ins_fa(ins));
448 
    return tmp_str ;
449 
}
450 
char*op_ins_SWAPFF(char*ins)
451 
{
452 
    init_temp_str();
453 
    add_ins("SWAPFF");
454 
    sprintf(tmp_str,"SWAPFF %s",gen_ins_fa(ins));
455 
    return tmp_str ;
456 
}
457 
char*op_ins_INCFSZW(char*ins)
458 
{
459 
    init_temp_str();
460 
    add_ins("INCFZW");
461 
    sprintf(tmp_str,"INCFSZW %s",gen_ins_fa(ins));
462 
    return tmp_str ;
463 
}
464 
char*op_ins_INCFSZF(char*ins)
465 
{
466 
    init_temp_str();
467 
    add_ins("INCFSZF");
468 
    sprintf(tmp_str,"INCFSZF %s  [%d]",gen_ins_fa(ins),gen_ins_bd(ins));
469 
    return tmp_str ;
470 
}
471 
char*op_ins_BCF(char*ins)
472 
{
473 
    init_temp_str();
474 
    add_ins("BCF");
475 
    sprintf(tmp_str,"BCF %s  [%d]",gen_ins_fa(ins),gen_ins_bd(ins));
476 
    return tmp_str ;
477 
}
478 
char*op_ins_BSF(char*ins)
479 
{
480 
    init_temp_str();
481 
    add_ins("BSF");
482 
    sprintf(tmp_str,"BSF %s  [%d]",gen_ins_fa(ins),gen_ins_bd(ins));
483 
    return tmp_str ;
484 
}
485 
char*op_ins_BTFSC(char*ins)
486 
{
487 
    init_temp_str();
488 
    add_ins("BTFSC");
489 
    sprintf(tmp_str,"BTFSC %s  [%d]",gen_ins_fa(ins),gen_ins_bd(ins));
490 
    return tmp_str ;
491 
}
492 
char*op_ins_BTFSS(char*ins)
493 
{
494 
    init_temp_str();
495 
    add_ins("BTFSS");
496 
    sprintf(tmp_str,"BTFSS %s  [%d]",gen_ins_fa(ins),gen_ins_bd(ins));
497 
    return tmp_str ;
498 
}
499 
char*op_ins_RETLW(char*ins)
500 
{
501 
    init_temp_str();
502 
    add_ins("RETLW");
503 
    sprintf(tmp_str,"RETLW %d",gen_ins_in(ins));
504 
    return tmp_str ;
505 
}
506 
char*op_ins_CALL(char*ins)
507 
{
508 
    init_temp_str();
509 
    add_ins("CALL");
510 
    sprintf(tmp_str,"CALL %d",gen_ins_goto(ins));
511 
    return tmp_str ;
512 
}
513 
char*op_ins_GOTO(char*ins)
514 
{
515 
    init_temp_str();
516 
    add_ins("GOTO");
517 
    sprintf(tmp_str,"GOTO %d",gen_ins_goto(ins));
518 
    return tmp_str ;
519 
}
520 
char*op_ins_MOVLW(char*ins)
521 
{
522 
    init_temp_str();
523 
    add_ins("MOVLW");
524 
    sprintf(tmp_str,"MOVLW %d",gen_ins_in(ins));
525 
    return tmp_str ;
526 
}
527 
char*op_ins_IORLW(char*ins)
528 
{
529 
    init_temp_str();
530 
    add_ins("IORLW");
531 
    sprintf(tmp_str,"IORLW %d",gen_ins_in(ins));
532 
    return tmp_str ;
533 
}
534 
char*op_ins_ANDLW(char*ins)
535 
{
536 
    init_temp_str();
537 
    add_ins("ANDLW");
538 
    sprintf(tmp_str,"ANDLW %d",gen_ins_in(ins));
539 
    return tmp_str ;
540 
}
541 
char*op_ins_XORLW(char*ins)
542 
{
543 
    init_temp_str();
544 
    add_ins("XORLW");
545 
    sprintf(tmp_str,"XORLW %d",gen_ins_in(ins));
546 
    return tmp_str ;
547 
}
548 
 
549 
 
550 
char*branch_ins(char*ins)
551 
{
552 
    if(inscmp("000000000000",ins)==1)
553 
    return op_ins_NOP(ins);
554 
    // char * op_ins_NOP (char *ins){}
555 
    else if(inscmp("0000001XXXXX",ins)==1)
556 
    return op_ins_MOVWF(ins);
557 
    // char * op_ins_MOVWF (char *ins){}
558 
    else if(inscmp("000001000000",ins)==1)
559 
    return op_ins_CLRW(ins);
560 
    // char * op_ins_CLRW (char *ins){}
561 
    else if(inscmp("0000011XXXXX",ins)==1)
562 
    return op_ins_CLRF(ins);
563 
    // char * op_ins_CLRF (char *ins){}
564 
    else if(inscmp("0000100XXXXX",ins)==1)
565 
    return op_ins_SUBWFW(ins);
566 
    // char * op_ins_SUBWFW (char *ins){}
567 
    else if(inscmp("0000101XXXXX",ins)==1)
568 
    return op_ins_SUBWFF(ins);
569 
    // char * op_ins_SUBWFF (char *ins){}
570 
    else if(inscmp("0000110XXXXX",ins)==1)
571 
    return op_ins_DECFW(ins);
572 
    // char * op_ins_DECFW (char *ins){}
573 
    else if(inscmp("0000111XXXXX",ins)==1)
574 
    return op_ins_DECFF(ins);
575 
    // char *op_ins_DECFF  (char *ins){}
576 
    else if(inscmp("0001000XXXXX",ins)==1)
577 
    return op_ins_IORWFW(ins);
578 
    // char * op_ins_IORWFW (char *ins){}
579 
    else if(inscmp("0001001XXXXX",ins)==1)
580 
    return op_ins_IORWFF(ins);
581 
    // char * op_ins_IORWFF (char *ins){}
582 
    else if(inscmp("0001010XXXXX",ins)==1)
583 
    return op_ins_ANDWFW(ins);
584 
    // char * op_ins_ANDWFW (char *ins){}
585 
    else if(inscmp("0001011XXXXX",ins)==1)
586 
    return op_ins_ANDWFF(ins);
587 
    // char *  op_ins_ANDWFF(char *ins){}
588 
    else if(inscmp("0001100XXXXX",ins)==1)
589 
    return op_ins_XORWFW(ins);
590 
    // char * op_ins_XORWFW (char *ins){}
591 
    else if(inscmp("0001101XXXXX",ins)==1)
592 
    return op_ins_XORWFF(ins);
593 
    // char *  op_ins_XORWFF(char *ins){}
594 
    else if(inscmp("0001110XXXXX",ins)==1)
595 
    return op_ins_ADDWFW(ins);
596 
    // char *   op_ins_ADDWFW(char *ins){}
597 
    else if(inscmp("0001111XXXXX",ins)==1)
598 
    return op_ins_ADDWFF(ins);
599 
    // char *  op_ins_ADDWFF(char *ins){}
600 
    else if(inscmp("0010000XXXXX",ins)==1)
601 
    return op_ins_MOVFW(ins);
602 
    // char * op_ins_MOVFW (char *ins){}
603 
    else if(inscmp("0010001XXXXX",ins)==1)
604 
    return op_ins_MOVFF(ins);
605 
    // char *  op_ins_MOVFF(char *ins){}
606 
    else if(inscmp("0010010XXXXX",ins)==1)
607 
    return op_ins_COMFW(ins);
608 
    // char * op_ins_COMFW (char *ins){}
609 
    else if(inscmp("0010011XXXXX",ins)==1)
610 
    return op_ins_COMFF(ins);
611 
    // char *  op_ins_COMFF(char *ins){}
612 
    else if(inscmp("0010100XXXXX",ins)==1)
613 
    return op_ins_INCFW(ins);
614 
    // char *  op_ins_INCFW(char *ins){}
615 
    else if(inscmp("0010101XXXXX",ins)==1)
616 
    return op_ins_INCFF(ins);
617 
    // char *  op_ins_INCFF(char *ins){}
618 
    else if(inscmp("0010110XXXXX",ins)==1)
619 
    return op_ins_DECFSZW(ins);
620 
    // char *op_ins_DECFSZW  (char *ins){}
621 
    else if(inscmp("0010111XXXXX",ins)==1)
622 
    return op_ins_DECFSZF(ins);
623 
    // char *  op_ins_DECFSZF(char *ins){}
624 
    else if(inscmp("0011000XXXXX",ins)==1)
625 
    return op_ins_RRFW(ins);
626 
    // char * op_ins_RRFW (char *ins){}
627 
    else if(inscmp("0011001XXXXX",ins)==1)
628 
    return op_ins_RRFF(ins);
629 
    // char * op_ins_RRFF (char *ins){}
630 
    else if(inscmp("0011010XXXXX",ins)==1)
631 
    return op_ins_RLFW(ins);
632 
    // char *  op_ins_RLFW(char *ins){}
633 
    else if(inscmp("0011011XXXXX",ins)==1)
634 
    return op_ins_RLFF(ins);
635 
    // char *  op_ins_RLFF(char *ins){}
636 
    else if(inscmp("0011100XXXXX",ins)==1)
637 
    return op_ins_SWAPFW(ins);
638 
    // char * op_ins_SWAPFW (char *ins){}
639 
    else if(inscmp("0011101XXXXX",ins)==1)
640 
    return op_ins_SWAPFF(ins);
641 
    // char *  op_ins_SWAPFF(char *ins){}
642 
    else if(inscmp("0011110XXXXX",ins)==1)
643 
    return op_ins_INCFSZW(ins);
644 
    // char *op_ins_INCFSZW  (char *ins){}
645 
    else if(inscmp("0011111XXXXX",ins)==1)
646 
    return op_ins_INCFSZF(ins);
647 
    // char * op_ins_INCFSZF (char *ins){}
648 
    else if(inscmp("0100XXXXXXXX",ins)==1)
649 
    return op_ins_BCF(ins);
650 
    // char * op_ins_BCF (char *ins){}
651 
    else if(inscmp("0101XXXXXXXX",ins)==1)
652 
    return op_ins_BSF(ins);
653 
    // char *  op_ins_BSF(char *ins){}
654 
    else if(inscmp("0110XXXXXXXX",ins)==1)
655 
    return op_ins_BTFSC(ins);
656 
    // char *  op_ins_BTFSC(char *ins){}
657 
    else if(inscmp("0111XXXXXXXX",ins)==1)
658 
    return op_ins_BTFSS(ins);
659 
    // char * op_ins_BTFSS (char *ins){}
660 
    else if(inscmp("1000XXXXXXXX",ins)==1)
661 
    return op_ins_RETLW(ins);
662 
    // char *  op_ins_RETLW(char *ins){}
663 
    else if(inscmp("1001XXXXXXXX",ins)==1)
664 
    return op_ins_CALL(ins);
665 
    // char * op_ins_CALL (char *ins){}
666 
    else if(inscmp("101XXXXXXXXX",ins)==1)
667 
    return op_ins_GOTO(ins);
668 
    // char *  op_ins_GOTO( (char *ins){}
669 
    else if(inscmp("1100XXXXXXXX",ins)==1)
670 
    return op_ins_MOVLW(ins);
671 
    // char * op_ins_MOVLW (char *ins){}
672 
    else if(inscmp("1101XXXXXXXX",ins)==1)
673 
    return op_ins_IORLW(ins);
674 
    // char *  op_ins_IORLW(char *ins){}
675 
    else if(inscmp("1110XXXXXXXX",ins)==1)
676 
    return op_ins_ANDLW(ins);
677 
    // char * op_ins_ANDLW (char *ins){}
678 
    else if(inscmp("1111XXXXXXXX",ins)==1)
679 
    return op_ins_XORLW(ins);
680 
    // char *  op_ins_XORLW(char *ins){}
681 
    return NULL ;
682 
}
683 
 
684 
/*  Input and Output file streams. */
685 
FILE*fpi ;
686 
 
687 
/*  Well.. Let's read stuff in completely before outputting.. Programs */
688 
/*  should be pretty small.. */
689 
/*  */
690 
#define MAX_MEMORY_SIZE 1024
691 
struct
692 
{
693 
int nAddress ;
694 
     int byData ;
695 
    char ins[30];
696 
    char dasm[30];
697 
}
698 
 
699 
 
700 
Memory[MAX_MEMORY_SIZE];
701 
 
702 
char szLine[80];
703 
unsigned int start_address,address,ndata_bytes,ndata_words ;
704 
unsigned int data ;
705 
unsigned int nMemoryCount ;
706 
char mif_fn[20]=
707 
{
708 
 
709 
}
710 
;
711 
char fin[20]=
712 
{
713 
 
714 
}
715 
;
716 
 
717 
char ins_tsted[100][10];
718 
int index=0;
719 
void init1(void){
720 
int i,j;
721 
    for(i=0;i<100;++i)
722 
    for(j=0;j<10;++j)
723 
    ins_tsted[i][j]=0;
724 
    index=0;
725 
}
726 
 
727 
void add_ins(char *ins){
728 
int i;
729 
for(i=0;i<=index;++i)
730 
if (strcmp(ins_tsted[i],ins)==0) return ;
731 
++index;
732 
//printf("add string >%s<\n",ins);getchar();
733 
strcpy(ins_tsted[index],ins);
734 
}
735 
 
736 
int main(int argc,char*argv[])
737 
{
738 
 
739 
 
740 
    int i ;
741 
       int addr_wdt,wd_no;
742 
    int max=0;
743 
   init1();
744 
 
745 
    if(argc==2)strcpy(fin,argv[1]);
746 
    else
747 
    {
748 
   //     printf("\nThe Synthetic PIC --- Intel HEX File to Altera memory file");
749 
   //     printf("\nUsage: hex2mif <infile>");
750 
  //      printf("\n");
751 
        getchar();
752 
        return 0 ;
753 
        printf("Input Hex file name:");
754 
        scanf("%s",fin);
755 
        printf("Input Mif file name:");
756 
        scanf("%s",mif_fn);
757 
    }
758 
 
759 
 
760 
 
761 
    /*  Open input HEX file */
762 
    fpi=fopen(argv[1],"r");
763 
    if(!fpi)
764 
    {
765 
        printf("\nCan't open input file %s.\n",argv[1]);
766 
        return 1 ;
767 
    }
768 
 
769 
    /*  Read in the HEX file */
770 
    /*  */
771 
    /*  !! Note, that things are a little strange for us, because the PIC is */
772 
    /*     a 12-bit instruction, addresses are 16-bit, and the hex format is */
773 
    /*     8-bit oriented!! */
774 
    /*  */
775 
    nMemoryCount=0 ;
776 
    while(!feof(fpi))
777 
    {
778 
        /*  Get one Intel HEX line */
779 
        fgets(szLine,80,fpi);
780 
        if(strlen(szLine)>=10)
781 
        {
782 
            /*  This is the PIC, with its 12-bit "words".  We're interested in these */
783 
            /*  words and not the bytes.  Read 4 hex digits at a time for each */
784 
            /*  address. */
785 
            /*  */
786 
            sscanf(&szLine[1],"%2x%4x",&ndata_bytes,&start_address);
787 
            if(start_address>=0&&start_address<=20000&&ndata_bytes>0)
788 
            {
789 
                /*  Suck up data bytes starting at 9th byte. */
790 
                i=9 ;
791 
 
792 
                /*  Words.. not bytes.. */
793 
                ndata_words=ndata_bytes/2 ;
794 
                start_address=start_address/2 ;
795 
 
796 
                /*  Spit out all the data that is supposed to be on this line. */
797 
                for(address=start_address;address<start_address+ndata_words;address++)
798 
                {
799 
                    /*  Scan out 4 hex digits for a word.  This will be one address. */
800 
                    sscanf(&szLine[i],"%04x",&data);
801 
 
802 
                    /*  Need to swap bytes... */
803 
                    data=((data>>8)&0x00ff)|((data<<8)&0xff00);
804 
                    i+=4 ;
805 
 
806 
                    /*  Store in our memory buffer */
807 
                    Memory[nMemoryCount].nAddress=address ;
808 
                    Memory[nMemoryCount].byData=data ;
809 
                    nMemoryCount++;
810 
                }
811 
            }
812 
        }
813 
    }
814 
    fclose(fpi);
815 
 
816 
    /*
817 
            for(i=0;;++i)
818 
            {
819 
                mif_fn[i]=fin[i];
820 
                if(mif_fn[i]=='.')
821 
                {
822 
                    mif_fn[i+1]='m' ;
823 
                    mif_fn[i+2]='i' ;
824 
                    mif_fn[3+i]='f' ;
825 
                    mif_fn[4+i]=0 ;
826 
                    break ;
827 
                }
828 
            }
829 
                                  */
830 
 
831 
    strcpy(mif_fn,"init_file.mif");
832 
 
833 
    fpi=fopen(mif_fn,"w");
834 
    if(NULL==fpi)return ;
835 
    /*  Now output the Verilog $readmemh format! */
836 
    /*  */
837 
 
838 
    /*  Now output the Verilog $readmemh format! */
839 
    /*  */
840 
    fprintf(fpi,"WIDTH=12;\nDEPTH=2048;\n\nADDRESS_RADIX=HEX;\nDATA_RADIX=HEX;\n\nCONTENT BEGIN\n");
841 
    printf("WIDTH=8;\nDEPTH=256;\n\nADDRESS_RADIX=HEX;\nDATA_RADIX=HEX;\n\nCONTENT BEGIN\n");
842 
    printf("Email:McuPro@163.com\n");
843 
 
844 
    for(i=0;i<nMemoryCount;i++)
845 
    {
846 
      //  printf("%X : %X;\n",Memory[i].nAddress,Memory[i].byData);
847 
        fprintf(fpi,"%4X : %4X;\n",Memory[i].nAddress,Memory[i].byData);
848 
    }
849 
 
850 
    fprintf(fpi,"\END;\n");
851 
    printf("\END;\n");
852 
    close(fpi);
853 
    /*output simulate verilog code */
854 
    /*
855 
            for(i=0;;++i)
856 
            {
857 
                mif_fn[i]=fin[i];
858 
                if(mif_fn[i]=='.')
859 
                {
860 
                    mif_fn[i+1]='v' ;
861 
                    mif_fn[i+2]=0 ;
862 
                    break ;
863 
                }
864 
            }
865 
                            */
866 
 
867 
    strcpy(mif_fn,"sim_rom.v");
868 
 
869 
    fpi=fopen(mif_fn,"w");
870 
    if(NULL==fpi)return ;
871 
    fprintf(fpi,"//This file was created by a tool wrietten with C.\n");
872 
    fprintf(fpi,"module sim_rom (\n");
873 
    fprintf(fpi,"    address,\n");
874 
    fprintf(fpi,"    clock,\n");
875 
    fprintf(fpi,"    q);\n");
876 
    fprintf(fpi,"    input    [10:0]  address;\n");
877 
    fprintf(fpi,"    input      clock;\n");
878 
    fprintf(fpi,"    output    [11:0]  q;\n");
879 
    fprintf(fpi,"    \n");
880 
    fprintf(fpi,"reg [10:0]    address_latched;\n");
881 
    fprintf(fpi,"// Instantiate the memory array itself.\n");
882 
    fprintf(fpi,"reg [11:0]    mem[0:2048-1];\n");
883 
    fprintf(fpi,"initial begin \n");
884 
    for(i=0;i<nMemoryCount;i++)
885 
    {
886 
    //    printf("mem[%05d] = s;\n",Memory[i].nAddress,Memory[i].ins);
887 
        fprintf(fpi,"mem[%04d] = 12'b%s;\n",Memory[i].nAddress,ins12tostr(Memory[i].byData));
888 
        }
889 
    fprintf(fpi,"end\n");
890 
    fprintf(fpi,"// Latch address\n");
891 
    fprintf(fpi,"always @(posedge clock)\n");
892 
    fprintf(fpi,"   address_latched <= address;\n");
893 
    fprintf(fpi,"   \n");
894 
    fprintf(fpi,"// READ\n");
895 
    fprintf(fpi,"assign q = mem[address_latched];\n");
896 
    fprintf(fpi,"\n");
897 
    fprintf(fpi,"endmodule\n");
898 
    fprintf(fpi,"\n");
899 
    fprintf(fpi,"/*\n");
900 
        for(i=0;i<nMemoryCount;i++)
901 
    {
902 
    //    printf("%04d:%s\n",Memory[i].nAddress,ins12tostr(Memory[i].byData));
903 
        //     sprintf(Memory[i].ins,"%s",ins12tostr(Memory[i].byData));
904 
        fprintf(fpi,"%04d: %s\n",Memory[i].nAddress,branch_ins(ins12tostr(Memory[i].byData)));
905 
        // fprintf(fpi,"mem[%d] = %d;\n",Memory[i].nAddress,Memory[i].byData);
906 
    }
907 
    fprintf(fpi,"*/\n/*\ncovered instructions:\n");
908 
 
909 
    for(i=0;i<=index;++i)
910 
    {
911 
        fprintf(fpi,"%s\n",ins_tsted[i]);
912 
    }
913 
        fprintf(fpi,"*/\n");
914 
    close(fpi);
915 
 
916 
 
917 
    strcpy(mif_fn,"tested_instructions.txt");
918 
     fpi=fopen(mif_fn,"w");
919 
        for(i=0;i<=index;++i)
920 
    {
921 
        fprintf(fpi,"%s\n",ins_tsted[i]);
922 
    }
923 
            close(fpi);
924 
 
925 
    fpi=fopen(mif_fn,"w");
926 
 
927 
 
928 
 
929 
    strcpy(mif_fn,"Dasm.txt");
930 
 
931 
    fpi=fopen(mif_fn,"w");
932 
    for(i=0;i<nMemoryCount;i++)
933 
    {
934 
    //   fprintf(fpi,"%04d:%s\n",Memory[i].nAddress,ins12tostr(Memory[i].byData));
935 
        //     sprintf(Memory[i].ins,"%s",ins12tostr(Memory[i].byData));
936 
        fprintf(fpi,"%04d : %s\n",Memory[i].nAddress,branch_ins(ins12tostr(Memory[i].byData)));
937 
        // fprintf(fpi,"mem[%d] = %d;\n",Memory[i].nAddress,Memory[i].byData);
938 
    }
939 
    close(fpi);
940 
    //   getchar();
941 
 
942 
 
943 
    strcpy(mif_fn,"alt_mem_set.h");
944 
 
945 
    fpi=fopen(mif_fn,"w");
946 
    for(i=0;i<nMemoryCount;i++)
947 
    {
948 
    if ((Memory[i].nAddress==2047)&&(Memory[i-1].nAddress!=2046))continue;
949 
    if ((Memory[i].nAddress==1023)&&(Memory[i-1].nAddress!=1022))continue;
950 
    if (Memory[i].nAddress>max) max=Memory[i].nAddress;
951 
    //   Memory[i].nAddressfprintf(fpi,"%04d:%s\n",Memory[i].nAddress,ins12tostr(Memory[i].byData));
952 
        //     sprintf(Memory[i].ins,"%s",ins12tostr(Memory[i].byData));
953 
        //fprintf(fpi,"%04d : %s\n",Memory[i].nAddress,branch_ins(ins12tostr(Memory[i].byData)));
954 
        // fprintf(fpi,"mem[%d] = %d;\n",Memory[i].nAddress,Memory[i].byData);
955 
       // fprintf(fpi,"mem[%d] = %d;\n",
956 
    }
957 
    addr_wdt = func1(max);
958 
      fprintf(fpi,"`define     ALT_MEM_WIDTHAD   %d\n",addr_wdt);
959 
      fprintf(fpi,"`define     ALT_MEM_NUMWORDS  %d\n",1<<addr_wdt);
960 
        fprintf(fpi,"`define      MIF_NAME  %s\n\n","init_file.mif");
961 
 
962 
    close(fpi);
963 
    //   getchar();
964 
}
965 
 

powered by: WebSVN 2.1.0

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