Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20090114211146

Diff

Diff from 1.3 to:

Annotations

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

Annotated File View

ragge
1.3
1 /*      $Id: code.c,v 1.3 2009/01/14 21:11:46 ragge Exp $       */
mickey
1.1
2 /*
3  * Copyright (c) 2008 Michael Shalayeff
4  * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. The name of the author may not be used to endorse or promote products
16  *    derived from this software without specific prior written permission
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30
31 # include "pass1.h"
32
33 NODE *funarg(NODE *, int *);
34 int argreg(TWORDint *);
35
36 int lastloc = -1;
37
38 /*
39  * Define everything needed to print out some data (or text).
40  * This means segment, alignment, visibility, etc.
41  */
42 void
43 defloc(struct symtab *sp)
44 {
45         extern char *nextsect;
46         static char *loctbl[] = { "text""data""section .rodata" };
47         TWORD t;
48         int s;
49
50         if (sp == NULL) {
51                 lastloc = -1;
52                 return;
53         }
54         t = sp->stype;
55         s = ISFTN(t) ? PROG : ISCON(cqual(tsp->squal)) ? RDATA : DATA;
56 #ifdef TLS
57         if (sp->sflags & STLS) {
58                 if (s != DATA)
59                         cerror("non-data symbol in tls section");
60                 nextsect = ".tdata";
61         }
62 #endif
63         if (nextsect) {
64                 printf("        .section %s\n"nextsect);
65                 nextsect = NULL;
66                 s = -1;
67         } else if (s != lastloc)
68                 printf("        .%s\n"loctbl[s]);
69         lastloc = s;
70         while (ISARY(t))
71                 t = DECREF(t);
ragge
1.3
72         s = ISFTN(t) ? ALINT : talign(tsp->ssue);
73         if (s > ALCHAR)
74                 printf("        .align %d\n"s/ALCHAR);
mickey
1.1
75         if (sp->sclass == EXTDEF)
76                 printf("        .globl %s\n"exname(sp->soname));
77         if (ISFTN(t))
78                 printf("\t.type %s,@function\n"exname(sp->soname));
79         if (sp->slevel == 0)
80                 printf("%s:\n"exname(sp->soname));
81         else
82                 printf(LABFMT ":\n"sp->soffset);
83 }
84
85 /*
86  * code for the end of a function
87  * deals with struct return here
88  */
89 void
90 efcode()
91 {
92         extern int gotnr;
93         NODE *p, *q;
94
95         gotnr = 0;      /* new number for next fun */
96         if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
97                 return;
98         /* Create struct assignment */
99         q = block(OREGNILNILPTR+STRTY0cftnsp->ssue);
100         q->n_rval = EBP;
101         q->n_lval = 8/* return buffer offset */
102         q = buildtree(UMULqNIL);
103         p = block(REGNILNILPTR+STRTY0cftnsp->ssue);
104         p = buildtree(UMULpNIL);
105         p = buildtree(ASSIGNqp);
106         ecomp(p);
107 }
108
109 /*
110  * code for the beginning of a function; a is an array of
111  * indices in symtab for the arguments; n is the number
112  */
113 void
114 bfcode(struct symtab **aint cnt)
115 {
116         struct symtab *sp2;
117         extern int gotnr;
118         NODE *n, *p;
119         int i;
120
121         if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
122                 /* Function returns struct, adjust arg offset */
123                 for (i = 0i < cnti++) 
124                         sp[i]->soffset += SZPOINT(LONG);
125         }
126
127         if (kflag) {
128                 /* Put ebx in temporary */
129                 n = block(REGNILNILINT0MKSUE(INT));
130                 n->n_rval = EBX;
131                 p = tempnode(0INT0MKSUE(INT));
132                 gotnr = regno(p);
133                 ecomp(buildtree(ASSIGNpn));
134         }
135
136         /* recalculate the arg offset and create TEMP moves */
137         for (n = 0i = 0i < cnti++) {
138                 sp = a[i];
139
140                 if (n < 6) {
141                         p = tempnode(0sp->stypesp->sdfsp->ssue);
142                         q = block(REGNILNILsp->stypesp->sdfsp->ssue);
143                         q->n_rval = argreg(sp->stype, &n);
144                         p = buildtree(ASSIGNpq);
145                         sp->soffset = regno(p->n_left);
146                         sp->sflags |= STNODE;
147                         ecomp(p);
148                 } else {
149                         sp->soffset += SZLONG * n;
150                         if (xtemps) {
151                                 /* put stack args in temps if optimizing */
152                                 p = tempnode(0sp->stypesp->sdfsp->ssue);
153                                 p = buildtree(ASSIGNpbuildtree(NAME00));
154                                 sp->soffset = regno(p->n_left);
155                                 sp->sflags |= STNODE;
156                                 ecomp(p);
157                         }
158                 }
159         }
160 }
161
162
163 /*
164  * by now, the automatics and register variables are allocated
165  */
166 void
167 bccode()
168 {
169         SETOFF(autooffSZINT);
170 }
171
172 /* called just before final exit */
173 /* flag is 1 if errors, 0 if none */
174 void
175 ejobcode(int flag )
176 {
177         if (errors)
178                 return;
179
180 #define _MKSTR(x) #x
181 #define MKSTR(x) _MKSTR(x)
182 #define OS MKSTR(TARGOS)
183         printf("\t.ident \"PCC: %s (%s)\"\n\t.end\n"PACKAGE_STRINGOS);
184 }
185
186 void
187 bjobcode()
188 {
189 }
190
191 static const int argregsi[] = { RDIRSIRDXRCXR09R08 };
192
193 int
194 argreg(TWORD tint *n)   
195 {
196         switch (t) {
197         case FLOAT:
198         case DOUBLE:
199         case LDOUBLE:
200                 return FR6 - *n - 2;
201         case LONGLONG:
202         case ULONGLONG:
203                 /* TODO */;
204         default:
205                 return argregsi[(*n)++];
206         }
207 }
208
209 NODE *
210 funarg(NODE *pint *n)
211 {
212         NODE *r;
213         int sz;
214
215         if (p->n_op == CM) {
216                 p->n_left = funarg(p->n_leftn);
217                 p->n_right = funarg(p->n_rightn);
218                 return p;
219         }
220
221         if (*n >= 6) {
222                 *n++;
223                 r = block(OREGNILNILp->n_type|PTR0,
224                     MKSUE(p->n_type|PTR));
225                 r->n_rval = RBP;
226                 r->n_lval = 16 + (*n - 6) * 8;
227         } else {
228                 r = block(REGNILNILp->n_type00);
229                 r->n_lval = 0;
230                 r->n_rval = argreg(p->n_typen);
231         }
232         p = block(ASSIGNrpp->n_type00);
233         clocal(p);
234
235         return p;
236 }  
237
238 /*
239  * Called with a function call with arguments as argument.
240  * This is done early in buildtree() and only done once.
241  * Returns p.
242  */
243 NODE *
244 funcode(NODE *p)
245 {
246         extern int gotnr;
247         NODE *r, *l;
248         int n = 0;
249
250         p->n_right = funarg(p->n_right, &n);
251
252         if (kflag == 0)
253                 return p;
254         /* Create an ASSIGN node for ebx */
255         l = block(REGNILNILINT0MKSUE(INT));
256         l->n_rval = EBX;
257         l = buildtree(ASSIGNltempnode(gotnrINT0MKSUE(INT)));
258         if (p->n_right->n_op != CM) {
259                 p->n_right = block(CMlp->n_rightINT0MKSUE(INT));
260         } else {
261                 for (r = p->n_rightr->n_left->n_op == CMr = r->n_left)
262                         ;
263                 r->n_left = block(CMlr->n_leftINT0MKSUE(INT));
264         }
265         return p;
266 }
267
268 /*
269  * return the alignment of field of type t
270  */
271 int
272 fldal(unsigned int t)
273 {
274         uerror("illegal field type");
275         return(ALINT);
276 }
277
278 /* fix up type of field p */
279 void
280 fldty(struct symtab *p)
281 {
282 }
283
284 /*
285  * XXX - fix genswitch.
286  */
287 int
288 mygenswitch(int numTWORD typestruct swents **pint n)
289 {
290         return 0;
291 }
FishEye: Open Source License registered to PCC.
Your maintenance has expired. You can renew your license at http://www.atlassian.com/fisheye/renew
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-09-16 21:31 +0200