Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:plunky:20120422210740

Diff

Diff from 1.42 to:

Annotations

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

Annotated File View

plunky
1.42
1 /*      $Id: code.c,v 1.42 2012/04/22 21:07:40 plunky Exp $     */
ragge
1.29
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  */
ragge
1.1
28
29
30 # include "pass1.h"
31
32 /*
ragge
1.38
33  * Define everything needed to print out some data (or text).
34  * This means segment, alignment, visibility, etc.
ragge
1.32
35  */
36 void
ragge
1.38
37 defloc(struct symtab *sp)
ragge
1.32
38 {
ragge
1.38
39         char *nextsect = NULL;  /* notyet */
40         static char *loctbl[] = { "text""data""section .rodata" };
41         static int lastloc = -1;
42         TWORD t;
43         int s;
ragge
1.32
44
ragge
1.38
45         if (sp == NULL) {
46                 lastloc = -1;
47                 return;
48         }
49         t = sp->stype;
50         s = ISFTN(t) ? PROG : ISCON(cqual(tsp->squal)) ? RDATA : DATA;
51         if (nextsect) {
52                 printf("        .section %s\n"nextsect);
53                 nextsect = NULL;
54                 s = -1;
55         } else if (s != lastloc)
56                 printf("        .%s\n"loctbl[s]);
57         lastloc = s;
58         if (sp->sclass == EXTDEF)
59                 printf("        .globl %s\n"sp->soname);
60         if (sp->slevel == 0)
61                 printf("%s:\n"sp->soname);
62         else
63                 printf(LABFMT ":\n"sp->soffset);
ragge
1.1
64 }
65
66 /*
67  * code for the end of a function
68  */
69 void
plunky
1.42
70 efcode(void)
ragge
1.1
71 {
72 }
73
74 /*
75  * code for the beginning of a function; a is an array of
76  * indices in stab for the arguments; n is the number
77  */
78 void
ragge
1.33
79 bfcode(struct symtab **spint cnt)
ragge
1.1
80 {
ragge
1.33
81         NODE *p, *q;
82         int in;
83
84         if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
85                 uerror("no struct return yet");
86         }
87         /* recalculate the arg offset and create TEMP moves */
88         for (n = 1i = 0i < cnti++) {
89                 if (n < 8) {
90                         p = tempnode(0sp[i]->stypesp[i]->sdfsp[i]->ssue);
91                         q = block(REGNILNIL,
92                             sp[i]->stypesp[i]->sdfsp[i]->ssue);
93                         q->n_rval = n;
94                         p = buildtree(ASSIGNpq);
ragge
1.36
95                         sp[i]->soffset = regno(p->n_left);
ragge
1.33
96                         sp[i]->sflags |= STNODE;
97                         ecomp(p);
98                 } else {
99                         sp[i]->soffset += SZINT * n;
100                         if (xtemps) {
101                                 /* put stack args in temps if optimizing */
102                                 p = tempnode(0sp[i]->stype,
103                                     sp[i]->sdfsp[i]->ssue);
ragge
1.39
104                                 p = buildtree(ASSIGNpnametree(sp[i]));
ragge
1.36
105                                 sp[i]->soffset = regno(p->n_left);
ragge
1.33
106                                 sp[i]->sflags |= STNODE;
107                                 ecomp(p);
108                         }
109                 }
110                 n += szty(sp[i]->stype);
111         }
ragge
1.1
112 }
113
114
ragge
1.32
115 void
plunky
1.42
116 bjobcode(void)
ragge
1.32
117 {
118 }
119
ragge
1.1
120 /* called just before final exit */
121 /* flag is 1 if errors, 0 if none */
122 void
plunky
1.42
123 ejobcode(int flag)
ragge
1.1
124 {
125 }
126
ragge
1.27
127 /*
ragge
1.33
128  * Make a register node, helper for funcode.
129  */
130 static NODE *
131 mkreg(NODE *pint n)
132 {
133         NODE *r;
134
135         r = block(REGNILNILp->n_typep->n_dfp->n_sue);
136         if (szty(p->n_type) == 2)
137                 n += 16;
138         r->n_rval = n;
139         return r;
140 }
141
142 static int regnum;
143 /*
144  * Move args to registers and emit expressions bottom-up.
145  */
146 static void
147 fixargs(NODE *p)
148 {
149         NODE *r;
150
151         if (p->n_op == CM) {
152                 fixargs(p->n_left);
153                 r = p->n_right;
154                 if (r->n_op == STARG)
155                         regnum = 9/* end of register list */
156                 else if (regnum + szty(r->n_type) > 8)
157                         p->n_right = block(FUNARGrNILr->n_type,
158                             r->n_dfr->n_sue);
159                 else
160                         p->n_right = buildtree(ASSIGNmkreg(rregnum), r);
161         } else {
162                 if (p->n_op == STARG) {
163                         regnum = 9/* end of register list */
164                 } else {
165                         r = talloc();
166                         *r = *p;
167                         r = buildtree(ASSIGNmkreg(rregnum), r);
168                         *p = *r;
169                         nfree(r);
170                 }
171                 r = p;
172         }
173         regnum += szty(r->n_type);
174 }
175
176
177 /*
178  * Called with a function call with arguments as argument.
179  * This is done early in buildtree() and only done once.
180  */
181 NODE *
182 funcode(NODE *p)
183 {
184
185         regnum = 1;
186
187         fixargs(p->n_right);
188         return p;
189 }
190
ragge
1.1
191 /* fix up type of field p */
192 void
193 fldty(struct symtab *p)
194 {
195 }
196
stefan
1.34
197 /*
ragge
1.24
198  * XXX - fix genswitch.
ragge
1.6
199  */
stefan
1.34
200 int
201 mygenswitch(int numTWORD typestruct swents **pint n)
ragge
1.1
202 {
stefan
1.34
203         return 0;
ragge
1.1
204 }
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-01 15:47 +0200