Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:plunky:20110605085442

Diff

Diff from 1.26 to:

Annotations

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

Annotated File View

plunky
1.26
1 /*      $Id: code.c,v 1.26 2011/06/05 08:54:42 plunky Exp $     */
mickey
1.7
2 /*      $OpenBSD: code.c,v 1.2 2007/11/22 15:06:43 stefan Exp $ */
mickey
1.1
3
4 /*
5  * Copyright (c) 2007 Michael Shalayeff
6  * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. The name of the author may not be used to endorse or promote products
18  *    derived from this software without specific prior written permission
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32
33 # include "pass1.h"
34
mickey
1.7
35 NODE *funarg(NODE *, int *);
mickey
1.8
36 int argreg(TWORDint *);
mickey
1.7
37
mickey
1.18
38 static const char *const loctbl[] = { "text""data""section .rodata" };
39
mickey
1.1
40 /*
mickey
1.11
41  * Define everything needed to print out some data (or text).
42  * This means segment, alignment, visibility, etc.
mickey
1.1
43  */
44 void
mickey
1.11
45 defloc(struct symtab *sp)
mickey
1.1
46 {
mickey
1.11
47         extern char *nextsect;
48         static int lastloc = -1;
49         TWORD t;
ragge
1.22
50         char *n;
mickey
1.11
51         int s;
52
53         if (sp == NULL) {
54                 lastloc = -1;
mickey
1.1
55                 return;
mickey
1.11
56         }
57         t = sp->stype;
58         s = ISFTN(t) ? PROG : ISCON(cqual(tsp->squal)) ? RDATA : DATA;
59         if (nextsect) {
60                 printf("\t.section %s\n"nextsect);
61                 nextsect = NULL;
62                 s = -1;
63         } else if (s != lastloc)
64                 printf("\t.%s\n"loctbl[s]);
65         lastloc = s;
66         while (ISARY(t))
67                 t = DECREF(t);
ragge
1.21
68         s = ISFTN(t) ? ALINT : talign(tsp->ssue);
69         if (s > ALCHAR)
70                 printf("\t.align\t%d\n"s / ALCHAR);
ragge
1.22
71         n = sp->soname ? sp->soname : sp->sname;
mickey
1.11
72         if (sp->sclass == EXTDEF)
ragge
1.22
73                 printf("\t.export %s, %s\n"n,
mickey
1.13
74                     ISFTN(t)? "code" : "data");
mickey
1.11
75         if (sp->slevel == 0)
mickey
1.16
76                 printf("\t.type\t%s, @%s\n\t.label %s\n",
ragge
1.22
77                     nISFTN(t)? "function" : "object"n);
mickey
1.11
78         else
mickey
1.16
79                 printf("\t.type\t" LABFMT ", @%s\n\t.label\t" LABFMT "\n"
80                     sp->soffsetISFTN(t)? "function" : "object"sp->soffset);
mickey
1.1
81 }
82
83 /*
84  * code for the end of a function
85  * deals with struct return here
86  */
87 void
88 efcode()
89 {
90         NODE *p, *q;
91         int sz;
92
93         if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
94                 return;
mickey
1.18
95         /* address of return struct is in %ret0 */
mickey
1.1
96         /* create a call to memcpy() */
97         /* will get the result in %ret0 */
ragge
1.23
98         p = block(REGNILNILCHAR+PTR00);
mickey
1.1
99         p->n_rval = RET0;
ragge
1.23
100         q = block(OREGNILNILCHAR+PTR00);
mickey
1.1
101         q->n_rval = FP;
102         q->n_lval = 8/* return buffer offset */
ragge
1.23
103         p = block(CMqpINT00);
mickey
1.1
104         sz = (tsize(STRTYcftnsp->sdfcftnsp->ssue)+SZCHAR-1)/SZCHAR;
ragge
1.23
105         p = block(CMpbcon(sz), INT00);
mickey
1.1
106         p->n_right->n_name = "";
ragge
1.23
107         p = block(CALLbcon(0), pCHAR+PTR00);
mickey
1.1
108         p->n_left->n_name = "memcpy";
109         p = clocal(p);
110         send_passt(IP_NODEp);
111 }
112
mickey
1.8
113 int
114 argreg(TWORD tint *n)
115 {
116         switch (t) {
117         case FLOAT:
118                 return FR7L - 2 * (*n)++;
119         case DOUBLE:
120         case LDOUBLE:
121                 *n += 2;
122                 return FR6 - *n - 2;
123         case LONGLONG:
124         case ULONGLONG:
125                 *n += 2;
126                 return AD1 - (*n - 2) / 2;
127         default:
128                 return ARG0 - (*n)++;
129         }
130 }
131
mickey
1.1
132 /*
133  * code for the beginning of a function; 'a' is an array of
134  * indices in symtab for the arguments; n is the number
135  */
136 void
mickey
1.8
137 bfcode(struct symtab **aint cnt)
mickey
1.1
138 {
mickey
1.8
139         struct symtab *sp;
140         NODE *p, *q;
141         int insz;
mickey
1.1
142
mickey
1.8
143         if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
mickey
1.13
144                 /* Function returns struct, adjust arg offset */
145                 for (i = 0i < ni++)
mickey
1.19
146                         a[i]->soffset += SZPOINT(LONG);
mickey
1.8
147         }
148
149         /* recalculate the arg offset and create TEMP moves */
150         for (n = 0i = 0i < cnti++) {
151                 sp = a[i];
152
153                 sz = szty(sp->stype);
154                 if (n % sz)
155                         n++;    /* XXX LDOUBLE */
156
157                 if (n < 4) {
158                         p = tempnode(0sp->stypesp->sdfsp->ssue);
159                         /* TODO p->n_left->n_lval = -(32 + n * 4); */
160                         q = block(REGNILNILsp->stypesp->sdfsp->ssue);
161                         q->n_rval = argreg(sp->stype, &n);
162                         p = buildtree(ASSIGNpq);
ragge
1.9
163                         sp->soffset = regno(p->n_left);
mickey
1.8
164                         sp->sflags |= STNODE;
165                         ecomp(p);
166                 } else {
167                         sp->soffset += SZINT * n;
168                         if (xtemps) {
169                                 /* put stack args in temps if optimizing */
170                                 p = tempnode(0sp->stypesp->sdfsp->ssue);
171                                 p = buildtree(ASSIGNpbuildtree(NAME00));
ragge
1.9
172                                 sp->soffset = regno(p->n_left);
mickey
1.8
173                                 sp->sflags |= STNODE;
174                                 ecomp(p);
175                         }
176                 }
177         }
mickey
1.1
178 }
179
180
181 /* called just before final exit */
182 /* flag is 1 if errors, 0 if none */
183 void
184 ejobcode(int errors)
185 {
186         if (errors)
187                 return;
188
189         printf("\t.end\n");
190 }
191
192 void
193 bjobcode(void)
194 {
mickey
1.15
195         printf("\t.level\t1.1\n"
196             "\t.import $global$, data\n"
197             "\t.import $$dyncall, millicode\n");
mickey
1.1
198 }
199
200 /* fix up type of field p */
201 void
202 fldty(struct symtab *p)
203 {
204 }
205
stefan
1.4
206 /*
mickey
1.1
207  * XXX - fix genswitch.
208  */
stefan
1.4
209 int
210 mygenswitch(int numTWORD typestruct swents **pint n)
mickey
1.1
211 {
stefan
1.4
212         return 0;
mickey
1.1
213 }
mickey
1.3
214
mickey
1.7
215 NODE *
216 funarg(NODE *pint *n)
217 {
218         NODE *r;
219         int sz;
220
221         if (p->n_op == CM) {
222                 p->n_left = funarg(p->n_leftn);
223                 p->n_right = funarg(p->n_rightn);
224                 return p;
225         }
226
227         sz = szty(p->n_type);
228         if (*n % sz)
mickey
1.8
229                 (*n)++; /* XXX LDOUBLE */
mickey
1.7
230
231         if (*n >= 4) {
232                 *n += sz;
ragge
1.23
233                 r = block(OREGNILNILp->n_type|PTR00);
mickey
1.7
234                 r->n_rval = SP;
235                 r->n_lval = -(32 + *n * 4);
236         } else {
237                 r = block(REGNILNILp->n_type00);
238                 r->n_lval = 0;
mickey
1.8
239                 r->n_rval = argreg(p->n_typen);
mickey
1.7
240         }
241         p = block(ASSIGNrpp->n_type00);
242         clocal(p);
243
244         return p;
245 }
246
ragge
1.2
247 /*
248  * Called with a function call with arguments as argument.
249  * This is done early in buildtree() and only done once.
250  */
251 NODE *
252 funcode(NODE *p)
253 {
mickey
1.7
254         int n = 0;
255
256         p->n_right = funarg(p->n_right, &n);
ragge
1.2
257         return p;
258 }
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-17 07:33 +0200