1 | /* |
2 | ** LuaJIT VM builder: library definition compiler. |
3 | ** Copyright (C) 2005-2014 Mike Pall. See Copyright Notice in luajit.h |
4 | */ |
5 | |
6 | #include "buildvm.h" |
7 | #include "lj_obj.h" |
8 | #include "lj_lib.h" |
9 | |
10 | /* Context for library definitions. */ |
11 | static uint8_t obuf[8192]; |
12 | static uint8_t *optr; |
13 | static char modname[80]; |
14 | static size_t modnamelen; |
15 | static char funcname[80]; |
16 | static int modstate, regfunc; |
17 | static int ffid, recffid, ffasmfunc; |
18 | |
19 | enum { |
20 | REGFUNC_OK, |
21 | REGFUNC_NOREG, |
22 | REGFUNC_NOREGUV |
23 | }; |
24 | |
25 | static void libdef_name(const char *p, int kind) |
26 | { |
27 | size_t n = strlen(p); |
28 | if (kind != LIBINIT_STRING) { |
29 | if (n > modnamelen && p[modnamelen] == '_' && |
30 | !strncmp(p, modname, modnamelen)) { |
31 | p += modnamelen+1; |
32 | n -= modnamelen+1; |
33 | } |
34 | } |
35 | if (n > LIBINIT_MAXSTR) { |
36 | fprintf(stderr, "Error: string too long: '%s'\n" , p); |
37 | exit(1); |
38 | } |
39 | if (optr+1+n+2 > obuf+sizeof(obuf)) { /* +2 for caller. */ |
40 | fprintf(stderr, "Error: output buffer overflow\n" ); |
41 | exit(1); |
42 | } |
43 | *optr++ = (uint8_t)(n | kind); |
44 | memcpy(optr, p, n); |
45 | optr += n; |
46 | } |
47 | |
48 | static void libdef_endmodule(BuildCtx *ctx) |
49 | { |
50 | if (modstate != 0) { |
51 | char line[80]; |
52 | const uint8_t *p; |
53 | int n; |
54 | if (modstate == 1) |
55 | fprintf(ctx->fp, " (lua_CFunction)0" ); |
56 | fprintf(ctx->fp, "\n};\n" ); |
57 | fprintf(ctx->fp, "static const uint8_t %s%s[] = {\n" , |
58 | LABEL_PREFIX_LIBINIT, modname); |
59 | line[0] = '\0'; |
60 | for (n = 0, p = obuf; p < optr; p++) { |
61 | n += sprintf(line+n, "%d," , *p); |
62 | if (n >= 75) { |
63 | fprintf(ctx->fp, "%s\n" , line); |
64 | n = 0; |
65 | line[0] = '\0'; |
66 | } |
67 | } |
68 | fprintf(ctx->fp, "%s%d\n};\n#endif\n\n" , line, LIBINIT_END); |
69 | } |
70 | } |
71 | |
72 | static void libdef_module(BuildCtx *ctx, char *p, int arg) |
73 | { |
74 | UNUSED(arg); |
75 | if (ctx->mode == BUILD_libdef) { |
76 | libdef_endmodule(ctx); |
77 | optr = obuf; |
78 | *optr++ = (uint8_t)ffid; |
79 | *optr++ = (uint8_t)ffasmfunc; |
80 | *optr++ = 0; /* Hash table size. */ |
81 | modstate = 1; |
82 | fprintf(ctx->fp, "#ifdef %sMODULE_%s\n" , LIBDEF_PREFIX, p); |
83 | fprintf(ctx->fp, "#undef %sMODULE_%s\n" , LIBDEF_PREFIX, p); |
84 | fprintf(ctx->fp, "static const lua_CFunction %s%s[] = {\n" , |
85 | LABEL_PREFIX_LIBCF, p); |
86 | } |
87 | modnamelen = strlen(p); |
88 | if (modnamelen > sizeof(modname)-1) { |
89 | fprintf(stderr, "Error: module name too long: '%s'\n" , p); |
90 | exit(1); |
91 | } |
92 | strcpy(modname, p); |
93 | } |
94 | |
95 | static int find_ffofs(BuildCtx *ctx, const char *name) |
96 | { |
97 | int i; |
98 | for (i = 0; i < ctx->nglob; i++) { |
99 | const char *gl = ctx->globnames[i]; |
100 | if (gl[0] == 'f' && gl[1] == 'f' && gl[2] == '_' && !strcmp(gl+3, name)) { |
101 | return (int)((uint8_t *)ctx->glob[i] - ctx->code); |
102 | } |
103 | } |
104 | fprintf(stderr, "Error: undefined fast function %s%s\n" , |
105 | LABEL_PREFIX_FF, name); |
106 | exit(1); |
107 | } |
108 | |
109 | static void libdef_func(BuildCtx *ctx, char *p, int arg) |
110 | { |
111 | if (arg != LIBINIT_CF) |
112 | ffasmfunc++; |
113 | if (ctx->mode == BUILD_libdef) { |
114 | if (modstate == 0) { |
115 | fprintf(stderr, "Error: no module for function definition %s\n" , p); |
116 | exit(1); |
117 | } |
118 | if (regfunc == REGFUNC_NOREG) { |
119 | if (optr+1 > obuf+sizeof(obuf)) { |
120 | fprintf(stderr, "Error: output buffer overflow\n" ); |
121 | exit(1); |
122 | } |
123 | *optr++ = LIBINIT_FFID; |
124 | } else { |
125 | if (arg != LIBINIT_ASM_) { |
126 | if (modstate != 1) fprintf(ctx->fp, ",\n" ); |
127 | modstate = 2; |
128 | fprintf(ctx->fp, " %s%s" , arg ? LABEL_PREFIX_FFH : LABEL_PREFIX_CF, p); |
129 | } |
130 | if (regfunc != REGFUNC_NOREGUV) obuf[2]++; /* Bump hash table size. */ |
131 | libdef_name(regfunc == REGFUNC_NOREGUV ? "" : p, arg); |
132 | } |
133 | } else if (ctx->mode == BUILD_ffdef) { |
134 | fprintf(ctx->fp, "FFDEF(%s)\n" , p); |
135 | } else if (ctx->mode == BUILD_recdef) { |
136 | if (strlen(p) > sizeof(funcname)-1) { |
137 | fprintf(stderr, "Error: function name too long: '%s'\n" , p); |
138 | exit(1); |
139 | } |
140 | strcpy(funcname, p); |
141 | } else if (ctx->mode == BUILD_vmdef) { |
142 | int i; |
143 | for (i = 1; p[i] && modname[i-1]; i++) |
144 | if (p[i] == '_') p[i] = '.'; |
145 | fprintf(ctx->fp, "\"%s\",\n" , p); |
146 | } else if (ctx->mode == BUILD_bcdef) { |
147 | if (arg != LIBINIT_CF) |
148 | fprintf(ctx->fp, ",\n%d" , find_ffofs(ctx, p)); |
149 | } |
150 | ffid++; |
151 | regfunc = REGFUNC_OK; |
152 | } |
153 | |
154 | static uint32_t find_rec(char *name) |
155 | { |
156 | char *p = (char *)obuf; |
157 | uint32_t n; |
158 | for (n = 2; *p; n++) { |
159 | if (strcmp(p, name) == 0) |
160 | return n; |
161 | p += strlen(p)+1; |
162 | } |
163 | if (p+strlen(name)+1 >= (char *)obuf+sizeof(obuf)) { |
164 | fprintf(stderr, "Error: output buffer overflow\n" ); |
165 | exit(1); |
166 | } |
167 | strcpy(p, name); |
168 | return n; |
169 | } |
170 | |
171 | static void libdef_rec(BuildCtx *ctx, char *p, int arg) |
172 | { |
173 | UNUSED(arg); |
174 | if (ctx->mode == BUILD_recdef) { |
175 | char *q; |
176 | uint32_t n; |
177 | for (; recffid+1 < ffid; recffid++) |
178 | fprintf(ctx->fp, ",\n0" ); |
179 | recffid = ffid; |
180 | if (*p == '.') p = funcname; |
181 | q = strchr(p, ' '); |
182 | if (q) *q++ = '\0'; |
183 | n = find_rec(p); |
184 | if (q) |
185 | fprintf(ctx->fp, ",\n0x%02x00+(%s)" , n, q); |
186 | else |
187 | fprintf(ctx->fp, ",\n0x%02x00" , n); |
188 | } |
189 | } |
190 | |
191 | static void memcpy_endian(void *dst, void *src, size_t n) |
192 | { |
193 | union { uint8_t b; uint32_t u; } host_endian; |
194 | host_endian.u = 1; |
195 | if (host_endian.b == LJ_ENDIAN_SELECT(1, 0)) { |
196 | memcpy(dst, src, n); |
197 | } else { |
198 | size_t i; |
199 | for (i = 0; i < n; i++) |
200 | ((uint8_t *)dst)[i] = ((uint8_t *)src)[n-i-1]; |
201 | } |
202 | } |
203 | |
204 | static void libdef_push(BuildCtx *ctx, char *p, int arg) |
205 | { |
206 | UNUSED(arg); |
207 | if (ctx->mode == BUILD_libdef) { |
208 | int len = (int)strlen(p); |
209 | if (*p == '"') { |
210 | if (len > 1 && p[len-1] == '"') { |
211 | p[len-1] = '\0'; |
212 | libdef_name(p+1, LIBINIT_STRING); |
213 | return; |
214 | } |
215 | } else if (*p >= '0' && *p <= '9') { |
216 | char *ep; |
217 | double d = strtod(p, &ep); |
218 | if (*ep == '\0') { |
219 | if (optr+1+sizeof(double) > obuf+sizeof(obuf)) { |
220 | fprintf(stderr, "Error: output buffer overflow\n" ); |
221 | exit(1); |
222 | } |
223 | *optr++ = LIBINIT_NUMBER; |
224 | memcpy_endian(optr, &d, sizeof(double)); |
225 | optr += sizeof(double); |
226 | return; |
227 | } |
228 | } else if (!strcmp(p, "lastcl" )) { |
229 | if (optr+1 > obuf+sizeof(obuf)) { |
230 | fprintf(stderr, "Error: output buffer overflow\n" ); |
231 | exit(1); |
232 | } |
233 | *optr++ = LIBINIT_LASTCL; |
234 | return; |
235 | } else if (len > 4 && !strncmp(p, "top-" , 4)) { |
236 | if (optr+2 > obuf+sizeof(obuf)) { |
237 | fprintf(stderr, "Error: output buffer overflow\n" ); |
238 | exit(1); |
239 | } |
240 | *optr++ = LIBINIT_COPY; |
241 | *optr++ = (uint8_t)atoi(p+4); |
242 | return; |
243 | } |
244 | fprintf(stderr, "Error: bad value for %sPUSH(%s)\n" , LIBDEF_PREFIX, p); |
245 | exit(1); |
246 | } |
247 | } |
248 | |
249 | static void libdef_set(BuildCtx *ctx, char *p, int arg) |
250 | { |
251 | UNUSED(arg); |
252 | if (ctx->mode == BUILD_libdef) { |
253 | if (p[0] == '!' && p[1] == '\0') p[0] = '\0'; /* Set env. */ |
254 | libdef_name(p, LIBINIT_STRING); |
255 | *optr++ = LIBINIT_SET; |
256 | obuf[2]++; /* Bump hash table size. */ |
257 | } |
258 | } |
259 | |
260 | static void libdef_regfunc(BuildCtx *ctx, char *p, int arg) |
261 | { |
262 | UNUSED(ctx); UNUSED(p); |
263 | regfunc = arg; |
264 | } |
265 | |
266 | typedef void (*LibDefFunc)(BuildCtx *ctx, char *p, int arg); |
267 | |
268 | typedef struct LibDefHandler { |
269 | const char *suffix; |
270 | const char *stop; |
271 | const LibDefFunc func; |
272 | const int arg; |
273 | } LibDefHandler; |
274 | |
275 | static const LibDefHandler libdef_handlers[] = { |
276 | { "MODULE_" , " \t\r\n" , libdef_module, 0 }, |
277 | { "CF(" , ")" , libdef_func, LIBINIT_CF }, |
278 | { "ASM(" , ")" , libdef_func, LIBINIT_ASM }, |
279 | { "ASM_(" , ")" , libdef_func, LIBINIT_ASM_ }, |
280 | { "REC(" , ")" , libdef_rec, 0 }, |
281 | { "PUSH(" , ")" , libdef_push, 0 }, |
282 | { "SET(" , ")" , libdef_set, 0 }, |
283 | { "NOREGUV" , NULL, libdef_regfunc, REGFUNC_NOREGUV }, |
284 | { "NOREG" , NULL, libdef_regfunc, REGFUNC_NOREG }, |
285 | { NULL, NULL, (LibDefFunc)0, 0 } |
286 | }; |
287 | |
288 | /* Emit C source code for library function definitions. */ |
289 | void emit_lib(BuildCtx *ctx) |
290 | { |
291 | const char *fname; |
292 | |
293 | if (ctx->mode == BUILD_ffdef || ctx->mode == BUILD_libdef || |
294 | ctx->mode == BUILD_recdef) |
295 | fprintf(ctx->fp, "/* This is a generated file. DO NOT EDIT! */\n\n" ); |
296 | else if (ctx->mode == BUILD_vmdef) |
297 | fprintf(ctx->fp, "ffnames = {\n[0]=\"Lua\",\n\"C\",\n" ); |
298 | if (ctx->mode == BUILD_recdef) |
299 | fprintf(ctx->fp, "static const uint16_t recff_idmap[] = {\n0,\n0x0100" ); |
300 | recffid = ffid = FF_C+1; |
301 | ffasmfunc = 0; |
302 | |
303 | while ((fname = *ctx->args++)) { |
304 | char buf[256]; /* We don't care about analyzing lines longer than that. */ |
305 | FILE *fp; |
306 | if (fname[0] == '-' && fname[1] == '\0') { |
307 | fp = stdin; |
308 | } else { |
309 | fp = fopen(fname, "r" ); |
310 | if (!fp) { |
311 | fprintf(stderr, "Error: cannot open input file '%s': %s\n" , |
312 | fname, strerror(errno)); |
313 | exit(1); |
314 | } |
315 | } |
316 | modstate = 0; |
317 | regfunc = REGFUNC_OK; |
318 | while (fgets(buf, sizeof(buf), fp) != NULL) { |
319 | char *p; |
320 | /* Simplistic pre-processor. Only handles top-level #if/#endif. */ |
321 | if (buf[0] == '#' && buf[1] == 'i' && buf[2] == 'f') { |
322 | int ok = 1; |
323 | if (!strcmp(buf, "#if LJ_52\n" )) |
324 | ok = LJ_52; |
325 | else if (!strcmp(buf, "#if LJ_HASJIT\n" )) |
326 | ok = LJ_HASJIT; |
327 | else if (!strcmp(buf, "#if LJ_HASFFI\n" )) |
328 | ok = LJ_HASFFI; |
329 | if (!ok) { |
330 | int lvl = 1; |
331 | while (fgets(buf, sizeof(buf), fp) != NULL) { |
332 | if (buf[0] == '#' && buf[1] == 'e' && buf[2] == 'n') { |
333 | if (--lvl == 0) break; |
334 | } else if (buf[0] == '#' && buf[1] == 'i' && buf[2] == 'f') { |
335 | lvl++; |
336 | } |
337 | } |
338 | continue; |
339 | } |
340 | } |
341 | for (p = buf; (p = strstr(p, LIBDEF_PREFIX)) != NULL; ) { |
342 | const LibDefHandler *ldh; |
343 | p += sizeof(LIBDEF_PREFIX)-1; |
344 | for (ldh = libdef_handlers; ldh->suffix != NULL; ldh++) { |
345 | size_t n, len = strlen(ldh->suffix); |
346 | if (!strncmp(p, ldh->suffix, len)) { |
347 | p += len; |
348 | n = ldh->stop ? strcspn(p, ldh->stop) : 0; |
349 | if (!p[n]) break; |
350 | p[n] = '\0'; |
351 | ldh->func(ctx, p, ldh->arg); |
352 | p += n+1; |
353 | break; |
354 | } |
355 | } |
356 | if (ldh->suffix == NULL) { |
357 | buf[strlen(buf)-1] = '\0'; |
358 | fprintf(stderr, "Error: unknown library definition tag %s%s\n" , |
359 | LIBDEF_PREFIX, p); |
360 | exit(1); |
361 | } |
362 | } |
363 | } |
364 | fclose(fp); |
365 | if (ctx->mode == BUILD_libdef) { |
366 | libdef_endmodule(ctx); |
367 | } |
368 | } |
369 | |
370 | if (ctx->mode == BUILD_ffdef) { |
371 | fprintf(ctx->fp, "\n#undef FFDEF\n\n" ); |
372 | fprintf(ctx->fp, |
373 | "#ifndef FF_NUM_ASMFUNC\n#define FF_NUM_ASMFUNC %d\n#endif\n\n" , |
374 | ffasmfunc); |
375 | } else if (ctx->mode == BUILD_vmdef) { |
376 | fprintf(ctx->fp, "}\n\n" ); |
377 | } else if (ctx->mode == BUILD_bcdef) { |
378 | int i; |
379 | fprintf(ctx->fp, "\n};\n\n" ); |
380 | fprintf(ctx->fp, "LJ_DATADEF const uint16_t lj_bc_mode[] = {\n" ); |
381 | fprintf(ctx->fp, "BCDEF(BCMODE)\n" ); |
382 | for (i = ffasmfunc-1; i > 0; i--) |
383 | fprintf(ctx->fp, "BCMODE_FF,\n" ); |
384 | fprintf(ctx->fp, "BCMODE_FF\n};\n\n" ); |
385 | } else if (ctx->mode == BUILD_recdef) { |
386 | char *p = (char *)obuf; |
387 | fprintf(ctx->fp, "\n};\n\n" ); |
388 | fprintf(ctx->fp, "static const RecordFunc recff_func[] = {\n" |
389 | "recff_nyi,\n" |
390 | "recff_c" ); |
391 | while (*p) { |
392 | fprintf(ctx->fp, ",\nrecff_%s" , p); |
393 | p += strlen(p)+1; |
394 | } |
395 | fprintf(ctx->fp, "\n};\n\n" ); |
396 | } |
397 | } |
398 | |
399 | |