Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:plunky:20120422210740

Diff

Diff from 1.24 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/arch/m16c/code.c

Annotated File View

plunky
1.24
1 /*      $Id: code.c,v 1.24 2012/04/22 21:07:40 plunky Exp $     */
pj
1.1
2 /*
3  * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29
30 # include "pass1.h"
31
32 /*
33  * cause the alignment to become a multiple of n
34  */
35 void
36 defalign(int n)
37 {
38 #if 0
39         char *s;
40
41         n /= SZCHAR;
42         if (lastloc == PROG || n == 1)
43                 return;
44         s = (isinlining ? permalloc(40) : tmpalloc(40));
45         sprintf(s".align %d"n);
46         send_passt(IP_ASMs);
47 #endif
48 }
49
50 /*
ragge
1.19
51  * define the current location as the name p->soname
pj
1.1
52  */
53 void
54 defnam(struct symtab *p)
55 {
ragge
1.19
56         char *c = p->soname;
pj
1.1
57
58         if (p->sclass == EXTDEF)
ragge
1.2
59                 printf("        PUBLIC %s\n"c);
pj
1.1
60         printf("%s:\n"c);
61 }
62
63
64 /*
65  * code for the end of a function
66  * deals with struct return here
67  */
68 void
plunky
1.24
69 efcode(void)
pj
1.1
70 {
71         NODE *p, *q;
72         int sz;
73
74         if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
75                 return;
76         /* address of return struct is in eax */
77         /* create a call to memcpy() */
78         /* will get the result in eax */
ragge
1.21
79         p = block(REGNILNILCHAR+PTR00);
pj
1.1
80         p->n_rval = R0;
ragge
1.21
81         q = block(OREGNILNILCHAR+PTR00);
pj
1.1
82         q->n_rval = FB;
83         q->n_lval = 8/* return buffer offset */
ragge
1.21
84         p = block(CMqpINT00);
pj
1.1
85         sz = (tsize(STRTYcftnsp->sdfcftnsp->ssue)+SZCHAR-1)/SZCHAR;
ragge
1.21
86         p = block(CMpbcon(sz), INT00);
pj
1.1
87         p->n_right->n_name = "";
ragge
1.21
88         p = block(CALLbcon(0), pCHAR+PTR00);
pj
1.1
89         p->n_left->n_name = "memcpy";
90         send_passt(IP_NODEp);
91 }
92
93 /*
ragge
1.6
94  * helper for bfcode() to put register arguments on stack.
95  */
96 static void
97 argmove(struct symtab *sint regno)
98 {
99         NODE *p, *r;
100
101         s->sclass = AUTO;
102         s->soffset = NOOFFSET;
103         oalloc(s, &autooff);
ragge
1.20
104         p = nametree(s);
ragge
1.6
105         r = bcon(0);
106         r->n_op = REG;
107         r->n_rval = regno;
ragge
1.9
108         r->n_type = p->n_type;
109         r->n_sue = p->n_sue;
110         r->n_df = p->n_df;
ragge
1.6
111         ecode(buildtree(ASSIGNpr));
112 }
113
114 /*
pj
1.1
115  * code for the beginning of a function; a is an array of
116  * indices in symtab for the arguments; n is the number
ragge
1.4
117  * On m16k, space is allocated on stack for register arguments,
118  * arguments are moved to the stack and symtab is updated accordingly.
pj
1.1
119  */
120 void
121 bfcode(struct symtab **aint n)
122 {
ragge
1.4
123         struct symtab *s;
ragge
1.6
124         int ir0lr0ha0r2szhaschstk;
125         int argoff = ARGINIT;
pj
1.1
126
ragge
1.3
127         if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
128                 /* Function returns struct, adjust arg offset */
129                 for (i = 0i < ni++)
ragge
1.8
130                         a[i]->soffset += SZPOINT(INT);
ragge
1.3
131         }
ragge
1.5
132         /* first check if there are 1-byte parameters */
133         for (hasch = i = 0i < n && i < 6i++)
134                 if (DEUNSIGN(a[i]->stype) == CHAR)
135                         hasch = 1;
136
ragge
1.6
137         stk = r0l = r0h = a0 = r2 = 0;
ragge
1.4
138         for (i = 0i < ni++) {
139                 s = a[i];
140                 sz = tsize(s->stypes->sdfs->ssue);
ragge
1.13
141                 if (ISPTR(s->stype) && ISFTN(DECREF(s->stype)))
142                         sz = SZLONG/* function pointers are always 32 */
ragge
1.6
143                 if (stk == 0)
144                     switch (sz) {
ragge
1.4
145                 case SZCHAR:
146                         if (r0l) {
147                                 if (r0h)
ragge
1.6
148                                         break;
149                                 argmove(s1);
ragge
1.4
150                                 r0h = 1;
151                         } else {
ragge
1.6
152                                 argmove(s0);
ragge
1.4
153                                 r0l = 1;
154                         }
155                         continue;
156
157                 case SZINT:
ragge
1.5
158                         if (s->stype > BTMASK) {
159                                 /* is a pointer */
160                                 if (a0) {
161                                         if (r0l || hasch) {
162                                                 if (r2)
ragge
1.6
163                                                         break;
164                                                 argmove(sR2);
ragge
1.5
165                                                 r2 = 1;
ragge
1.6
166                                         } else {
167                                                 argmove(sR0);
168                                                 r0l = r0h = 1;
ragge
1.5
169                                         }
ragge
1.6
170                                 } else {
171                                         argmove(sA0);
172                                         a0 = 1;
ragge
1.5
173                                 }
ragge
1.6
174                         } else if (r0l || hasch) {
ragge
1.5
175                                 if (r2) {
176                                         if (a0)
ragge
1.6
177                                                 break;
178                                         argmove(sA0);
ragge
1.5
179                                         a0 = 1;
ragge
1.6
180                                 } else {
181                                         argmove(sR2);
182                                         r2 = 1;
ragge
1.5
183                                 }
ragge
1.6
184                         } else {
185                                 argmove(sR0);
186                                 r0l = r0h = 1;
ragge
1.5
187                         }
ragge
1.4
188                         continue;
189                 case SZLONG:
190                         if (r0l||r0h||r2)
ragge
1.6
191                                 break;
192                         argmove(sR0);
ragge
1.4
193                         r0l = r0h = r2 = 1;
194                         continue;
ragge
1.5
195
196                 default:
ragge
1.6
197                         break;
ragge
1.4
198                 }
ragge
1.6
199                 stk = 1;
200                 s->soffset = argoff;
201                 argoff += sz;
ragge
1.4
202         }
pj
1.1
203 }
204
ragge
1.11
205 /*
206  * Add a symbol to an internal list printed out at the end.
207  */
208 void addsym(struct symtab *);
209 static struct symlst {
210         struct symlst *next;
211         struct symtab *sp;
212 } *sympole;
213
214 void
215 addsym(struct symtab *q)
216 {
217         struct symlst *w = sympole;
218
pj
1.12
219         if (q == NULL)
220                 return;
221
ragge
1.11
222         while (w) {
223                 if (q == w->sp)
224                         return/* exists */
225                 w = w->next;
226         }
227         w = permalloc(sizeof(struct symlst));
228         w->sp = q;
229         w->next = sympole;
230         sympole = w;
231 }
pj
1.1
232
ragge
1.2
233 struct caps {
234         char *cap, *stat;
235 caps[] = {
236         { "__64bit_doubles""Disabled" },
237         { "__calling_convention""Normal" },
238         { "__constant_data""near" },
239         { "__data_alignment""2" },
240         { "__data_model""near" },
241         { "__processor""M16C" },
242         { "__rt_version""1" },
243         { "__variable_data""near" },
244         { NULLNULL },
245 };
plunky
1.24
246
ragge
1.2
247 /*
248  * Called before parsing begins.
249  */
250 void
plunky
1.24
251 bjobcode(void)
ragge
1.2
252 {
253         struct caps *c;
254
255         printf("        NAME gurka.c\n"); /* Don't have the name */
256         for (c = capsc->capc++)
257                 printf("        RTMODEL \"%s\", \"%s\"\n"c->capc->stat);
janeno-1
1.15
258         //printf("      RSEG CODE:CODE:REORDER:NOROOT(0)\n");
ragge
1.2
259 }
260
pj
1.1
261 /* called just before final exit */
262 /* flag is 1 if errors, 0 if none */
263 void
plunky
1.24
264 ejobcode(int flag)
pj
1.1
265 {
ragge
1.11
266         struct symlst *w = sympole;
267
268         for (w = sympoleww = w->next) {
269                 if (w->sp->sclass != EXTERN)
270                         continue;
ragge
1.19
271                 printf("        EXTERN %s\n"w->sp->soname);
ragge
1.11
272         }
273         
ragge
1.2
274         printf("        END\n");
pj
1.1
275 }
276
277 /*
278  * Print character t at position i in one string, until t == -1.
279  * Locctr & label is already defined.
280  */
281 void
282 bycode(int tint i)
283 {
284         static  int     lastoctal = 0;
285
286         /* put byte i+1 in a string */
287
288         if (t < 0) {
289                 if (i != 0)
290                         puts("\"");
291         } else {
292                 if (i == 0)
293                         printf("\t.ascii \"");
294                 if (t == '\\' || t == '"') {
295                         lastoctal = 0;
296                         putchar('\\');
297                         putchar(t);
298                 } else if (t < 040 || t >= 0177) {
299                         lastoctal++;
300                         printf("\\%o",t);
301                 } else if (lastoctal && '0' <= t && t <= '9') {
302                         lastoctal = 0;
303                         printf("\"\n\t.ascii \"%c"t);
304                 } else {        
305                         lastoctal = 0;
306                         putchar(t);
307                 }
308         }
309 }
310
311 /* fix up type of field p */
312 void
313 fldty(struct symtab *p)
314 {
315 }
316
stefan
1.17
317 /*
pj
1.1
318  * XXX - fix genswitch.
319  */
stefan
1.17
320 int
321 mygenswitch(int numTWORD typestruct swents **pint n)
pj
1.1
322 {
stefan
1.17
323         return 0;
pj
1.1
324 }
ragge
1.16
325 /*
326  * Called with a function call with arguments as argument.
327  * This is done early in buildtree() and only done once.
328  */
329 NODE *
330 funcode(NODE *p)
331 {
332         return p;
333 }
FishEye: Open Source License registered to PCC.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-29 08:25 +0100