Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20140603201950

Diff

Diff from 1.11 to:

Annotations

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

Annotated File View

ragge
1.11
1 /*      $Id: code.c,v 1.11 2014/06/03 20:19:50 ragge Exp $      */
ragge
1.1
2 /*
3  * Copyright (c) 2006 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  * never called for text segment.
35  */
36 void
37 defalign(int n)
38 {
39         /* alignment are always correct */
40 }
41
42 /*
ragge
1.10
43  * Print out assembler segment name.
44  */
45 void
46 setseg(int segchar *name)
47 {
48         switch (seg) {
49         case PROGname = ".text"break;
50         case DATA:
51         case LDATAname = ".data"break;
52         case STRNG:
53         case RDATAname = ".section .rodata"break;
54         case UDATAbreak;
55         default:
56                 cerror((char *)__func__);
57         }
58         printf("\t%s\n"name);
59 }
60
61 /*
62  * Define everything needed to print out some data (or text).
63  * This means segment, alignment, visibility, etc.
ragge
1.1
64  */
65 void
ragge
1.10
66 defloc(struct symtab *sp)
ragge
1.1
67 {
ragge
1.10
68         char *name;
ragge
1.1
69
ragge
1.10
70         if ((name = sp->soname) == NULL)
71                 name = exname(sp->sname);
72
ragge
1.11
73         if (ISFTN(sp->stype))
74                 return;
ragge
1.10
75         if (sp->sclass == EXTDEF)
76                 printf("\t.globl %s\n"name);
77         if (sp->slevel == 0)
78                 printf("%s:\n"name);
79         else
80                 printf(LABFMT ":\n"sp->soffset);
81 }
82
83 /* make a common declaration for id, if reasonable */
84 void
85 defzero(struct symtab *sp)
86 {
87         int offal;
88         char *name;
89
90         if ((name = sp->soname) == NULL)
91                 name = exname(sp->sname);
92         off = tsize(sp->stypesp->sdfsp->sap);
93         SETOFF(off,SZCHAR);
94         off /= SZCHAR;
95         al = talign(sp->stypesp->sap)/SZCHAR;
96
97         if (sp->sclass == STATIC) {
98                 if (sp->slevel == 0) {
99                         printf("\t.local %s\n"name);
100                 } else
101                         printf("\t.local " LABFMT "\n"sp->soffset);
102         }
103         if (sp->slevel == 0) {
104                 printf("\t.comm %s,0%o,%d\n"nameoffal);
105         } else
106                 printf("\t.comm " LABFMT ",0%o,%d\n"sp->soffsetoffal);
ragge
1.1
107 }
108
109
ragge
1.11
110 //static int ac3temp;
ragge
1.1
111 /*
112  * code for the end of a function
113  * deals with struct return here
114  */
115 void
plunky
1.9
116 efcode(void)
ragge
1.1
117 {
118         NODE *p, *q;
ragge
1.10
119 //      int sz;
ragge
1.1
120
ragge
1.11
121 #if 0
122         /* restore ac3 */
123         p = block(REG00INT00);
124         regno(p) = 3;
125         q = tempnode(ac3tempINT00);
126         ecomp(buildtree(ASSIGNpq));
127 #endif
128
129
ragge
1.1
130         if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
131                 return;
132 cerror("efcode");
133         /* address of return struct is in eax */
134         /* create a call to memcpy() */
135         /* will get the result in eax */
ragge
1.6
136         p = block(REGNILNILCHAR+PTR00);
ragge
1.1
137 //      p->n_rval = EAX;
ragge
1.6
138         q = block(OREGNILNILCHAR+PTR00);
ragge
1.1
139 //      q->n_rval = EBP;
140         q->n_lval = 8/* return buffer offset */
ragge
1.6
141         p = block(CMqpINT00);
ragge
1.10
142 //      sz = (tsize(STRTY, cftnsp->sdf, cftnsp->ssue)+SZCHAR-1)/SZCHAR;
143 //      p = block(CM, p, bcon(sz), INT, 0, 0);
ragge
1.1
144         p->n_right->n_name = "";
ragge
1.6
145         p = block(CALLbcon(0), pCHAR+PTR00);
ragge
1.1
146         p->n_left->n_name = "memcpy";
147         p = clocal(p);
148         send_passt(IP_NODEp);
149 }
150
151 /*
152  * code for the beginning of a function; a is an array of
153  * indices in symtab for the arguments; n is the number
154  */
155 void
156 bfcode(struct symtab **aint n)
157 {
ragge
1.11
158 //      NODE *p, *q;
ragge
1.1
159         int i;
160
ragge
1.11
161         for (i = 0i < ni++) {
162                 if (a[i]->stype == CHAR)
163                         a[i]->stype = INT;
164                 if (a[i]->stype == UCHAR)
165                         a[i]->stype = UNSIGNED;
166         }
167
ragge
1.1
168         if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
169                 return;
170 cerror("bfcode");
171         /* Function returns struct, adjust arg offset */
172         for (i = 0i < ni++)
173                 a[i]->soffset += SZPOINT(INT);
174 }
175
176
177 /* called just before final exit */
178 /* flag is 1 if errors, 0 if none */
179 void
plunky
1.9
180 ejobcode(int flag)
ragge
1.1
181 {
182 }
183
184 void
plunky
1.9
185 bjobcode(void)
ragge
1.1
186 {
187 }
188
189 /* fix up type of field p */
190 void
191 fldty(struct symtab *p)
192 {
193 }
194
stefan
1.3
195 /*
ragge
1.1
196  * XXX - fix genswitch.
197  */
stefan
1.3
198 int
199 mygenswitch(int numTWORD typestruct swents **pint n)
ragge
1.1
200 {
stefan
1.3
201         return 0;
ragge
1.1
202 }
ragge
1.2
203 /*
204  * Called with a function call with arguments as argument.
205  * This is done early in buildtree() and only done once.
206  */
207 NODE *
208 funcode(NODE *p)
209 {
ragge
1.11
210         NODE *r, *l;
211
212         /* Fix function call arguments. On nova, just add funarg */
213         for (r = p->n_rightr->n_op == CMr = r->n_left) {
214                 if (r->n_right->n_op != STARG)
215                         r->n_right = block(FUNARGr->n_rightNIL,
216                             r->n_right->n_typer->n_right->n_df,
217                             r->n_right->n_ap);
218         }
219         if (r->n_op != STARG) {
220                 l = talloc();
221                 *l = *r;
222                 r->n_op = FUNARG;
223                 r->n_left = l;
224                 r->n_type = l->n_type;
225         }
226
ragge
1.2
227         return p;
228 }
ragge
1.10
229
230 /*
231  * Return return as given by a.
232  */
233 NODE *
234 builtin_return_address(const struct bitable *btNODE *a)
235 {
236         cerror((char *)__func__);
237         return 0;
238 }
239
240 /*
241  * Return frame as given by a.
242  */
243 NODE *
244 builtin_frame_address(const struct bitable *btNODE *a)
245 {
246         cerror((char *)__func__);
247         return 0;
248 }
249
250 /*
251  * Return "canonical frame address".
252  */
253 NODE *
254 builtin_cfa(const struct bitable *btNODE *a)
255 {
256         cerror((char *)__func__);
257         return 0;
258 }
259
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-10-31 22:33 +0100