* src/SDCCmain.c (linkEdit),
[fw/sdcc] / as / hc08 / lkmem.c
1 /*-------------------------------------------------------------------------
2   lkmem.c - Create a memory summary file with extension .mem
3
4    Written By -  Jesus Calvino-Fraga, jesusc@ieee.org (2002)
5
6    This program is free software; you can redistribute it and/or modify it
7    under the terms of the GNU General Public License as published by the
8    Free Software Foundation; either version 2, or (at your option) any
9    later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 -------------------------------------------------------------------------*/
20
21 #include <stdio.h>
22 #include <string.h>
23 #include <stdlib.h>
24 #include "aslink.h"
25 #include "strcmpi.h"
26
27 int summary(struct area * areap) 
28 {
29         #define EQ(A,B) !as_strcmpi((A),(B))
30         #define MIN_STACK 16
31         #define REPORT_ERROR(A, H) \
32         {\
33                 fprintf(of, "%s%s", (H)?"*** ERROR: ":"", (A)); \
34                 fprintf(stderr, "%s%s", (H)?"\n?ASlink-Error-":"",(A)); \
35                 toreturn=1; \
36         }
37
38         #define REPORT_WARNING(A, H) \
39         { \
40                 fprintf(of, "%s%s", (H)?"*** WARNING: ":"", (A)); \
41                 fprintf(stderr, "%s%s",(H)?"\n?ASlink-Warning-":"", (A)); \
42         }
43
44         char buff[128];
45         int j, toreturn=0;
46         unsigned int Total_Last=0, k; 
47
48         struct area * xp;
49         FILE * of;
50         
51         /*Artifacts used for printing*/
52         char start[15], end[15], size[15], max[15];
53         char format[]="   %-16.16s %-8.8s %-8.8s %-8.8s %-8.8s\n";
54         char line[]="---------------------";
55
56         typedef struct
57         {
58                 unsigned long Start;
59                 unsigned long Size;
60                 unsigned long Max;
61                 char Name[NCPS];
62                 unsigned long flag;
63         } _Mem;
64
65         unsigned int dram[0x100];
66         _Mem Ram[]={
67                 {0,     0,      0,       "REG_BANK_0", 0x0001},
68                 {0x0,   0,      0,       "REG_BANK_1", 0x0002},
69                 {0x0,   0,      0,       "REG_BANK_2", 0x0004},
70                 {0x0,   0,      0,       "REG_BANK_3", 0x0008},
71                 {0x0,   0,      0,       "BSEG_BYTES", 0x0010},
72                 {0,     0,      256,    "UNUSED",     0x0000},
73                 {0xff,  0,      256,    "DATA",       0x0020},
74                 {0,             0,      256, "TOTAL:",     0x0000}
75         };
76         
77         _Mem IRam= {0xff,   0,     0, "INDIRECT RAM",           0x0080};
78         _Mem Stack={0xff,   0,     1, "STACK",                          0x0000};
79         _Mem XRam= {0xffff, 0, 65536, "EXTERNAL RAM",           0x0100};
80         _Mem Rom=  {0xffff, 0, 65536, "ROM/EPROM/FLASH",        0x0200};
81         
82 #if 0
83         if(rflag) /*For the DS390*/
84         {
85                 XRam.Max=0x1000000; /*24 bits*/
86                 XRam.Start=0xffffff;
87                 Rom.Max=0x1000000;
88                 Rom.Start=0xffffff;
89         }
90
91         if((iram_size<=0)||(iram_size>0x100)) /*Default: 8052 like memory*/
92         {
93                 Ram[5].Max=0x80;
94                 Ram[6].Max=0x80;
95                 Ram[7].Max=0x80;
96                 IRam.Max=0x80;
97                 iram_size=0x100;
98         }
99         else if(iram_size<0x80)
100         {
101                 Ram[5].Max=iram_size;
102                 Ram[6].Max=iram_size;
103                 Ram[7].Max=iram_size;
104                 IRam.Max=0;
105         }
106         else
107         {
108                 Ram[5].Max=0x80;
109                 Ram[6].Max=0x80;
110                 Ram[7].Max=0x80;
111                 IRam.Max=iram_size-0x80;
112         }
113 #endif
114
115         for(j=0; j<(int)iram_size; j++) dram[j]=0;
116         for(; j<0x100; j++) dram[j]=0x8000; /*Memory not available*/
117
118         /* Open Memory Summary File*/
119         of = afile(linkp->f_idp, "mem", 1);
120         if (of == NULL)
121         {
122                 lkexit(1);
123         }
124
125         xp=areap;
126         while (xp)
127         {
128                 /**/ if (EQ(xp->a_id, "REG_BANK_0"))
129                 {
130                         Ram[0].Size=xp->a_size;
131                 }
132                 else if (EQ(xp->a_id, "REG_BANK_1"))
133                 {
134                         Ram[1].Size=xp->a_size;
135                 }
136                 else if (EQ(xp->a_id, "REG_BANK_2"))
137                 {
138                         Ram[2].Size=xp->a_size;
139                 }
140                 else if (EQ(xp->a_id, "REG_BANK_3"))
141                 {
142                         Ram[3].Size=xp->a_size;
143                 }
144                 else if (EQ(xp->a_id, "BSEG_BYTES"))
145                 {
146                         Ram[4].Size=xp->a_size;
147                 }
148                 else if ( EQ(xp->a_id, "DSEG") || EQ(xp->a_id, "OSEG") )
149                 {
150                         Ram[6].Size+=xp->a_size;
151                         if(xp->a_addr<Ram[6].Start) Ram[6].Start=xp->a_addr;
152                 }
153
154                 else if( EQ(xp->a_id, "CSEG") || EQ(xp->a_id, "GSINIT") ||
155                                  EQ(xp->a_id, "GSFINAL") || EQ(xp->a_id, "HOME") )
156                 {
157                         Rom.Size+=xp->a_size;
158                         if(xp->a_addr<Rom.Start) Rom.Start=xp->a_addr;
159                 }
160                 
161                 else if (EQ(xp->a_id, "SSEG"))
162                 {
163                         Stack.Size+=xp->a_size;
164                         if(xp->a_addr<Stack.Start) Stack.Start=xp->a_addr;
165                 }
166
167                 else if (EQ(xp->a_id, "XSEG") || EQ(xp->a_id, "XISEG")) 
168                 {
169                         XRam.Size+=xp->a_size;
170                         if(xp->a_addr<XRam.Start) XRam.Start=xp->a_addr;
171                 }
172
173                 else if (EQ(xp->a_id, "ISEG"))
174                 {
175                         IRam.Size+=xp->a_size;
176                         if(xp->a_addr<IRam.Start) IRam.Start=xp->a_addr;
177                 }
178                 xp=xp->a_ap;
179         }
180
181         for(j=0; j<7; j++)
182                 for(k=Ram[j].Start; (k<(Ram[j].Start+Ram[j].Size))&&(k<0x100); k++)
183                         dram[k]|=Ram[j].flag; /*Mark as used*/
184         
185 #if 0
186         for(k=IRam.Start; (k<(IRam.Start+IRam.Size))&&(k<0x100); k++)
187                 dram[k]|=IRam.flag; /*Mark as used*/
188 #endif
189
190         /*Compute the amount of unused memory in direct data Ram.  This is the
191         gap between the last register bank or bit segment and the data segment.*/
192         for(k=Ram[6].Start-1; (dram[k]==0) && (k>0); k--);
193         Ram[5].Start=k+1;
194         Ram[5].Size=Ram[6].Start-Ram[5].Start; /*It may be zero (which is good!)*/
195
196         /*Compute the data Ram totals*/
197         for(j=0; j<7; j++)
198         {
199                 if(Ram[7].Start>Ram[j].Start) Ram[7].Start=Ram[j].Start;
200                 Ram[7].Size+=Ram[j].Size;
201         }
202         Total_Last=Ram[6].Size+Ram[6].Start-1;
203
204         /*Report the Ram totals*/
205         fprintf(of, "Direct Internal RAM:\n");
206         fprintf(of, format, "Name", "Start", "End", "Size", "Max");
207
208         for(j=0; j<8; j++)
209         {
210                 if((j==0) || (j==7)) fprintf(of, format, line, line, line, line, line);
211                 if((j!=5) || (Ram[j].Size>0))
212                 {
213                         sprintf(start, "0x%02lx", Ram[j].Start);
214                         if(Ram[j].Size==0)
215                                 end[0]=0;/*Empty string*/
216                         else
217                                 sprintf(end,  "0x%02lx", j==7?Total_Last:Ram[j].Size+Ram[j].Start-1);
218                         sprintf(size, "%5lu", Ram[j].Size);
219                         sprintf(max, "%5lu", Ram[j].Max);
220                         fprintf(of, format, Ram[j].Name, start, end, size, max);
221                 }
222         }
223
224 #if 0
225         for(k=Ram[6].Start; (k<(Ram[6].Start+Ram[6].Size))&&(k<0x100); k++)
226         {
227                 if(dram[k]!=Ram[6].flag)
228                 {
229                         sprintf(buff, "Internal memory overlap starting at 0x%02x.\n", k);
230                         REPORT_ERROR(buff, 1);
231                         break;
232                 }
233         }
234
235  
236         if(Ram[4].Size>Ram[4].Max)
237         {
238                 k=Ram[4].Size-Ram[4].Max;
239                 sprintf(buff, "Insufficient bit addressable memory.  "
240                                         "%d byte%s short.\n", k, (k==1)?"":"s");
241                 REPORT_ERROR(buff, 1);
242         }
243
244         if(Ram[5].Size!=0)
245         {
246                 sprintf(buff, "%ld bytes in data memory wasted.  "
247                             "SDCC link could use: --data-loc 0x%02lx\n",
248                                         Ram[5].Size, Ram[6].Start-Ram[5].Size);
249                 REPORT_WARNING(buff, 1);
250         }
251
252         if((Ram[6].Start+Ram[6].Size)>Ram[6].Max)
253         {
254                 k=(Ram[6].Start+Ram[6].Size)-Ram[6].Max;
255                 sprintf(buff, "Insufficient space in data memory.   "
256                                         "%d byte%s short.\n", k, (k==1)?"":"s");
257                 REPORT_ERROR(buff, 1);
258         }
259 #endif
260         /*Report the position of the begining of the stack*/
261         fprintf(of, "\n%stack starts at: 0x%02lx (sp set to 0x%02lx)",
262                 rflag ? "16 bit mode initial s" : "S", Stack.Start, Stack.Start-1);
263
264 #if 0
265         /*Check that the stack pointer is landing in a safe place:*/
266         if( (dram[Stack.Start] & 0x8000) == 0x8000 )
267         {
268                 fprintf(of, ".\n");
269                 sprintf(buff, "Stack set to unavailable memory.\n");
270                 REPORT_ERROR(buff, 1);
271         }
272         else if(dram[Stack.Start])
273         {
274                 fprintf(of, ".\n");
275                 sprintf(buff, "Stack overlaps area ");
276                 REPORT_ERROR(buff, 1);
277                 for(j=0; j<7; j++)
278                 {
279                         if(dram[Stack.Start]&Ram[j].flag)
280                         {
281                                 sprintf(buff, "'%s'\n", Ram[j].Name);
282                                 break;
283                         }
284                 }
285                 if(dram[Stack.Start]&IRam.flag)
286                 {
287                         sprintf(buff, "'%s'\n", IRam.Name);
288                 }
289                 REPORT_ERROR(buff, 0);
290         }
291         else
292         {
293                 for(j=Stack.Start, k=0; (j<(int)iram_size)&&(dram[j]==0); j++, k++);
294                 fprintf(of, " with %d bytes available\n", k);
295                 if (k<MIN_STACK)
296                 {
297                         sprintf(buff, "Only %d byte%s available for stack.\n",
298                                 k, (k==1)?"":"s");
299                         REPORT_WARNING(buff, 1);
300                 }
301         }
302 #endif
303
304         fprintf(of, "\nOther memory:\n");
305         fprintf(of, format, "Name", "Start", "End", "Size", "Max");
306         fprintf(of, format, line, line, line, line, line);
307
308         /*Report IRam totals:*/
309         sprintf(start, "0x%02lx", IRam.Start);
310         if(IRam.Size==0)
311                 end[0]=0;/*Empty string*/
312         else
313                 sprintf(end,  "0x%02lx", IRam.Size+IRam.Start-1);
314         sprintf(size, "%5lu", IRam.Size);
315         sprintf(max, "%5lu", IRam.Max);
316         fprintf(of, format, IRam.Name, start, end, size, max);
317
318         /*Report XRam totals:*/
319         sprintf(start, "0x%04lx", XRam.Start);
320         if(XRam.Size==0)
321                 end[0]=0;/*Empty string*/
322         else
323                 sprintf(end,  "0x%04lx", XRam.Size+XRam.Start-1);
324         sprintf(size, "%5lu", XRam.Size);
325         sprintf(max, "%5lu", xram_size<0?XRam.Max:xram_size);
326         fprintf(of, format, XRam.Name, start, end, size, max);
327
328         /*Report Rom/Flash totals:*/
329         sprintf(start, "0x%04lx", Rom.Start);
330         if(Rom.Size==0)
331                 end[0]=0;/*Empty string*/
332         else
333                 sprintf(end,  "0x%04lx", Rom.Size+Rom.Start-1);
334         sprintf(size, "%5lu", Rom.Size);
335         sprintf(max, "%5lu", code_size<0?Rom.Max:code_size);
336         fprintf(of, format, Rom.Name, start, end, size, max);
337
338         /*Report any excess:*/
339 #if 0
340         if((IRam.Start+IRam.Size)>(IRam.Max+0x80))
341         {
342                 sprintf(buff, "Insufficient INDIRECT RAM memory.\n");
343                 REPORT_ERROR(buff, 1);
344         }
345 #endif
346         if( ((XRam.Start+XRam.Size)>XRam.Max) ||
347                 (((int)XRam.Size>xram_size)&&(xram_size>=0)) )
348         {
349                 sprintf(buff, "Insufficient EXTERNAL RAM memory.\n");
350                 REPORT_ERROR(buff, 1);
351         }
352         if( ((Rom.Start+Rom.Size)>Rom.Max) ||
353                 (((int)Rom.Size>code_size)&&(code_size>=0)) )
354         {
355                 sprintf(buff, "Insufficient ROM/EPROM/FLASH memory.\n");
356                 REPORT_ERROR(buff, 1);
357         }
358
359         fclose(of);
360         return toreturn;                
361 }