carl9170 firmware: fix [-Wpacked-not-aligned] warnings
[linux-libre-firmware.git] / as31 / as31 / emitter.c
1 /* ----------------------------------------------------------------------
2  * FILE: emitter.c
3  * PACKAGE: as31 - 8031/8051 Assembler.
4  *
5  * DESCRIPTION:
6  *      This file contains the code to generate various
7  *      object code formats. Provisions exist to
8  *      support many types of output formats within the
9  *      same executable.
10  *
11  * REVISION HISTORY:
12  *      Jan. 19, 1990 - Created. (Ken Stauffer)
13  *      Jan. 29, 1990 - Added S-records (Theo Deraadt)
14  *
15  *
16  * AUTHOR:
17  *      All code in this file written by Ken Stauffer (University of Calgary).
18  *      January, 1990.
19  */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23
24 #include "as31.h"
25
26 /* ----------------------------------------------------------------------
27  * DECLARE your own open(), close(), addr(), and byte() routines here.
28  *
29  */
30
31 static int open_tdr(const char *file, const char *ftype, const char *arg);
32 static void close_tdr(void);
33 static void addr_tdr(unsigned long a);
34 static void byte_tdr(unsigned char b);
35
36 static int open_byte(const char *file, const char *ftype, const char *arg);
37 static void close_byte(void);
38 static void addr_byte(unsigned long a);
39 static void byte_byte(unsigned char b);
40
41 static int open_od(const char *file, const char *ftype, const char *arg);
42 static void close_od(void);
43 static void addr_od(unsigned long a);
44 static void byte_od(unsigned char b);
45
46 static int open_srec(const char *file, const char *ftype, const char *arg);
47 static void close_srec(void);
48 static void addr_srec(unsigned long a);
49 static void byte_srec(unsigned char b);
50
51 static int open_hex(const char *file, const char *ftype, const char *arg);
52 static void close_hex(void);
53 static void addr_hex(unsigned long a);
54 static void byte_hex(unsigned char b);
55
56 static int open_bin(const char *file, const char *ftype, const char *arg);
57 static void close_bin(void);
58 static void addr_bin(unsigned long a);
59 static void byte_bin(unsigned char b);
60
61 /* ----------------------------------------------------------------------
62  * ADD an entry to this table to register your
63  * output format routines. Give your object format
64  * a name to be specified with the -F option.
65  *
66  */
67
68 static int format;
69
70 static struct {
71         char *name;
72         char *extension;
73         char *description;
74         int (*e_open)(const char *file, const char *ftype, const char *arg);
75         void (*e_close)(void);
76         void (*e_addr)(unsigned long a);
77         void (*e_byte)(unsigned char b);
78 } formtab[] = {
79         { "hex",   "hex",  "Intel-Hex (.hex)",  open_hex,  close_hex,  addr_hex,  byte_hex },
80         { "bin",   "bin",  "Binary (.bin)",  open_bin,  close_bin,  addr_bin,  byte_bin },
81         { "tdr",   "tdr",  "TDR Format (.tdr)", open_tdr,  close_tdr,  addr_tdr,  byte_tdr },
82         { "byte",  "byte", "BYTE list (.byte)",  open_byte, close_byte, addr_byte, byte_byte },
83         { "od",    "od",   "Octal Dump (.od)", open_od,   close_od,   addr_od,   byte_od },
84         { "srec2", "srec", "S Record, 16 bit Address (.srec)", open_srec, close_srec, addr_srec, byte_srec },
85         { "srec3", "srec", "S Record, 24 bit Address (.srec)", open_srec, close_srec, addr_srec, byte_srec },
86         { "srec4", "srec", "S Record, 32 bit Address (.srec)", open_srec, close_srec, addr_srec, byte_srec }
87 };
88
89 #define FORMTABSIZE     (sizeof(formtab)/sizeof(formtab[0]))
90
91 void emitusage(void)
92 {
93         int i;
94
95         fprintf(stderr, "[");
96         for(i=0; i<FORMTABSIZE; ) {
97                 fprintf(stderr, "%s", formtab[i].name);
98                 if( ++i < FORMTABSIZE)
99                         fprintf(stderr, "|");
100         }
101         fprintf(stderr, "]");
102 }
103
104 const char *emit_extension(const char *ftype)
105 {
106         int i;
107
108         if (ftype) {
109                 for(i=0; i<FORMTABSIZE; i++ ) {
110                         if (!strcmp(formtab[i].name, ftype))
111                                 return formtab[i].extension;
112                 }
113         }
114         return formtab[0].extension;
115 }
116
117
118 const char *emit_desc_lookup(int num)
119 {
120         if (num >= 0 && num < FORMTABSIZE)
121                 return formtab[num].description;
122         return NULL;
123 }
124
125 const char *emit_desc_to_name_lookup(const char *desc)
126 {
127         int i;
128
129         if (desc) {
130                 for(i=0; i<FORMTABSIZE; i++ ) {
131                         if (!strcmp(formtab[i].description, desc))
132                                 return formtab[i].name;
133                 }
134         }
135         return NULL;
136 }
137
138
139 int emitopen(const char *file, const char *ftype, const char *arg)
140 {
141         int i;
142         if( ftype ) {
143                 for(i=0; i<FORMTABSIZE; i++ ) {
144                         if( !strcmp(formtab[i].name,ftype) ) {
145                                 format = i;
146                                 return (*formtab[format].e_open)
147                                         (file,ftype,arg);
148                         }
149                 }
150                 mesg_f("no format \"%s\", using \"%s\"\n",
151                         ftype, formtab[0].name);
152         }
153         /*
154          * 0th entry is the default format type
155          */
156         format = 0;
157         return (*formtab[format].e_open)(file, ftype, arg);
158 }
159
160 void emitclose(void)
161 {
162         (*formtab[format].e_close)();
163 }
164
165 void emitaddr(unsigned long a)
166 {
167         (*formtab[format].e_addr)(a);
168 }
169
170 void emitbyte(int b)
171 {
172         (*formtab[format].e_byte)(b);
173 }
174
175 /* ----------------------------------------------------------------------
176  * Individual file format routines appear here:
177  *      Each file format must define the following routines:
178  *              open()  - Called ONCE before any of the others.
179  *                      It is passed with a filename and a format
180  *                      specific argument.
181  *
182  *              close() - Called ONCE when no more emit_byte()
183  *                      function calls will be made.
184  *
185  *              addr() - Called when ever a new address has been set
186  *                      in the assembler (ie. .org, .skip).
187  *                      This routine is also called once when the
188  *                      location counter is set to 0 at the very start of
189  *                      assembling.
190  * 
191  *              byte() - Called with each byte to be outputed.
192  *
193  */
194
195
196 static unsigned long addr;
197 static FILE *fout=NULL;
198 static long int offset;
199 static int newaddr;
200 static int pos=-666;
201 static unsigned char bytes[16];
202
203
204 /*-----------------------------------------------------------------------
205  * "hex" format.  Intel HEX format expected by many EPROM programmers
206  */
207
208
209 void hexdump(void)     /* dumps one line into file */
210 {
211         int i, sum;
212
213         if (fout == NULL) return;
214         fprintf(fout,":%02X%04lX00", pos, addr & 0xFFFF);
215         sum = pos + ((addr>>8)&0xff) + (addr&0xff) ;
216         for (i=0; i < pos; i++) {
217                 fprintf(fout,"%02X", bytes[i] & 0xFF );
218                 sum += bytes[i]&0xff;
219         }
220         fprintf(fout, "%02X\n", (-sum)&0xff);
221         addr += pos;
222         pos = 0;
223 }
224
225 static int open_hex(const char *file, const char *ftype, const char *arg)
226 {
227         if (file == NULL) fout = stdout;
228         else fout = fopen(file, "w");
229
230         if( fout == NULL ) {
231                 mesg_f("Cannot open %s for writing.\n", file);
232                 return -1;
233         }
234         pos = 0;
235         return 0;
236 }
237
238 static void close_hex(void)
239 {
240         if (fout == NULL) return;
241         if ( pos > 0 ) hexdump();
242         fprintf(fout, ":00000001FF\n");  /* end of file marker */
243         fclose(fout);
244 }
245
246 static void addr_hex(unsigned long a)
247 {
248         if ( pos > 0 ) hexdump();
249         addr = a;
250 }
251
252 static void byte_hex(unsigned char b)
253 {
254         bytes[pos] = b;
255         pos += 1;
256         if ( pos == 16) hexdump();
257 }
258
259
260 /*-----------------------------------------------------------------------
261  * "bin" format.  Raw binary data
262  */
263
264 static int open_bin(const char *file, const char *ftype, const char *arg)
265 {
266         if (file == NULL) fout = stdout;
267         else fout = fopen(file, "w");
268
269         if( fout == NULL ) {
270                 mesg_f("Cannot open %s for writing.\n", file);
271                 return -1;
272         }
273         addr = 0;
274         return 0;
275 }
276
277 static void close_bin(void)
278 {
279         if (fout == NULL) return;
280         fclose(fout);
281 }
282
283 static void addr_bin(unsigned long a)
284 {
285         long i;
286
287         if (fout == NULL) return;
288         if (a > addr) {
289                 for (i=0; i < a - addr; i++) {
290                         fprintf(fout, "%c", 0);
291                 }
292                 addr = a;
293                 return;
294         }
295         if (a < addr) {
296                 error("address changed to %lX, from %lX", a, addr);
297                 error("binary output format can't write backwards");
298                 addr = a;
299                 return;
300         }
301 }
302
303 static void byte_bin(unsigned char b)
304 {
305         if (fout == NULL) return;
306         fprintf(fout, "%c", b & 0xFF);
307         addr++;
308 }
309
310
311 /* ----------------------------------------------------------------------
312  * "tdr" format. For tdr's 68008 system. Generates a
313  * script file readable by a debugger.
314  *      [addr] : [byte] [byte] ..
315  *
316  * arg: This is a number in decimal which specifies
317  *      the offset, -Ftdr -A0000
318  *
319  *      These options specifies the tdr format, with an argument
320  *      of 0. This becomes the offset used in generating the
321  *      script file. The default if no A is present is 0x10000.
322  * 
323  */
324
325 static int open_tdr(const char *file, const char *ftype, const char *arg)
326 {
327         if (file == NULL) fout = stdout;
328         else fout = fopen(file,"w");
329
330         if( fout == NULL ) {
331                 mesg_f("Cannot open %s for writing.\n",file);
332                 return -1;
333         }
334         if (arg) {
335                 offset = atoi(arg);
336         } else {
337                 offset = 0x10000;
338         }
339         return 0;
340 }
341
342 static void close_tdr(void)
343 {
344         if (fout == NULL) return;
345         if( pos != 15 ) fprintf(fout,"\n");
346         fclose(fout);
347 }
348
349 static void addr_tdr(unsigned long a)
350 {
351         addr = a;
352         newaddr = 1;
353 }
354
355 static void byte_tdr(unsigned char b)
356 {
357         if (fout == NULL) return;
358         if( newaddr ) {
359                 if( pos != -666 ) fprintf(fout,"\n");
360                 newaddr = 0;
361                 pos = 15;
362                 fprintf(fout,"%06lx: ", (addr + offset) & 0xFFFFFF);
363         } else if( pos == 15 ) {
364                 fprintf(fout,"%06lx: ", (addr + offset) & 0xFFFFFF);
365         }
366
367         fprintf(fout,"%02x ", b & 0xFF );
368
369         if( pos-- == 0 ) {
370                 fprintf(fout, "\n");
371                 pos = 15;
372         }
373         addr += 1;
374 }
375
376
377 /* ----------------------------------------------------------------------
378  * "byte" format.
379  *      Like "tdr" but each byte is on a line by itself.
380  *      This is nice for debugging. No -A is used.
381  */
382
383 static int open_byte(const char *file, const char *ftype, const char *arg)
384 {
385         if (file == NULL) fout = stdout;
386         else fout = fopen(file,"w");
387
388         if( fout == NULL ) {
389                 mesg_f("Cannot open %s for writing.\n", file);
390                 return -1;
391         }
392         return 0;
393 }
394
395 static void close_byte(void)
396 {
397         if (fout == NULL) return;
398         fclose(fout);
399 }
400
401 static void addr_byte(unsigned long a)
402 {
403         addr = a;
404 }
405
406 static void byte_byte(unsigned char b)
407 {
408         if (fout == NULL) return;
409         fprintf(fout,"%04lX: %02X\n", addr & 0xFFFF, b & 0xFF );
410         addr += 1;
411 }
412
413
414 /* ----------------------------------------------------------------------
415  * "od", this format shows 16 bytes per line, with address.
416  *      It also includes ascii on one side.
417  *
418  * The format is similar to the od(1) program under Unix.
419  *
420  */
421
422 static int od_pos;
423 static unsigned char od_buf[16];
424 static unsigned long saveaddr;
425
426 void dumpline(unsigned long a, unsigned char *b, int len)
427 {
428         int i;
429
430         if (fout == NULL) return;
431         if(len <= 0 ) return;
432
433         fprintf(fout,"%04lx: ", a & 0xFFFF);
434
435         for(i=0; i<8; i++ ) {
436                 if( i <= len )
437                         fprintf(fout,"%02x ",b[i]);
438                 else
439                         fprintf(fout,"   ");
440         }
441
442         fprintf(fout,"- ");
443
444         for(i=8; i<16; i++ ) {
445                 if( i <= len )
446                         fprintf(fout,"%02x ",b[i]);
447                 else
448                         fprintf(fout,"   ");
449         }
450         fprintf(fout,"   ");
451
452         for(i=0; i<16; i++ ) {
453                 if( i <= len )
454                         fprintf(fout,"%c",
455                                 (b[i]>=' ' && b[i]<='~') ? b[i] : '.' );
456                 else
457                         break;
458         }
459         fprintf(fout,"\n");
460 }
461
462 static int open_od(const char *file, const char *ftype, const char *arg)
463 {
464         if (file == NULL) fout = stdout;
465         else fout = fopen(file,"w");
466
467         if( fout == NULL ) {
468                 mesg_f("Cannot open %s for writing.\n",file);
469                 return -1;
470         }
471         return 0;
472 }
473
474 static void close_od(void)
475 {
476         if (fout == NULL) return;
477         dumpline(saveaddr, od_buf, od_pos-1);
478         fclose(fout);
479 }
480
481 static void addr_od(unsigned long a)
482 {
483         newaddr = 1;
484         addr = a;
485 }
486
487 static void byte_od(unsigned char b)
488 {
489         if( newaddr ) {
490                 dumpline(saveaddr, od_buf, od_pos-1);
491                 od_pos = 0;
492                 newaddr = 0;
493                 saveaddr = addr;
494         } else if( od_pos == 16 ) {
495                 dumpline(saveaddr, od_buf, od_pos-1);
496                 od_pos = 0;
497                 saveaddr = addr;
498         }
499         od_buf[od_pos++] = b & 0x00ff;
500
501         addr += 1;
502 }
503
504
505 /* ----------------------------------------------------------------------
506  * srecord format. This is called with "-Fsrec2", "-Fsrec3", or
507  * "-Fsrec4"...
508  *
509  * arg: This is a number in decimal which specifies
510  *      the offset, -Fsrec3 -A0000
511  *
512  *      These options specifies the tdr format, with an argument
513  *      of 0. This becomes the offset used in generating the
514  *      script file. The default if no A is present is 0x0000.
515  * 
516  */
517
518 #define SREC_BYTESPERLINE 32
519
520 static int srec_format;
521 static int srec_check, srec_index;
522 static char srec_buf[SREC_BYTESPERLINE];
523 static long srec_address;
524
525 void srec_finishline(void)
526 {
527         int i;
528
529         if (fout == NULL) return;
530         srec_check = srec_index + (srec_address & 0xff) + ((srec_address>>8) & 0xff) + 4;
531
532         switch(srec_format) {
533         case 2:
534                 fprintf(fout, "S1%02X%04lX", srec_index + 4,
535                         srec_address & 0xFFFF);
536                 break;
537         case 3:
538                 fprintf(fout, "S2%02X%06lX", srec_index + 6,
539                         srec_address & 0xFFFFFF);
540                 srec_check += ((srec_address>>16) & 0xff) + 2;
541                 break;
542         case 4:
543                 fprintf(fout, "S3%02X%08lX", srec_index + 8, srec_address);
544                 srec_check += ((srec_address>>16) & 0xff) +
545                         ((srec_address>>24) & 0xff) + 4;
546                 break;
547         }
548
549         for(i=0; i<srec_index; i++) {
550                 fprintf(fout, "%02X", srec_buf[i] & 0xff);
551                 srec_check += srec_buf[i];
552         }
553
554         fprintf(fout, "%02X\n", (~srec_check & 0xff) );
555         srec_index = 0;
556 }
557
558 static int open_srec(const char *file, const char *ftype, const char *arg)
559 {
560         if (ftype == NULL) {
561                 mesg_f("No S Record Format\n");
562                 return -1;
563         }
564
565         if (sscanf(ftype, "srec%d", &srec_format) != 1) {
566                 mesg_f("Illegal S Record format \"%s\", must be \"srec2\", \"srec3\", or \"srec4\"\n", ftype);
567                 return -1;
568         }
569
570         if (srec_format < 2 || srec_format > 4) {
571                 mesg_f("Illegal S Record format %d %s (must be 2, 3, or 4)\n",
572                         srec_format, ftype);
573                 return -1;
574         }
575
576         if (file == NULL) fout = stdout;
577         else fout = fopen(file,"w");
578
579         if( fout == NULL ) {
580                 mesg_f("Cannot open %s for writing.\n",file);
581                 return -1;
582         }
583
584         if(arg) offset = atoi(arg);
585         else    offset = 0;
586
587         fprintf(fout, "S0030000%02X\n", (~3 & 0xff) );
588         return 0;
589 }
590
591 static void close_srec(void)
592 {
593         if (fout == NULL) return;
594         if(srec_index)
595                 srec_finishline();
596         switch(srec_format) {
597         case 2:
598                 fprintf(fout, "S9030000%02X\n", ~3 & 0xff);
599                 break;
600         case 3:
601                 fprintf(fout, "S804000000%02X\n", ~4 & 0xff);
602                 break;
603         case 4:
604                 fprintf(fout, "S70500000000%02X\n", ~5 & 0xff);
605                 break;
606         }
607         fclose(fout);
608 }
609
610 static void addr_srec(unsigned long a)
611 {
612         if(srec_index>0)
613                 srec_finishline();
614         srec_address = a + offset;
615 }
616
617 static void byte_srec(unsigned char b)
618 {
619         srec_buf[srec_index++] = b;
620         if(srec_index==SREC_BYTESPERLINE) {
621                 srec_finishline();
622                 srec_address += SREC_BYTESPERLINE;
623         }
624 }
625
626