OpenCores
URL https://opencores.org/ocsvn/eco32/eco32/trunk

Subversion Repositories eco32

[/] [eco32/] [trunk/] [lcc/] [src/] [bytecode.c] - Blame information for rev 130

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 4 hellwig
#include "c.h"
2
#define I(f) b_##f
3
 
4
static char rcsid[] = "$Id: bytecode.c,v 1.1 2002/08/28 23:12:41 drh Exp $";
5
 
6
static void I(segment)(int n) {
7
        static int cseg;
8
 
9
        if (cseg != n)
10
                switch (cseg = n) {
11
                case CODE: print("code\n"); return;
12
                case DATA: print("data\n"); return;
13
                case BSS:  print("bss\n");  return;
14
                case LIT:  print("lit\n");  return;
15
                default: assert(0);
16
                }
17
}
18
 
19
static void I(address)(Symbol q, Symbol p, long n) {
20
        q->x.name = stringf("%s%s%D", p->x.name, n > 0 ? "+" : "", n);
21
}
22
 
23
static void I(defaddress)(Symbol p) {
24
        print("address %s\n", p->x.name);
25
}
26
 
27
static void I(defconst)(int suffix, int size, Value v) {
28
        switch (suffix) {
29
        case I:
30
                if (size > sizeof (int))
31
                        print("byte %d %D\n", size, v.i);
32
                else
33
                        print("byte %d %d\n", size, v.i);
34
                return;
35
        case U:
36
                if (size > sizeof (unsigned))
37
                        print("byte %d %U\n", size, v.u);
38
                else
39
                        print("byte %d %u\n", size, v.u);
40
                return;
41
        case P: print("byte %d %U\n", size, (unsigned long)v.p); return;
42
        case F:
43
                if (size == 4) {
44
                        float f = v.d;
45
                        print("byte 4 %u\n", *(unsigned *)&f);
46
                } else {
47
                        double d = v.d;
48
                        unsigned *p = (unsigned *)&d;
49
                        print("byte 4 %u\n", p[swap]);
50
                        print("byte 4 %u\n", p[1 - swap]);
51
                }
52
                return;
53
        }
54
        assert(0);
55
}
56
 
57
static void I(defstring)(int len, char *str) {
58
        char *s;
59
 
60
        for (s = str; s < str + len; s++)
61
                print("byte 1 %d\n", (*s)&0377);
62
}
63
 
64
static void I(defsymbol)(Symbol p) {
65
        if (p->scope == CONSTANTS)
66
                switch (optype(ttob(p->type))) {
67
                case I: p->x.name = stringf("%D", p->u.c.v.i); break;
68
                case U: p->x.name = stringf("%U", p->u.c.v.u); break;
69
                case P: p->x.name = stringf("%U", p->u.c.v.p); break;
70
                default: assert(0);
71
                }
72
        else if (p->scope >= LOCAL && p->sclass == STATIC)
73
                p->x.name = stringf("$%d", genlabel(1));
74
        else if (p->scope == LABELS || p->generated)
75
                p->x.name = stringf("$%s", p->name);
76
        else
77
                p->x.name = p->name;
78
}
79
 
80
static void dumptree(Node p) {
81
        switch (specific(p->op)) {
82
        case ASGN+B:
83
                assert(p->kids[0]);
84
                assert(p->kids[1]);
85
                assert(p->syms[0]);
86
                dumptree(p->kids[0]);
87
                dumptree(p->kids[1]);
88
                print("%s %d\n", opname(p->op), p->syms[0]->u.c.v.u);
89
                return;
90
        case RET+V:
91
                assert(!p->kids[0]);
92
                assert(!p->kids[1]);
93
                print("%s\n", opname(p->op));
94
                return;
95
        }
96
        switch (generic(p->op)) {
97
        case CNST: case ADDRG: case ADDRF: case ADDRL: case LABEL:
98
                assert(!p->kids[0]);
99
                assert(!p->kids[1]);
100
                assert(p->syms[0] && p->syms[0]->x.name);
101
                print("%s %s\n", opname(p->op), p->syms[0]->x.name);
102
                return;
103
        case CVF: case CVI: case CVP: case CVU:
104
                assert(p->kids[0]);
105
                assert(!p->kids[1]);
106
                assert(p->syms[0]);
107
                dumptree(p->kids[0]);
108
                print("%s %d\n", opname(p->op), p->syms[0]->u.c.v.i);
109
                return;
110
        case ARG: case BCOM: case NEG: case INDIR: case JUMP: case RET:
111
                assert(p->kids[0]);
112
                assert(!p->kids[1]);
113
                dumptree(p->kids[0]);
114
                print("%s\n", opname(p->op));
115
                return;
116
        case CALL:
117
                assert(p->kids[0]);
118
                assert(!p->kids[1]);
119
                assert(optype(p->op) != B);
120
                dumptree(p->kids[0]);
121
                print("%s\n", opname(p->op));
122
                return;
123
        case ASGN: case BOR: case BAND: case BXOR: case RSH: case LSH:
124
        case ADD: case SUB: case DIV: case MUL: case MOD:
125
                assert(p->kids[0]);
126
                assert(p->kids[1]);
127
                dumptree(p->kids[0]);
128
                dumptree(p->kids[1]);
129
                print("%s\n", opname(p->op));
130
                return;
131
        case EQ: case NE: case GT: case GE: case LE: case LT:
132
                assert(p->kids[0]);
133
                assert(p->kids[1]);
134
                assert(p->syms[0]);
135
                assert(p->syms[0]->x.name);
136
                dumptree(p->kids[0]);
137
                dumptree(p->kids[1]);
138
                print("%s %s\n", opname(p->op), p->syms[0]->x.name);
139
                return;
140
        }
141
        assert(0);
142
}
143
 
144
static void I(emit)(Node p) {
145
        for (; p; p = p->link)
146
                dumptree(p);
147
}
148
 
149
static void I(export)(Symbol p) {
150
        print("export %s\n", p->x.name);
151
}
152
 
153
static void I(function)(Symbol f, Symbol caller[], Symbol callee[], int ncalls) {
154
        int i;
155
 
156
        (*IR->segment)(CODE);
157
        offset = 0;
158
        for (i = 0; caller[i] && callee[i]; i++) {
159
                offset = roundup(offset, caller[i]->type->align);
160
                caller[i]->x.name = callee[i]->x.name = stringf("%d", offset);
161
                caller[i]->x.offset = callee[i]->x.offset = offset;
162
                offset += caller[i]->type->size;
163
        }
164
        maxargoffset = maxoffset = argoffset = offset = 0;
165
        gencode(caller, callee);
166
        print("proc %s %d %d\n", f->x.name, maxoffset, maxargoffset);
167
        emitcode();
168
        print("endproc %s %d %d\n", f->x.name, maxoffset, maxargoffset);
169
 
170
}
171
 
172
static void gen02(Node p) {
173
        assert(p);
174
        if (generic(p->op) == ARG) {
175
                assert(p->syms[0]);
176
                argoffset += (p->syms[0]->u.c.v.i < 4 ? 4 : p->syms[0]->u.c.v.i);
177
        } else if (generic(p->op) == CALL) {
178
                maxargoffset = (argoffset > maxargoffset ? argoffset : maxargoffset);
179
                argoffset = 0;
180
        }
181
}
182
 
183
static void gen01(Node p) {
184
        if (p) {
185
                gen01(p->kids[0]);
186
                gen01(p->kids[1]);
187
                gen02(p);
188
        }
189
}
190
 
191
static Node I(gen)(Node p) {
192
        Node q;
193
 
194
        assert(p);
195
        for (q = p; q; q = q->link)
196
                gen01(q);
197
        return p;
198
}
199
 
200
static void I(global)(Symbol p) {
201
        print("align %d\n", p->type->align > 4 ? 4 : p->type->align);
202
        print("LABELV %s\n", p->x.name);
203
}
204
 
205
static void I(import)(Symbol p) {
206
        print("import %s\n", p->x.name);
207
}
208
 
209
static void I(local)(Symbol p) {
210
        offset = roundup(offset, p->type->align);
211
        p->x.name = stringf("%d", offset);
212
        p->x.offset = offset;
213
        offset += p->type->size;
214
}
215
 
216
static void I(progbeg)(int argc, char *argv[]) {}
217
 
218
static void I(progend)(void) {}
219
 
220
static void I(space)(int n) {
221
        print("skip %d\n", n);
222
}
223
 
224
static void I(stabline)(Coordinate *cp) {
225
        static char *prevfile;
226
        static int prevline;
227
 
228
        if (cp->file && (prevfile == NULL || strcmp(prevfile, cp->file) != 0)) {
229
                print("file \"%s\"\n", prevfile = cp->file);
230
                prevline = 0;
231
        }
232
        if (cp->y != prevline)
233
                print("line %d\n", prevline = cp->y);
234
}
235
 
236
#define b_blockbeg blockbeg
237
#define b_blockend blockend
238
 
239
Interface bytecodeIR = {
240
        1, 1, 0, /* char */
241
        2, 2, 0, /* short */
242
        4, 4, 0, /* int */
243
        4, 4, 0, /* long */
244
        4, 4, 0, /* long long */
245
        4, 4, 1,        /* float */
246
        8, 8, 1,        /* double */
247
        8, 8, 1,        /* long double */
248
        4, 4, 0, /* T* */
249
        0, 4, 0,  /* struct */
250
        0,               /* little_endian */
251
        0,               /* mulops_calls */
252
        0,               /* wants_callb */
253
        0,               /* wants_argb */
254
        1,              /* left_to_right */
255
        0,               /* wants_dag */
256
        0,               /* unsigned_char */
257
        I(address),
258
        I(blockbeg),
259
        I(blockend),
260
        I(defaddress),
261
        I(defconst),
262
        I(defstring),
263
        I(defsymbol),
264
        I(emit),
265
        I(export),
266
        I(function),
267
        I(gen),
268
        I(global),
269
        I(import),
270
        I(local),
271
        I(progbeg),
272
        I(progend),
273
        I(segment),
274
        I(space),
275
        0,               /* I(stabblock) */
276
        0,               /* I(stabend) */
277
        0,               /* I(stabfend) */
278
        0,               /* I(stabinit) */
279
        I(stabline),
280
        0,               /* I(stabsym) */
281
        0,               /* I(stabtype) */
282
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.