1 /**
2 * Compiler implementation of the
3 * $(LINK2 http://www.dlang.org, D programming language).
4 *
5 * Copyright: Copyright (C) 1985-1998 by Symantec
6 * Copyright (C) 2000-2019 by The D Language Foundation, All Rights Reserved
7 * Authors: $(LINK2 http://www.digitalmars.com, Walter Bright)
8 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
9 * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/optabgen.d, backend/optabgen.d)
10 */
11
12 module optabgen;
13
14 /* Generate op-code tables
15 * Creates optab.d,tytab.d,debtab.d,cdxxx.d,elxxx.d
16 */
17
18 import core.stdc.stdio;
19 import core.stdc.stdlib;
20
21 import dmd.backend.cc;
22 import dmd.backend.cdef;
23 import dmd.backend.oper;
24 import dmd.backend.ty;
25
26 ubyte[OPMAX] xptab1,xptab2,xptab3;
27
28 int[] _binary = [
29 OPadd,OPmul,OPand,OPmin,OPcond,OPcomma,OPdiv,OPmod,OPxor,
30 OPor,OPoror,OPandand,OPshl,OPshr,OPashr,OPstreq,OPstrcpy,OPstrcat,OPstrcmp,
31 OPpostinc,OPpostdec,OPeq,OPaddass,OPminass,OPmulass,OPdivass,
32 OPmodass,OPshrass,OPashrass,OPshlass,OPandass,OPxorass,OPorass,
33 OPle,OPgt,OPlt,OPge,OPeqeq,OPne,OPparam,OPcall,OPcallns,OPcolon,OPcolon2,
34 OPbit,OPbrack,OParrowstar,OPmemcpy,OPmemcmp,OPmemset,
35 OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge,
36 OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue,
37 OPinfo,OPpair,OPrpair,
38 OPbt,OPbtc,OPbtr,OPbts,OPror,OProl,OPbtst,
39 OPremquo,OPcmpxchg,
40 OPoutp,OPscale,OPyl2x,OPyl2xp1,
41 OPvecsto,OPprefetch
42 ];
43 int[] _unary =
44 [OPnot,OPcom,OPind,OPaddr,OPneg,OPuadd,
45 OPabs,OPrndtol,OPrint,
46 OPpreinc,OPpredec,
47 OPbool,OPstrlen,
48 OPb_8,OPs16_32,OPu16_32,OPd_s32,OPd_u32,
49 OPs32_d,OPu32_d,OPd_s16,OPs16_d,OP32_16,
50 OPd_f,OPf_d,OPu8_16,OPs8_16,OP16_8,
51 OPd_ld, OPld_d,OPc_r,OPc_i,
52 OPu32_64,OPs32_64,OP64_32,OPmsw,
53 OPd_s64,OPs64_d,OPd_u64,OPu64_d,OPld_u64,
54 OP128_64,OPs64_128,OPu64_128,
55 OPucall,OPucallns,OPstrpar,OPstrctor,OPu16_d,OPd_u16,
56 OParrow,OPnegass,
57 OPctor,OPdtor,OPsetjmp,OPvoid,
58 OPbsf,OPbsr,OPbswap,OPpopcnt,
59 OPddtor,
60 OPvector,OPvecfill,
61 OPva_start,
62 OPsqrt,OPsin,OPcos,OPinp,
63 OPvp_fp,OPcvp_fp,OPnp_fp,OPnp_f16p,OPf16p_np,OPoffset,
64 ];
65 int[] _commut = [OPadd,OPand,OPor,OPxor,OPmul,OPeqeq,OPne,OPle,OPlt,OPge,OPgt,
66 OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge,
67 OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue,
68 ];
69 int[] _assoc = [OPadd,OPand,OPor,OPxor,OPmul];
70 int[] _assign =
71 [OPstreq,OPeq,OPaddass,OPminass,OPmulass,OPdivass,OPmodass,
72 OPshrass,OPashrass,OPshlass,OPandass,OPxorass,OPorass,OPpostinc,OPpostdec,
73 OPnegass,OPvecsto,OPcmpxchg,
74 ];
75 int[] _wid =
76 [OPadd,OPmin,OPand,OPor,OPxor,OPcom,OPneg,OPmul,OPaddass,OPnegass,
77 OPminass,OPandass,OPorass,OPxorass,OPmulass,OPshlass,OPshl,OPshrass,
78 OPashrass,
79 ];
80 int[] _eop0e =
81 [OPadd,OPmin,OPxor,OPor,OPshl,OPshr,OPashr,OPpostinc,OPpostdec,OPaddass,
82 OPminass,OPshrass,OPashrass,OPshlass,OPxorass,OPorass,
83 OPror,OProl,
84 ];
85 int[] _eop00 = [OPmul,OPand,OPmulass,OPandass];
86 int[] _eop1e = [OPmul,OPdiv,OPmulass,OPdivass];
87 int[] _call = [OPcall,OPucall,OPcallns,OPucallns];
88 int[] _rel = [OPeqeq,OPne,OPle,OPlt,OPgt,OPge,
89 OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge,
90 OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue,
91 ];
92 int[] _logical = [OPeqeq,OPne,OPle,OPlt,OPgt,OPge,OPandand,OPoror,OPnot,OPbool,
93 OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge,
94 OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue,
95 OPbt,OPbtst,
96 ];
97 int[] _def = [OPstreq,OPeq,OPaddass,OPminass,OPmulass,OPdivass,OPmodass,
98 OPshrass,OPashrass,OPshlass,OPandass,OPxorass,OPorass,
99 OPpostinc,OPpostdec,
100 OPcall,OPucall,OPasm,OPstrcpy,OPmemcpy,OPmemset,OPstrcat,
101 OPnegass,
102 OPbtc,OPbtr,OPbts,
103 OPvecsto,OPcmpxchg,
104 ];
105 int[] _sideff = [OPasm,OPucall,OPstrcpy,OPmemcpy,OPmemset,OPstrcat,
106 OPcall,OPeq,OPstreq,OPpostinc,OPpostdec,
107 OPaddass,OPminass,OPmulass,OPdivass,OPmodass,OPandass,
108 OPorass,OPxorass,OPshlass,OPshrass,OPashrass,
109 OPnegass,OPctor,OPdtor,OPmark,OPvoid,
110 OPbtc,OPbtr,OPbts,
111 OPhalt,OPdctor,OPddtor,
112 OPcmpxchg,
113 OPva_start,
114 OPinp,OPoutp,OPvecsto,OPprefetch,
115 ];
116 int[] _rtol = [OPeq,OPstreq,OPstrcpy,OPmemcpy,OPpostinc,OPpostdec,OPaddass,
117 OPminass,OPmulass,OPdivass,OPmodass,OPandass,
118 OPorass,OPxorass,OPshlass,OPshrass,OPashrass,
119 OPcall,OPcallns,OPinfo,OPmemset,
120 OPvecsto,OPcmpxchg,
121 ];
122 int[] _ae = [OPvar,OPconst,OPrelconst,OPneg,
123 OPabs,OPrndtol,OPrint,
124 OPstrlen,OPstrcmp,OPind,OPaddr,
125 OPnot,OPbool,OPcom,OPadd,OPmin,OPmul,OPand,OPor,OPmemcmp,
126 OPxor,OPdiv,OPmod,OPshl,OPshr,OPashr,OPeqeq,OPne,OPle,OPlt,OPge,OPgt,
127 OPunord,OPlg,OPleg,OPule,OPul,OPuge,OPug,OPue,OPngt,OPnge,
128 OPnlt,OPnle,OPord,OPnlg,OPnleg,OPnule,OPnul,OPnuge,OPnug,OPnue,
129 OPs16_32,OPu16_32,OPd_s32,OPd_u32,OPu16_d,OPd_u16,
130 OPs32_d,OPu32_d,OPd_s16,OPs16_d,OP32_16,
131 OPd_f,OPf_d,OPu8_16,OPs8_16,OP16_8,
132 OPd_ld,OPld_d,OPc_r,OPc_i,
133 OPu32_64,OPs32_64,OP64_32,OPmsw,
134 OPd_s64,OPs64_d,OPd_u64,OPu64_d,OPld_u64,
135 OP128_64,OPs64_128,OPu64_128,
136 OPsizeof,
137 OPcallns,OPucallns,OPpair,OPrpair,
138 OPbsf,OPbsr,OPbt,OPbswap,OPb_8,OPbtst,OPpopcnt,
139 OPgot,OPremquo,
140 OPnullptr,
141 OProl,OPror,
142 OPsqrt,OPsin,OPcos,OPscale,
143 OPvp_fp,OPcvp_fp,OPnp_fp,OPnp_f16p,OPf16p_np,OPoffset,OPvecfill,
144 ];
145 int[] _boolnop = [OPuadd,OPbool,OPs16_32,OPu16_32,
146 OPs16_d,
147 OPf_d,OPu8_16,OPs8_16,
148 OPd_ld, OPld_d,
149 OPu32_64,OPs32_64,/*OP64_32,OPmsw,*/
150 OPs64_128,OPu64_128,
151 OPu16_d,OPb_8,
152 OPnullptr,
153 OPnp_fp,OPvp_fp,OPcvp_fp,
154 OPvecfill,
155 ];
156 int[] _lvalue = [OPvar,OPind,OPcomma,OPbit];
157
158 FILE *fdeb;
159
160 int main()
161 {
162 printf("OPTABGEN... generating files\n");
163 fdeb = fopen("debtab.d","w");
164 dooptab();
165 dotab();
166 fltables();
167 dotytab();
168 fclose(fdeb);
169 return 0;
170 }
171
172 int cost(uint op)
173 { uint c;
174
175 c = 0; /* default cost */
176 if (xptab1[op] & _OTunary)
177 c += 2;
178 else if (xptab1[op] & _OTbinary)
179 c += 7;
180 if (xptab2[op] & _OTlogical)
181 c += 3;
182 switch (op)
183 { case OPvar: c += 1; break;
184 case OPmul: c += 3; break;
185 case OPdiv:
186 case OPmod: c += 4; break;
187 case OProl:
188 case OPror:
189 case OPshl:
190 case OPashr:
191 case OPshr: c += 2; break;
192 case OPcall:
193 case OPucall:
194 case OPcallns:
195 case OPucallns:
196 c += 10; break; // very high cost for function calls
197
198 default:
199 break;
200 }
201 return c;
202 }
203
204 void dooptab()
205 { int i;
206 FILE *f;
207
208 /* Load optab[] */
209 static void X1(int[] arr, uint mask) { for(int i=0; i<arr.length; i++) xptab1[arr[i]] |= mask; }
210 static void X2(int[] arr, uint mask) { for(int i=0; i<arr.length; i++) xptab2[arr[i]] |= mask; }
211 static void X3(int[] arr, uint mask) { for(int i=0; i<arr.length; i++) xptab3[arr[i]] |= mask; }
212
213 X1(_binary,_OTbinary);
214 X1(_unary,_OTunary);
215 X1(_commut,_OTcommut);
216 X1(_assoc,_OTassoc);
217 X1(_sideff,_OTsideff);
218 X1(_eop0e,_OTeop0e);
219 X1(_eop00,_OTeop00);
220 X1(_eop1e,_OTeop1e);
221
222 X2(_logical,_OTlogical);
223 X2(_wid,_OTwid);
224 X2(_call,_OTcall);
225 X2(_rtol,_OTrtol);
226 X2(_assign,_OTassign);
227 X2(_def,_OTdef);
228 X2(_ae,_OTae);
229
230 X3(_boolnop,_OTboolnop);
231
232 f = fopen("optab.d","w");
233 fprintf(f,"extern (C) __gshared ubyte[OPMAX] optab1 =\n\t[");
234 for (i = 0; i < OPMAX; i++)
235 { if ((i & 7) == 0)
236 fprintf(f,"\n\t");
237 fprintf(f,"0x%x",xptab1[i]);
238 if (i != OPMAX - 1)
239 fprintf(f,",");
240 }
241 fprintf(f,"\t];\n");
242 fprintf(f,"extern (C) __gshared ubyte[OPMAX] optab2 =\n\t[");
243 for (i = 0; i < OPMAX; i++)
244 { if ((i & 7) == 0)
245 fprintf(f,"\n\t");
246 fprintf(f,"0x%x",xptab2[i]);
247 if (i != OPMAX - 1)
248 fprintf(f,",");
249 }
250 fprintf(f,"\t];\n");
251 fprintf(f,"extern (C) __gshared ubyte[OPMAX] optab3 =\n\t[");
252 for (i = 0; i < OPMAX; i++)
253 { if ((i & 7) == 0)
254 fprintf(f,"\n\t");
255 fprintf(f,"0x%x",xptab3[i]);
256 if (i != OPMAX - 1)
257 fprintf(f,",");
258 }
259 fprintf(f,"\t];\n");
260
261 fprintf(f,"extern (C) __gshared ubyte[OPMAX] opcost =\n\t[");
262 for (i = 0; i < OPMAX; i++)
263 { if ((i & 7) == 0)
264 fprintf(f,"\n\t");
265 fprintf(f,"0x%x",cost(i));
266 if (i != OPMAX - 1)
267 fprintf(f,",");
268 }
269 fprintf(f,"\t];\n");
270
271 doreltables(f);
272 fclose(f);
273 }
274
275 /********************************************************
276 */
277
278 void doreltables(FILE *f)
279 {
280 struct RelTables
281 { OPER op; /* operator */
282 OPER inot; /* for logical negation */
283 OPER swap; /* if operands are swapped */
284 OPER integral; /* if operands are integral types */
285 int exception; /* if invalid exception is generated */
286 int unord; /* result of unordered operand(s) */
287 }
288 static RelTables[26] reltables =
289 [ /* op not swap int exc unord */
290 { OPeqeq, OPne, OPeqeq, OPeqeq, 0, 0 },
291 { OPne, OPeqeq, OPne, OPne, 0, 1 },
292 { OPgt, OPngt, OPlt, OPgt, 1, 0 },
293 { OPge, OPnge, OPle, OPge, 1, 0 },
294 { OPlt, OPnlt, OPgt, OPlt, 1, 0 },
295 { OPle, OPnle, OPge, OPle, 1, 0 },
296
297 { OPunord, OPord, OPunord, cast(OPER)0,0,1 },
298 { OPlg, OPnlg, OPlg, OPne, 1, 0 },
299 { OPleg, OPnleg, OPleg, cast(OPER)1,1, 0 },
300 { OPule, OPnule, OPuge, OPle, 0, 1 },
301 { OPul, OPnul, OPug, OPlt, 0, 1 },
302 { OPuge, OPnuge, OPule, OPge, 0, 1 },
303 { OPug, OPnug, OPul, OPgt, 0, 1 },
304 { OPue, OPnue, OPue, OPeqeq, 0, 1 },
305
306 { OPngt, OPgt, OPnlt, OPle, 1, 1 },
307 { OPnge, OPge, OPnle, OPlt, 1, 1 },
308 { OPnlt, OPlt, OPngt, OPge, 1, 1 },
309 { OPnle, OPle, OPnge, OPgt, 1, 1 },
310 { OPord, OPunord, OPord, cast(OPER)1,0, 0 },
311 { OPnlg, OPlg, OPnlg, OPeqeq, 1, 1 },
312 { OPnleg, OPleg, OPnleg, cast(OPER)0,1, 1 },
313 { OPnule, OPule, OPnuge, OPgt, 0, 0 },
314 { OPnul, OPul, OPnug, OPge, 0, 0 },
315 { OPnuge, OPuge, OPnule, OPlt, 0, 0 },
316 { OPnug, OPug, OPnul, OPle, 0, 0 },
317 { OPnue, OPue, OPnue, OPne, 0, 0 },
318 ];
319 enum RELMAX = reltables.length;
320 OPER[RELMAX] rel_not;
321 OPER[RELMAX] rel_swap;
322 OPER[RELMAX] rel_integral;
323 int[RELMAX] rel_exception;
324 int[RELMAX] rel_unord;
325 int i;
326
327 for (i = 0; i < RELMAX; i++)
328 { int j = cast(int)(reltables[i].op) - RELOPMIN;
329
330 assert(j >= 0 && j < RELMAX);
331 rel_not [j] = reltables[i].inot;
332 rel_swap [j] = reltables[i].swap;
333 rel_integral [j] = reltables[i].integral;
334 rel_exception[j] = reltables[i].exception;
335 rel_unord [j] = reltables[i].unord;
336 }
337
338 fprintf(f,"__gshared ubyte[%d] _rel_not =\n[ ", RELMAX);
339 for (i = 0; i < rel_not.length; i++)
340 { fprintf(f,"0x%02x,",rel_not[i]);
341 if ((i & 7) == 7 && i < rel_not.length - 1)
342 fprintf(f,"\n ");
343 }
344 fprintf(f,"\n];\n");
345
346 fprintf(f,"__gshared ubyte[%d] _rel_swap =\n[ ", RELMAX);
347 for (i = 0; i < rel_swap.length; i++)
348 { fprintf(f,"0x%02x,",rel_swap[i]);
349 if ((i & 7) == 7 && i < rel_swap.length - 1)
350 fprintf(f,"\n ");
351 }
352 fprintf(f,"\n];\n");
353
354 fprintf(f,"__gshared ubyte[%d] _rel_integral =\n[ ", RELMAX);
355 for (i = 0; i < rel_integral.length; i++)
356 { fprintf(f,"0x%02x,",rel_integral[i]);
357 if ((i & 7) == 7 && i < rel_integral.length - 1)
358 fprintf(f,"\n ");
359 }
360 fprintf(f,"\n];\n");
361
362 fprintf(f,"__gshared ubyte[%d] _rel_exception =\n[ ", RELMAX);
363 for (i = 0; i < rel_exception.length; i++)
364 { fprintf(f,"0x%02x,",rel_exception[i]);
365 if ((i & 7) == 7 && i < rel_exception.length - 1)
366 fprintf(f,"\n ");
367 }
368 fprintf(f,"\n];\n");
369
370 fprintf(f,"__gshared ubyte[%d] _rel_unord =\n[ ", RELMAX);
371 for (i = 0; i < rel_unord.length; i++)
372 { fprintf(f,"0x%02x,",rel_unord[i]);
373 if ((i & 7) == 7 && i < rel_unord.length - 1)
374 fprintf(f,"\n ");
375 }
376 fprintf(f,"\n];\n");
377 }
378
379
380 /********************************************************
381 */
382
383 string[OPMAX] debtab, cdxxx, elxxx;
384
385 void dotab()
386 { int i;
387 FILE *f;
388
389 void X(string d, string e, string c) { debtab[i]=d; cdxxx[i]=c; elxxx[i]=e; }
390
391 for (i = 0; i < OPMAX; i++)
392 {
393 switch (i)
394 {
395 case OPunde: X("unde", "elerr", "cderr"); break;
396 case OPadd: X("+", "eladd", "cdorth"); break;
397 case OPmul: X("*", "elmul", "cdmul"); break;
398 case OPand: X("&", "elbitwise", "cdorth"); break;
399 case OPmin: X("-", "elmin", "cdorth"); break;
400 case OPnot: X("!", "elnot", "cdnot"); break;
401 case OPcom: X("~", "elcom", "cdcom"); break;
402 case OPcond: X("?", "elcond", "cdcond"); break;
403 case OPcomma: X(",", "elcomma", "cdcomma"); break;
404 case OPremquo: X("/%", "elremquo", "cdmul"); break;
405 case OPdiv: X("/", "eldiv", "cdmul"); break;
406 case OPmod: X("%", "elmod", "cdmul"); break;
407 case OPxor: X("^", "elxor", "cdorth"); break;
408 case OPstring: X("string", "elstring", "cderr"); break;
409 case OPrelconst: X("relconst", "elzot", "cdrelconst"); break;
410 case OPinp: X("inp", "elzot", "cdport"); break;
411 case OPoutp: X("outp", "elzot", "cdport"); break;
412 case OPasm: X("asm", "elzot", "cdasm"); break;
413 case OPinfo: X("info", "elinfo", "cdinfo"); break;
414 case OPdctor: X("dctor", "elzot", "cddctor"); break;
415 case OPddtor: X("ddtor", "elddtor", "cdddtor"); break;
416 case OPctor: X("ctor", "elinfo", "cdctor"); break;
417 case OPdtor: X("dtor", "elinfo", "cddtor"); break;
418 case OPmark: X("mark", "elinfo", "cdmark"); break;
419 case OPvoid: X("void", "elzot", "cdvoid"); break;
420 case OPhalt: X("halt", "elzot", "cdhalt"); break;
421 case OPnullptr: X("nullptr", "elerr", "cderr"); break;
422 case OPpair: X("pair", "elpair", "cdpair"); break;
423 case OPrpair: X("rpair", "elpair", "cdpair"); break;
424
425 case OPor: X("|", "elor", "cdorth"); break;
426 case OPoror: X("||", "eloror", "cdloglog"); break;
427 case OPandand: X("&&", "elandand", "cdloglog"); break;
428 case OProl: X("<<|", "elshl", "cdshift"); break;
429 case OPror: X(">>|", "elshl", "cdshift"); break;
430 case OPshl: X("<<", "elshl", "cdshift"); break;
431 case OPshr: X(">>>", "elshr", "cdshift"); break;
432 case OPashr: X(">>", "elshr", "cdshift"); break;
433 case OPbit: X("bit", "elbit", "cderr"); break;
434 case OPind: X("*", "elind", "cdind"); break;
435 case OPaddr: X("&", "eladdr", "cderr"); break;
436 case OPneg: X("-", "elneg", "cdneg"); break;
437 case OPuadd: X("+", "elzot", "cderr"); break;
438 case OPabs: X("abs", "evalu8", "cdabs"); break;
439 case OPsqrt: X("sqrt", "evalu8", "cdneg"); break;
440 case OPsin: X("sin", "evalu8", "cdneg"); break;
441 case OPcos: X("cos", "evalu8", "cdneg"); break;
442 case OPscale: X("scale", "elzot", "cdscale"); break;
443 case OPyl2x: X("yl2x", "elzot", "cdscale"); break;
444 case OPyl2xp1: X("yl2xp1", "elzot", "cdscale"); break;
445 case OPcmpxchg: X("cas", "elzot", "cdcmpxchg"); break;
446 case OPrint: X("rint", "evalu8", "cdneg"); break;
447 case OPrndtol: X("rndtol", "evalu8", "cdrndtol"); break;
448 case OPstrlen: X("strlen", "elzot", "cdstrlen"); break;
449 case OPstrcpy: X("strcpy", "elstrcpy", "cdstrcpy"); break;
450 case OPmemcpy: X("memcpy", "elmemcpy", "cdmemcpy"); break;
451 case OPmemset: X("memset", "elmemset", "cdmemset"); break;
452 case OPstrcat: X("strcat", "elzot", "cderr"); break;
453 case OPstrcmp: X("strcmp", "elstrcmp", "cdstrcmp"); break;
454 case OPmemcmp: X("memcmp", "elmemcmp", "cdmemcmp"); break;
455 case OPsetjmp: X("setjmp", "elzot", "cdsetjmp"); break;
456 case OPnegass: X("negass", "elnegass", "cdaddass"); break;
457 case OPpreinc: X("U++", "elzot", "cderr"); break;
458 case OPpredec: X("U--", "elzot", "cderr"); break;
459 case OPstreq: X("streq", "elstruct", "cdstreq"); break;
460 case OPpostinc: X("++", "elpost", "cdpost"); break;
461 case OPpostdec: X("--", "elpost", "cdpost"); break;
462 case OPeq: X("=", "eleq", "cdeq"); break;
463 case OPaddass: X("+=", "elopass", "cdaddass"); break;
464 case OPminass: X("-=", "elopass", "cdaddass"); break;
465 case OPmulass: X("*=", "elopass", "cdmulass"); break;
466 case OPdivass: X("/=", "elopass", "cdmulass"); break;
467 case OPmodass: X("%=", "elopass", "cdmulass"); break;
468 case OPshrass: X(">>>=", "elopass", "cdshass"); break;
469 case OPashrass: X(">>=", "elopass", "cdshass"); break;
470 case OPshlass: X("<<=", "elopass", "cdshass"); break;
471 case OPandass: X("&=", "elopass", "cdaddass"); break;
472 case OPxorass: X("^=", "elopass", "cdaddass"); break;
473 case OPorass: X("|=", "elopass", "cdaddass"); break;
474
475 case OPle: X("<=", "elcmp", "cdcmp"); break;
476 case OPgt: X(">", "elcmp", "cdcmp"); break;
477 case OPlt: X("<", "elcmp", "cdcmp"); break;
478 case OPge: X(">=", "elcmp", "cdcmp"); break;
479 case OPeqeq: X("==", "elcmp", "cdcmp"); break;
480 case OPne: X("!=", "elcmp", "cdcmp"); break;
481
482 case OPunord: X("!<>=", "elcmp", "cdcmp"); break;
483 case OPlg: X("<>", "elcmp", "cdcmp"); break;
484 case OPleg: X("<>=", "elcmp", "cdcmp"); break;
485 case OPule: X("!>", "elcmp", "cdcmp"); break;
486 case OPul: X("!>=", "elcmp", "cdcmp"); break;
487 case OPuge: X("!<", "elcmp", "cdcmp"); break;
488 case OPug: X("!<=", "elcmp", "cdcmp"); break;
489 case OPue: X("!<>", "elcmp", "cdcmp"); break;
490 case OPngt: X("~>", "elcmp", "cdcmp"); break;
491 case OPnge: X("~>=", "elcmp", "cdcmp"); break;
492 case OPnlt: X("~<", "elcmp", "cdcmp"); break;
493 case OPnle: X("~<=", "elcmp", "cdcmp"); break;
494 case OPord: X("~!<>=", "elcmp", "cdcmp"); break;
495 case OPnlg: X("~<>", "elcmp", "cdcmp"); break;
496 case OPnleg: X("~<>=", "elcmp", "cdcmp"); break;
497 case OPnule: X("~!>", "elcmp", "cdcmp"); break;
498 case OPnul: X("~!>=", "elcmp", "cdcmp"); break;
499 case OPnuge: X("~!<", "elcmp", "cdcmp"); break;
500 case OPnug: X("~!<=", "elcmp", "cdcmp"); break;
501 case OPnue: X("~!<>", "elcmp", "cdcmp"); break;
502
503 case OPvp_fp: X("vptrfptr", "elvptrfptr", "cdcnvt"); break;
504 case OPcvp_fp: X("cvptrfptr", "elvptrfptr", "cdcnvt"); break;
505 case OPoffset: X("offset", "ellngsht", "cdlngsht"); break;
506 case OPnp_fp: X("ptrlptr", "elptrlptr", "cdshtlng"); break;
507 case OPnp_f16p: X("tofar16", "elzot", "cdfar16"); break;
508 case OPf16p_np: X("fromfar16", "elzot", "cdfar16"); break;
509
510 case OPs16_32: X("s16_32", "evalu8", "cdshtlng"); break;
511 case OPu16_32: X("u16_32", "evalu8", "cdshtlng"); break;
512 case OPd_s32: X("d_s32", "evalu8", "cdcnvt"); break;
513 case OPb_8: X("b_8", "evalu8", "cdcnvt"); break;
514 case OPs32_d: X("s32_d", "evalu8", "cdcnvt"); break;
515 case OPd_s16: X("d_s16", "evalu8", "cdcnvt"); break;
516 case OPs16_d: X("s16_d", "evalu8", "cdcnvt"); break;
517 case OPd_u16: X("d_u16", "evalu8", "cdcnvt"); break;
518 case OPu16_d: X("u16_d", "evalu8", "cdcnvt"); break;
519 case OPd_u32: X("d_u32", "evalu8", "cdcnvt"); break;
520 case OPu32_d: X("u32_d", "evalu8", "cdcnvt"); break;
521 case OP32_16: X("32_16", "ellngsht", "cdlngsht"); break;
522 case OPd_f: X("d_f", "evalu8", "cdcnvt"); break;
523 case OPf_d: X("f_d", "evalu8", "cdcnvt"); break;
524 case OPd_ld: X("d_ld", "evalu8", "cdcnvt"); break;
525 case OPld_d: X("ld_d", "evalu8", "cdcnvt"); break;
526 case OPc_r: X("c_r", "elc_r", "cdconvt87"); break;
527 case OPc_i: X("c_i", "elc_i", "cdconvt87"); break;
528 case OPu8_16: X("u8_16", "elbyteint", "cdbyteint"); break;
529 case OPs8_16: X("s8_16", "elbyteint", "cdbyteint"); break;
530 case OP16_8: X("16_8", "ellngsht", "cdlngsht"); break;
531 case OPu32_64: X("u32_64", "el32_64", "cdshtlng"); break;
532 case OPs32_64: X("s32_64", "el32_64", "cdshtlng"); break;
533 case OP64_32: X("64_32", "el64_32", "cdlngsht"); break;
534 case OPu64_128: X("u64_128", "evalu8", "cdshtlng"); break;
535 case OPs64_128: X("s64_128", "evalu8", "cdshtlng"); break;
536 case OP128_64: X("128_64", "el64_32", "cdlngsht"); break;
537 case OPmsw: X("msw", "elmsw", "cdmsw"); break;
538
539 case OPd_s64: X("d_s64", "evalu8", "cdcnvt"); break;
540 case OPs64_d: X("s64_d", "evalu8", "cdcnvt"); break;
541 case OPd_u64: X("d_u64", "evalu8", "cdcnvt"); break;
542 case OPu64_d: X("u64_d", "elu64_d", "cdcnvt"); break;
543 case OPld_u64: X("ld_u64", "evalu8", "cdcnvt"); break;
544 case OPparam: X("param", "elparam", "cderr"); break;
545 case OPsizeof: X("sizeof", "elzot", "cderr"); break;
546 case OParrow: X("->", "elzot", "cderr"); break;
547 case OParrowstar: X("->*", "elzot", "cderr"); break;
548 case OPcolon: X("colon", "elzot", "cderr"); break;
549 case OPcolon2: X("colon2", "elzot", "cderr"); break;
550 case OPbool: X("bool", "elbool", "cdnot"); break;
551 case OPcall: X("call", "elcall", "cdfunc"); break;
552 case OPucall: X("ucall", "elcall", "cdfunc"); break;
553 case OPcallns: X("callns", "elcall", "cdfunc"); break;
554 case OPucallns: X("ucallns", "elcall", "cdfunc"); break;
555 case OPstrpar: X("strpar", "elstruct", "cderr"); break;
556 case OPstrctor: X("strctor", "elzot", "cderr"); break;
557 case OPstrthis: X("strthis", "elzot", "cdstrthis"); break;
558 case OPconst: X("const", "elerr", "cderr"); break;
559 case OPvar: X("var", "elerr", "loaddata"); break;
560 case OPreg: X("reg", "elerr", "cderr"); break;
561 case OPnew: X("new", "elerr", "cderr"); break;
562 case OPanew: X("new[]", "elerr", "cderr"); break;
563 case OPdelete: X("delete", "elerr", "cderr"); break;
564 case OPadelete: X("delete[]", "elerr", "cderr"); break;
565 case OPbrack: X("brack", "elerr", "cderr"); break;
566 case OPframeptr: X("frameptr", "elzot", "cdframeptr"); break;
567 case OPgot: X("got", "elzot", "cdgot"); break;
568
569 case OPbsf: X("bsf", "elzot", "cdbscan"); break;
570 case OPbsr: X("bsr", "elzot", "cdbscan"); break;
571 case OPbtst: X("btst", "elzot", "cdbtst"); break;
572 case OPbt: X("bt", "elzot", "cdbt"); break;
573 case OPbtc: X("btc", "elzot", "cdbt"); break;
574 case OPbtr: X("btr", "elzot", "cdbt"); break;
575 case OPbts: X("bts", "elzot", "cdbt"); break;
576
577 case OPbswap: X("bswap", "evalu8", "cdbswap"); break;
578 case OPpopcnt: X("popcnt", "evalu8", "cdpopcnt"); break;
579 case OPvector: X("vector", "elzot", "cdvector"); break;
580 case OPvecsto: X("vecsto", "elzot", "cdvecsto"); break;
581 case OPvecfill: X("vecfill", "elzot", "cdvecfill"); break;
582 case OPva_start: X("va_start", "elvalist", "cderr"); break;
583 case OPprefetch: X("prefetch", "elzot", "cdprefetch"); break;
584
585 default:
586 printf("opcode hole x%x\n",i);
587 exit(EXIT_FAILURE);
588 }
589 }
590
591 fprintf(fdeb,"extern (C++) __gshared const(char)*[OPMAX] debtab = \n\t[\n");
592 for (i = 0; i < OPMAX - 1; i++)
593 fprintf(fdeb,"\t\"%.*s\",\n",cast(int)debtab[i].length, debtab[i].ptr);
594 fprintf(fdeb,"\t\"%.*s\"\n\t];\n",cast(int)debtab[i].length, debtab[i].ptr);
595
596 f = fopen("cdxxx.d","w");
597 fprintf(f,"__gshared void function (ref CodeBuilder,elem *,regm_t *)[OPMAX] cdxxx = \n\t[\n");
598 for (i = 0; i < OPMAX - 1; i++)
599 fprintf(f,"\t&%.*s,\n",cast(int)cdxxx[i].length, cdxxx[i].ptr);
600 fprintf(f,"\t&%.*s\n\t];\n", cast(int)cdxxx[i].length, cdxxx[i].ptr);
601 fclose(f);
602
603 static if (1)
604 {
605 {
606 f = fopen("elxxx.d","w");
607 fprintf(f,"extern (C++) __gshared elem *function(elem *, goal_t)[OPMAX] elxxx = \n\t[\n");
608 for (i = 0; i < OPMAX - 1; i++)
609 fprintf(f,"\t&%s,\n",elxxx[i].ptr);
610 fprintf(f,"\t&%s\n\t];\n",elxxx[i].ptr);
611 fclose(f);
612 }
613 }
614 else
615 {
616 {
617 f = fopen("elxxx.c","w");
618 fprintf(f,"static elem *(*elxxx[OPMAX]) (elem *, goal_t) = \n\t{\n");
619 for (i = 0; i < OPMAX - 1; i++)
620 fprintf(f,"\t%s,\n",elxxx[i].ptr);
621 fprintf(f,"\t%s\n\t};\n",elxxx[i].ptr);
622 fclose(f);
623 }
624 }
625 }
626
627 void fltables()
628 { FILE *f;
629 int i;
630 char[FLMAX] segfl, datafl, stackfl, flinsymtab;
631
632 static char[] indatafl = /* is FLxxxx a data type? */
633 [ FLdata,FLudata,FLreg,FLpseudo,FLauto,FLfast,FLpara,FLextern,
634 FLcs,FLfltreg,FLallocatmp,FLdatseg,FLtlsdata,FLbprel,
635 FLstack,FLregsave,FLfuncarg,
636 FLndp,
637 ];
638 static char[] indatafl_s = [ FLfardata, ];
639
640 static char[] instackfl = /* is FLxxxx a stack data type? */
641 [ FLauto,FLfast,FLpara,FLcs,FLfltreg,FLallocatmp,FLbprel,FLstack,FLregsave,
642 FLfuncarg,
643 FLndp,
644 ];
645
646 static char[] inflinsymtab = /* is FLxxxx in the symbol table? */
647 [ FLdata,FLudata,FLreg,FLpseudo,FLauto,FLfast,FLpara,FLextern,FLfunc,
648 FLtlsdata,FLbprel,FLstack ];
649 static char[] inflinsymtab_s = [ FLfardata,FLcsdata, ];
650
651 for (i = 0; i < FLMAX; i++)
652 datafl[i] = stackfl[i] = flinsymtab[i] = 0;
653
654 for (i = 0; i < indatafl.length; i++)
655 datafl[indatafl[i]] = 1;
656
657 for (i = 0; i < instackfl.length; i++)
658 stackfl[instackfl[i]] = 1;
659
660 for (i = 0; i < inflinsymtab.length; i++)
661 flinsymtab[inflinsymtab[i]] = 1;
662
663 for (i = 0; i < indatafl_s.length; i++)
664 datafl[indatafl_s[i]] = 1;
665
666 for (i = 0; i < inflinsymtab_s.length; i++)
667 flinsymtab[inflinsymtab_s[i]] = 1;
668
669 /* Segment registers */
670 enum ES = 0;
671 enum CS = 1;
672 enum SS = 2;
673 enum DS = 3;
674
675 for (i = 0; i < FLMAX; i++)
676 { switch (i)
677 {
678 case 0: segfl[i] = cast(byte)-1; break;
679 case FLconst: segfl[i] = cast(byte)-1; break;
680 case FLoper: segfl[i] = cast(byte)-1; break;
681 case FLfunc: segfl[i] = CS; break;
682 case FLdata: segfl[i] = DS; break;
683 case FLudata: segfl[i] = DS; break;
684 case FLreg: segfl[i] = cast(byte)-1; break;
685 case FLpseudo: segfl[i] = cast(byte)-1; break;
686 case FLauto: segfl[i] = SS; break;
687 case FLfast: segfl[i] = SS; break;
688 case FLstack: segfl[i] = SS; break;
689 case FLbprel: segfl[i] = SS; break;
690 case FLpara: segfl[i] = SS; break;
691 case FLextern: segfl[i] = DS; break;
692 case FLcode: segfl[i] = CS; break;
693 case FLblock: segfl[i] = CS; break;
694 case FLblockoff: segfl[i] = CS; break;
695 case FLcs: segfl[i] = SS; break;
696 case FLregsave: segfl[i] = SS; break;
697 case FLndp: segfl[i] = SS; break;
698 case FLswitch: segfl[i] = cast(byte)-1; break;
699 case FLfltreg: segfl[i] = SS; break;
700 case FLoffset: segfl[i] = cast(byte)-1; break;
701 case FLfardata: segfl[i] = cast(byte)-1; break;
702 case FLcsdata: segfl[i] = CS; break;
703 case FLdatseg: segfl[i] = DS; break;
704 case FLctor: segfl[i] = cast(byte)-1; break;
705 case FLdtor: segfl[i] = cast(byte)-1; break;
706 case FLdsymbol: segfl[i] = cast(byte)-1; break;
707 case FLgot: segfl[i] = cast(byte)-1; break;
708 case FLgotoff: segfl[i] = cast(byte)-1; break;
709 case FLlocalsize: segfl[i] = cast(byte)-1; break;
710 case FLtlsdata: segfl[i] = cast(byte)-1; break;
711 case FLframehandler: segfl[i] = cast(byte)-1; break;
712 case FLasm: segfl[i] = cast(byte)-1; break;
713 case FLallocatmp: segfl[i] = SS; break;
714 case FLfuncarg: segfl[i] = SS; break;
715 default:
716 printf("error in segfl[%d]\n", i);
717 exit(1);
718 }
719 }
720
721 f = fopen("fltables.d","w");
722 fprintf(f, "extern (C++) __gshared {\n");
723
724 fprintf(f,"ubyte[FLMAX] datafl = \n\t[ ");
725 for (i = 0; i < FLMAX - 1; i++)
726 fprintf(f,"cast(ubyte)%d,",datafl[i]);
727 fprintf(f,"cast(ubyte)%d ];\n",datafl[i]);
728
729 fprintf(f,"ubyte[FLMAX] stackfl = \n\t[ ");
730 for (i = 0; i < FLMAX - 1; i++)
731 fprintf(f,"cast(ubyte)%d,",stackfl[i]);
732 fprintf(f,"cast(ubyte)%d ];\n",stackfl[i]);
733
734 fprintf(f,"ubyte[FLMAX] segfl = \n\t[ ");
735 for (i = 0; i < FLMAX - 1; i++)
736 fprintf(f,"cast(ubyte)%d,",segfl[i]);
737 fprintf(f,"cast(ubyte)%d ];\n",segfl[i]);
738
739 fprintf(f,"ubyte[FLMAX] flinsymtab = \n\t[ ");
740 for (i = 0; i < FLMAX - 1; i++)
741 fprintf(f,"cast(ubyte)%d,",flinsymtab[i]);
742 fprintf(f,"cast(ubyte)%d ];\n",flinsymtab[i]);
743
744 fprintf(f, "}\n");
745 fclose(f);
746 }
747
748 void dotytab()
749 {
750 static tym_t[] _ptr = [ TYnptr ];
751 static tym_t[] _ptr_nflat= [ TYsptr,TYcptr,TYf16ptr,TYfptr,TYhptr,TYvptr ];
752 static tym_t[] _real = [ TYfloat,TYdouble,TYdouble_alias,TYldouble,
753 TYfloat4,TYdouble2,
754 TYfloat8,TYdouble4,
755 TYfloat16,TYdouble8,
756 ];
757 static tym_t[] _imaginary = [
758 TYifloat,TYidouble,TYildouble,
759 ];
760 static tym_t[] _complex = [
761 TYcfloat,TYcdouble,TYcldouble,
762 ];
763 static tym_t[] _integral = [ TYbool,TYchar,TYschar,TYuchar,TYshort,
764 TYwchar_t,TYushort,TYenum,TYint,TYuint,
765 TYlong,TYulong,TYllong,TYullong,TYdchar,
766 TYschar16,TYuchar16,TYshort8,TYushort8,
767 TYlong4,TYulong4,TYllong2,TYullong2,
768 TYschar32,TYuchar32,TYshort16,TYushort16,
769 TYlong8,TYulong8,TYllong4,TYullong4,
770 TYschar64,TYuchar64,TYshort32,TYushort32,
771 TYlong16,TYulong16,TYllong8,TYullong8,
772 TYchar16,TYcent,TYucent,
773 ];
774 static tym_t[] _ref = [ TYnref,TYref ];
775 static tym_t[] _func = [ TYnfunc,TYnpfunc,TYnsfunc,TYifunc,TYmfunc,TYjfunc,TYhfunc ];
776 static tym_t[] _ref_nflat = [ TYfref ];
777 static tym_t[] _func_nflat= [ TYffunc,TYfpfunc,TYf16func,TYfsfunc,TYnsysfunc,TYfsysfunc, ];
778 static tym_t[] _uns = [ TYuchar,TYushort,TYuint,TYulong,
779 TYwchar_t,
780 TYuchar16,TYushort8,TYulong4,TYullong2,
781 TYdchar,TYullong,TYucent,TYchar16 ];
782 static tym_t[] _mptr = [ TYmemptr ];
783 static tym_t[] _nullptr = [ TYnullptr ];
784 static tym_t[] _fv = [ TYfptr, TYvptr ];
785 static tym_t[] _farfunc = [ TYffunc,TYfpfunc,TYfsfunc,TYfsysfunc ];
786 static tym_t[] _pasfunc = [ TYnpfunc,TYnsfunc,TYmfunc,TYjfunc ];
787 static tym_t[] _pasfunc_nf = [ TYfpfunc,TYf16func,TYfsfunc, ];
788 static tym_t[] _revfunc = [ TYnpfunc,TYjfunc ];
789 static tym_t[] _revfunc_nf = [ TYfpfunc,TYf16func, ];
790 static tym_t[] _short = [ TYbool,TYchar,TYschar,TYuchar,TYshort,
791 TYwchar_t,TYushort,TYchar16 ];
792 static tym_t[] _aggregate = [ TYstruct,TYarray ];
793 static tym_t[] _xmmreg = [
794 TYfloat,TYdouble,TYifloat,TYidouble,
795 TYfloat4,TYdouble2,
796 TYschar16,TYuchar16,TYshort8,TYushort8,
797 TYlong4,TYulong4,TYllong2,TYullong2,
798 TYfloat8,TYdouble4,
799 TYschar32,TYuchar32,TYshort16,TYushort16,
800 TYlong8,TYulong8,TYllong4,TYullong4,
801 TYschar64,TYuchar64,TYshort32,TYushort32,
802 TYlong16,TYulong16,TYllong8,TYullong8,
803 TYfloat16,TYdouble8,
804 ];
805 static tym_t[] _simd = [
806 TYfloat4,TYdouble2,
807 TYschar16,TYuchar16,TYshort8,TYushort8,
808 TYlong4,TYulong4,TYllong2,TYullong2,
809 TYfloat8,TYdouble4,
810 TYschar32,TYuchar32,TYshort16,TYushort16,
811 TYlong8,TYulong8,TYllong4,TYullong4,
812 TYschar64,TYuchar64,TYshort32,TYushort32,
813 TYlong16,TYulong16,TYllong8,TYullong8,
814 TYfloat16,TYdouble8,
815 ];
816
817 struct TypeTab
818 {
819 string str; /* name of type */
820 tym_t ty; /* TYxxxx */
821 tym_t unsty; /* conversion to unsigned type */
822 tym_t relty; /* type for relaxed type checking */
823 int size;
824 int debtyp; /* Codeview 1 type in debugger record */
825 int debtyp4; /* Codeview 4 type in debugger record */
826 }
827 static TypeTab[] typetab =
828 [
829 /* Note that chars are signed, here */
830 {"bool", TYbool, TYbool, TYchar, 1, 0x80, 0x30},
831 {"char", TYchar, TYuchar, TYchar, 1, 0x80, 0x70},
832 {"signed char", TYschar, TYuchar, TYchar, 1, 0x80, 0x10},
833 {"unsigned char",TYuchar, TYuchar, TYchar, 1, 0x84, 0x20},
834 {"char16_t", TYchar16, TYchar16, TYint, 2, 0x85, 0x21},
835 {"short", TYshort, TYushort, TYint, SHORTSIZE, 0x81,0x11},
836 {"wchar_t", TYwchar_t, TYwchar_t, TYint, SHORTSIZE, 0x85,0x71},
837 {"unsigned short",TYushort, TYushort, TYint, SHORTSIZE, 0x85,0x21},
838
839 // These values are adjusted for 32 bit ints in cv_init() and util_set32()
840 {"enum", TYenum, TYuint, TYint, -1, 0x81,0x72},
841 {"int", TYint, TYuint, TYint, 2, 0x81,0x72},
842 {"unsigned", TYuint, TYuint, TYint, 2, 0x85,0x73},
843
844 {"long", TYlong, TYulong, TYlong, LONGSIZE, 0x82,0x12},
845 {"unsigned long",TYulong, TYulong, TYlong, LONGSIZE, 0x86,0x22},
846 {"dchar", TYdchar, TYdchar, TYlong, 4, 0x86,0x22},
847 {"long long", TYllong, TYullong, TYllong, LLONGSIZE, 0x82,0x13},
848 {"uns long long",TYullong, TYullong, TYllong, LLONGSIZE, 0x86,0x23},
849 {"cent", TYcent, TYucent, TYcent, 16, 0x82,0x603},
850 {"ucent", TYucent, TYucent, TYcent, 16, 0x86,0x603},
851 {"float", TYfloat, TYfloat, TYfloat, FLOATSIZE, 0x88,0x40},
852 {"double", TYdouble, TYdouble, TYdouble, DOUBLESIZE,0x89,0x41},
853 {"double alias", TYdouble_alias, TYdouble_alias, TYdouble_alias,8, 0x89,0x41},
854 {"long double", TYldouble, TYldouble, TYldouble, -1, 0x89,0x42},
855
856 {"imaginary float", TYifloat, TYifloat, TYifloat, FLOATSIZE, 0x88,0x40},
857 {"imaginary double", TYidouble, TYidouble, TYidouble, DOUBLESIZE,0x89,0x41},
858 {"imaginary long double",TYildouble, TYildouble, TYildouble, -1,0x89,0x42},
859
860 {"complex float", TYcfloat, TYcfloat, TYcfloat, 2*FLOATSIZE, 0x88,0x50},
861 {"complex double", TYcdouble, TYcdouble, TYcdouble, 2*DOUBLESIZE,0x89,0x51},
862 {"complex long double", TYcldouble, TYcldouble, TYcldouble, -1,0x89,0x52},
863
864 {"float[4]", TYfloat4, TYfloat4, TYfloat4, 16, 0, 0},
865 {"double[2]", TYdouble2, TYdouble2, TYdouble2, 16, 0, 0},
866 {"signed char[16]", TYschar16, TYuchar16, TYschar16, 16, 0, 0},
867 {"unsigned char[16]", TYuchar16, TYuchar16, TYuchar16, 16, 0, 0},
868 {"short[8]", TYshort8, TYushort8, TYshort8, 16, 0, 0},
869 {"unsigned short[8]", TYushort8, TYushort8, TYushort8, 16, 0, 0},
870 {"long[4]", TYlong4, TYulong4, TYlong4, 16, 0, 0},
871 {"unsigned long[4]", TYulong4, TYulong4, TYulong4, 16, 0, 0},
872 {"long long[2]", TYllong2, TYullong2, TYllong2, 16, 0, 0},
873 {"unsigned long long[2]", TYullong2, TYullong2, TYullong2, 16, 0, 0},
874
875 {"float[8]", TYfloat8, TYfloat8, TYfloat8, 32, 0, 0},
876 {"double[4]", TYdouble4, TYdouble4, TYdouble4, 32, 0, 0},
877 {"signed char[32]", TYschar32, TYuchar32, TYschar32, 32, 0, 0},
878 {"unsigned char[32]", TYuchar32, TYuchar32, TYuchar32, 32, 0, 0},
879 {"short[16]", TYshort16, TYushort16, TYshort16, 32, 0, 0},
880 {"unsigned short[16]", TYushort16, TYushort16, TYushort16, 32, 0, 0},
881 {"long[8]", TYlong8, TYulong8, TYlong8, 32, 0, 0},
882 {"unsigned long[8]", TYulong8, TYulong8, TYulong8, 32, 0, 0},
883 {"long long[4]", TYllong4, TYullong4, TYllong4, 32, 0, 0},
884 {"unsigned long long[4]", TYullong4, TYullong4, TYullong4, 32, 0, 0},
885
886 {"float[16]", TYfloat16, TYfloat16, TYfloat16, 64, 0, 0},
887 {"double[8]", TYdouble8, TYdouble8, TYdouble8, 64, 0, 0},
888 {"signed char[64]", TYschar64, TYuchar64, TYschar64, 64, 0, 0},
889 {"unsigned char[64]", TYuchar64, TYuchar64, TYuchar64, 64, 0, 0},
890 {"short[32]", TYshort32, TYushort32, TYshort32, 64, 0, 0},
891 {"unsigned short[32]", TYushort32, TYushort32, TYushort32, 64, 0, 0},
892 {"long[16]", TYlong16, TYulong16, TYlong16, 64, 0, 0},
893 {"unsigned long[16]", TYulong16, TYulong16, TYulong16, 64, 0, 0},
894 {"long long[8]", TYllong8, TYullong8, TYllong8, 64, 0, 0},
895 {"unsigned long long[8]", TYullong8, TYullong8, TYullong8, 64, 0, 0},
896
897 {"nullptr_t", TYnullptr, TYnullptr, TYptr, 2, 0x20, 0x100},
898 {"*", TYnptr, TYnptr, TYnptr, 2, 0x20, 0x100},
899 {"&", TYref, TYref, TYref, -1, 0, 0},
900 {"void", TYvoid, TYvoid, TYvoid, -1, 0x85, 3},
901 {"struct", TYstruct, TYstruct, TYstruct, -1, 0, 0},
902 {"array", TYarray, TYarray, TYarray, -1, 0x78, 0},
903 {"C func", TYnfunc, TYnfunc, TYnfunc, -1, 0x63, 0},
904 {"Pascal func", TYnpfunc, TYnpfunc, TYnpfunc, -1, 0x74, 0},
905 {"std func", TYnsfunc, TYnsfunc, TYnsfunc, -1, 0x63, 0},
906 {"*", TYptr, TYptr, TYptr, 2, 0x20, 0x100},
907 {"member func", TYmfunc, TYmfunc, TYmfunc, -1, 0x64, 0},
908 {"D func", TYjfunc, TYjfunc, TYjfunc, -1, 0x74, 0},
909 {"C func", TYhfunc, TYhfunc, TYhfunc, -1, 0, 0},
910 {"__near &", TYnref, TYnref, TYnref, 2, 0, 0},
911
912 {"__ss *", TYsptr, TYsptr, TYsptr, 2, 0x20, 0x100},
913 {"__cs *", TYcptr, TYcptr, TYcptr, 2, 0x20, 0x100},
914 {"__far16 *", TYf16ptr, TYf16ptr, TYf16ptr, 4, 0x40, 0x200},
915 {"__far *", TYfptr, TYfptr, TYfptr, 4, 0x40, 0x200},
916 {"__huge *", TYhptr, TYhptr, TYhptr, 4, 0x40, 0x300},
917 {"__handle *", TYvptr, TYvptr, TYvptr, 4, 0x40, 0x200},
918 {"far C func", TYffunc, TYffunc, TYffunc, -1, 0x64, 0},
919 {"far Pascal func", TYfpfunc, TYfpfunc, TYfpfunc, -1, 0x73, 0},
920 {"far std func", TYfsfunc, TYfsfunc, TYfsfunc, -1, 0x64, 0},
921 {"_far16 Pascal func", TYf16func, TYf16func, TYf16func, -1, 0x63, 0},
922 {"sys func", TYnsysfunc, TYnsysfunc,TYnsysfunc, -1, 0x63, 0},
923 {"far sys func", TYfsysfunc, TYfsysfunc,TYfsysfunc, -1, 0x64, 0},
924 {"__far &", TYfref, TYfref, TYfref, 4, 0, 0},
925
926 {"interrupt func", TYifunc, TYifunc, TYifunc, -1, 0x64, 0},
927 {"memptr", TYmemptr, TYmemptr, TYmemptr, -1, 0, 0},
928 {"ident", TYident, TYident, TYident, -1, 0, 0},
929 {"template", TYtemplate, TYtemplate, TYtemplate, -1, 0, 0},
930 {"vtshape", TYvtshape, TYvtshape, TYvtshape, -1, 0, 0},
931 ];
932
933 FILE *f;
934 static uint[64 * 4] tytab;
935 static tym_t[64 * 4] tytouns;
936 static tym_t[TYMAX] _tyrelax;
937 static tym_t[TYMAX] _tyequiv;
938 static byte[64 * 4] _tysize;
939 static string[TYMAX] tystring;
940 static ubyte[TYMAX] dttab;
941 static ushort[TYMAX] dttab4;
942 int i;
943
944 static void T1(tym_t[] arr, uint mask) { for (int i=0; i< arr.length; i++)
945 { tytab[arr[i]] |= mask; }
946 }
947 static void T2(tym_t[] arr, uint mask) { for (int i=0; i< arr.length; i++)
948 { tytab[arr[i]] |= mask; }
949 }
950
951 T1(_ptr, TYFLptr);
952 T1(_ptr_nflat,TYFLptr);
953 T1(_real, TYFLreal);
954 T1(_integral, TYFLintegral);
955 T1(_imaginary,TYFLimaginary);
956 T1(_complex, TYFLcomplex);
957 T1(_uns, TYFLuns);
958 T1(_mptr, TYFLmptr);
959
960 T1(_fv, TYFLfv);
961 T2(_farfunc, TYFLfarfunc);
962 T2(_pasfunc, TYFLpascal);
963 T2(_revfunc, TYFLrevparam);
964 T2(_short, TYFLshort);
965 T2(_aggregate,TYFLaggregate);
966 T2(_ref, TYFLref);
967 T2(_func, TYFLfunc);
968 T2(_nullptr, TYFLnullptr);
969 T2(_pasfunc_nf, TYFLpascal);
970 T2(_revfunc_nf, TYFLrevparam);
971 T2(_ref_nflat, TYFLref);
972 T2(_func_nflat, TYFLfunc);
973 T1(_xmmreg, TYFLxmmreg);
974 T1(_simd, TYFLsimd);
975
976 f = fopen("tytab.d","w");
977
978 fprintf(f,"__gshared uint[256] tytab =\n[ ");
979 for (i = 0; i < tytab.length; i++)
980 { fprintf(f,"0x%02x,",tytab[i]);
981 if ((i & 7) == 7 && i < tytab.length - 1)
982 fprintf(f,"\n ");
983 }
984 fprintf(f,"\n];\n");
985
986 static if (0)
987 {
988 fprintf(f,"__gshared ubyte[TYMAX] tytab2 =\n[ ");
989 for (i = 0; i < tytab2.length; i++)
990 { fprintf(f,"0x%02x,",tytab2[i]);
991 if ((i & 7) == 7 && i < tytab2.length - 1)
992 fprintf(f,"\n ");
993 }
994 fprintf(f,"\n];\n");
995 }
996
997 for (i = 0; i < typetab.length; i++)
998 { tytouns[typetab[i].ty] = typetab[i].unsty;
999 }
1000 fprintf(f,"__gshared tym_t[256] tytouns =\n[ ");
1001 for (i = 0; i < tytouns.length; i++)
1002 { fprintf(f,"0x%02x,",tytouns[i]);
1003 if ((i & 7) == 7 && i < tytouns.length - 1)
1004 fprintf(f,"\n ");
1005 }
1006 fprintf(f,"\n];\n");
1007
1008 for (i = 0; i < typetab.length; i++)
1009 { _tysize[typetab[i].ty | 0x00] = cast(byte)typetab[i].size;
1010 /*printf("_tysize[%d] = %d\n",typetab[i].ty,typetab[i].size);*/
1011 }
1012 fprintf(f,"__gshared byte[256] _tysize =\n[ ");
1013 for (i = 0; i < _tysize.length; i++)
1014 { fprintf(f,"%d,",_tysize[i]);
1015 if ((i & 7) == 7 && i < _tysize.length - 1)
1016 fprintf(f,"\n ");
1017 }
1018 fprintf(f,"\n];\n");
1019
1020 for (i = 0; i < _tysize.length; i++)
1021 _tysize[i] = 0;
1022 for (i = 0; i < typetab.length; i++)
1023 { byte sz = cast(byte)typetab[i].size;
1024 switch (typetab[i].ty)
1025 {
1026 case TYldouble:
1027 case TYildouble:
1028 case TYcldouble:
1029 static if (TARGET_OSX)
1030 {
1031 sz = 16;
1032 }
1033 else static if (TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_DRAGONFLYBSD || TARGET_SOLARIS)
1034 {
1035 sz = 4;
1036 }
1037 else static if (TARGET_WINDOS)
1038 {
1039 sz = 2;
1040 }
1041 else
1042 {
1043 static assert(0, "fix this");
1044 }
1045 break;
1046
1047 case TYcent:
1048 case TYucent:
1049 sz = 8;
1050 break;
1051
1052 default:
1053 break;
1054 }
1055 _tysize[typetab[i].ty | 0x00] = sz;
1056 /*printf("_tyalignsize[%d] = %d\n",typetab[i].ty,typetab[i].size);*/
1057 }
1058
1059 fprintf(f,"__gshared byte[256] _tyalignsize =\n[ ");
1060 for (i = 0; i < _tysize.length; i++)
1061 { fprintf(f,"%d,",_tysize[i]);
1062 if ((i & 7) == 7 && i < _tysize.length - 1)
1063 fprintf(f,"\n ");
1064 }
1065 fprintf(f,"\n];\n");
1066
1067 for (i = 0; i < typetab.length; i++)
1068 { _tyrelax[typetab[i].ty] = typetab[i].relty;
1069 /*printf("_tyrelax[%d] = %d\n",typetab[i].ty,typetab[i].relty);*/
1070 }
1071 fprintf(f,"__gshared ubyte[TYMAX] _tyrelax =\n[ ");
1072 for (i = 0; i < _tyrelax.length; i++)
1073 { fprintf(f,"0x%02x,",_tyrelax[i]);
1074 if ((i & 7) == 7 && i < _tyrelax.length - 1)
1075 fprintf(f,"\n ");
1076 }
1077 fprintf(f,"\n];\n");
1078
1079 /********** tyequiv ************/
1080 for (i = 0; i < _tyequiv.length; i++)
1081 _tyequiv[i] = i;
1082 _tyequiv[TYchar] = TYschar; /* chars are signed by default */
1083
1084 // These values are adjusted in util_set32() for 32 bit ints
1085 _tyequiv[TYint] = TYshort;
1086 _tyequiv[TYuint] = TYushort;
1087
1088 fprintf(f,"__gshared ubyte[TYMAX] tyequiv =\n[ ");
1089 for (i = 0; i < _tyequiv.length; i++)
1090 { fprintf(f,"0x%02x,",_tyequiv[i]);
1091 if ((i & 7) == 7 && i < _tyequiv.length - 1)
1092 fprintf(f,"\n ");
1093 }
1094 fprintf(f,"\n];\n");
1095
1096 for (i = 0; i < typetab.length; i++)
1097 tystring[typetab[i].ty] = typetab[i].str;
1098 fprintf(f,"extern (C) __gshared const(char)*[TYMAX] tystring =\n[ ");
1099 for (i = 0; i < tystring.length; i++)
1100 { fprintf(f,"\"%s\",",tystring[i].ptr);
1101 if ((i & 7) == 7 && i < tystring.length - 1)
1102 fprintf(f,"\n ");
1103 }
1104 fprintf(f,"\n];\n");
1105
1106 for (i = 0; i < typetab.length; i++)
1107 dttab[typetab[i].ty] = cast(ubyte)typetab[i].debtyp;
1108 fprintf(f,"__gshared ubyte[TYMAX] dttab =\n[ ");
1109 for (i = 0; i < dttab.length; i++)
1110 { fprintf(f,"0x%02x,",dttab[i]);
1111 if ((i & 7) == 7 && i < dttab.length - 1)
1112 fprintf(f,"\n ");
1113 }
1114 fprintf(f,"\n];\n");
1115
1116 for (i = 0; i < typetab.length; i++)
1117 dttab4[typetab[i].ty] = cast(ushort)typetab[i].debtyp4;
1118 fprintf(f,"__gshared ushort[TYMAX] dttab4 =\n[ ");
1119 for (i = 0; i < dttab4.length; i++)
1120 { fprintf(f,"0x%02x,",dttab4[i]);
1121 if ((i & 7) == 7 && i < dttab4.length - 1)
1122 fprintf(f,"\n ");
1123 }
1124 fprintf(f,"\n];\n");
1125
1126 fclose(f);
1127 }
The D Programming Language's Unofficial Docs
beta