Mercurial

comparison third_party/luajit/src/host/buildvm.c @ 178:94705b5986b3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added WRK and luajit for load testing.
author MrJuneJune <me@mrjunejune.com>
date Thu, 22 Jan 2026 20:10:30 -0800
parents
children
comparison
equal deleted inserted replaced
177:24fe8ff94056 178:94705b5986b3
1 /*
2 ** LuaJIT VM builder.
3 ** Copyright (C) 2005-2023 Mike Pall. See Copyright Notice in luajit.h
4 **
5 ** This is a tool to build the hand-tuned assembler code required for
6 ** LuaJIT's bytecode interpreter. It supports a variety of output formats
7 ** to feed different toolchains (see usage() below).
8 **
9 ** This tool is not particularly optimized because it's only used while
10 ** _building_ LuaJIT. There's no point in distributing or installing it.
11 ** Only the object code generated by this tool is linked into LuaJIT.
12 **
13 ** Caveat: some memory is not free'd, error handling is lazy.
14 ** It's a one-shot tool -- any effort fixing this would be wasted.
15 */
16
17 #include "buildvm.h"
18 #include "lj_obj.h"
19 #include "lj_gc.h"
20 #include "lj_bc.h"
21 #if LJ_HASJIT
22 #include "lj_ir.h"
23 #include "lj_ircall.h"
24 #endif
25 #include "lj_frame.h"
26 #include "lj_dispatch.h"
27 #if LJ_HASFFI
28 #include "lj_ctype.h"
29 #include "lj_ccall.h"
30 #endif
31 #include "luajit.h"
32
33 #if defined(_WIN32)
34 #include <fcntl.h>
35 #include <io.h>
36 #endif
37
38 /* ------------------------------------------------------------------------ */
39
40 /* DynASM glue definitions. */
41 #define Dst ctx
42 #define Dst_DECL BuildCtx *ctx
43 #define Dst_REF (ctx->D)
44 #define DASM_CHECKS 1
45
46 #include "../dynasm/dasm_proto.h"
47
48 /* Glue macros for DynASM. */
49 static int collect_reloc(BuildCtx *ctx, uint8_t *addr, int idx, int type);
50
51 #define DASM_EXTERN(ctx, addr, idx, type) \
52 collect_reloc(ctx, addr, idx, type)
53
54 /* ------------------------------------------------------------------------ */
55
56 /* Avoid trouble if cross-compiling for an x86 target. Speed doesn't matter. */
57 #define DASM_ALIGNED_WRITES 1
58
59 /* Embed architecture-specific DynASM encoder. */
60 #if LJ_TARGET_X86ORX64
61 #include "../dynasm/dasm_x86.h"
62 #elif LJ_TARGET_ARM
63 #include "../dynasm/dasm_arm.h"
64 #elif LJ_TARGET_ARM64
65 #include "../dynasm/dasm_arm64.h"
66 #elif LJ_TARGET_PPC
67 #include "../dynasm/dasm_ppc.h"
68 #elif LJ_TARGET_MIPS
69 #include "../dynasm/dasm_mips.h"
70 #else
71 #error "No support for this architecture (yet)"
72 #endif
73
74 /* Embed generated architecture-specific backend. */
75 #include "buildvm_arch.h"
76
77 /* ------------------------------------------------------------------------ */
78
79 void owrite(BuildCtx *ctx, const void *ptr, size_t sz)
80 {
81 if (fwrite(ptr, 1, sz, ctx->fp) != sz) {
82 fprintf(stderr, "Error: cannot write to output file: %s\n",
83 strerror(errno));
84 exit(1);
85 }
86 }
87
88 /* ------------------------------------------------------------------------ */
89
90 /* Emit code as raw bytes. Only used for DynASM debugging. */
91 static void emit_raw(BuildCtx *ctx)
92 {
93 owrite(ctx, ctx->code, ctx->codesz);
94 }
95
96 /* -- Build machine code -------------------------------------------------- */
97
98 static const char *sym_decorate(BuildCtx *ctx,
99 const char *prefix, const char *suffix)
100 {
101 char name[256];
102 char *p;
103 #if LJ_64
104 const char *symprefix = ctx->mode == BUILD_machasm ? "_" : "";
105 #elif LJ_TARGET_XBOX360
106 const char *symprefix = "";
107 #else
108 const char *symprefix = ctx->mode != BUILD_elfasm ? "_" : "";
109 #endif
110 sprintf(name, "%s%s%s", symprefix, prefix, suffix);
111 p = strchr(name, '@');
112 if (p) {
113 #if LJ_TARGET_X86ORX64
114 if (!LJ_64 && (ctx->mode == BUILD_coffasm || ctx->mode == BUILD_peobj))
115 name[0] = name[1] == 'R' ? '_' : '@'; /* Just for _RtlUnwind@16. */
116 else
117 *p = '\0';
118 #elif LJ_TARGET_PPC && !LJ_TARGET_CONSOLE
119 /* Keep @plt etc. */
120 #else
121 *p = '\0';
122 #endif
123 }
124 p = (char *)malloc(strlen(name)+1); /* MSVC doesn't like strdup. */
125 strcpy(p, name);
126 return p;
127 }
128
129 #define NRELOCSYM (sizeof(extnames)/sizeof(extnames[0])-1)
130
131 static int relocmap[NRELOCSYM];
132
133 /* Collect external relocations. */
134 static int collect_reloc(BuildCtx *ctx, uint8_t *addr, int idx, int type)
135 {
136 if (ctx->nreloc >= BUILD_MAX_RELOC) {
137 fprintf(stderr, "Error: too many relocations, increase BUILD_MAX_RELOC.\n");
138 exit(1);
139 }
140 if (relocmap[idx] < 0) {
141 relocmap[idx] = ctx->nrelocsym;
142 ctx->relocsym[ctx->nrelocsym] = sym_decorate(ctx, "", extnames[idx]);
143 ctx->nrelocsym++;
144 }
145 ctx->reloc[ctx->nreloc].ofs = (int32_t)(addr - ctx->code);
146 ctx->reloc[ctx->nreloc].sym = relocmap[idx];
147 ctx->reloc[ctx->nreloc].type = type;
148 ctx->nreloc++;
149 #if LJ_TARGET_XBOX360
150 return (int)(ctx->code - addr) + 4; /* Encode symbol offset of .text. */
151 #else
152 return 0; /* Encode symbol offset of 0. */
153 #endif
154 }
155
156 /* Naive insertion sort. Performance doesn't matter here. */
157 static void sym_insert(BuildCtx *ctx, int32_t ofs,
158 const char *prefix, const char *suffix)
159 {
160 ptrdiff_t i = ctx->nsym++;
161 while (i > 0) {
162 if (ctx->sym[i-1].ofs <= ofs)
163 break;
164 ctx->sym[i] = ctx->sym[i-1];
165 i--;
166 }
167 ctx->sym[i].ofs = ofs;
168 ctx->sym[i].name = sym_decorate(ctx, prefix, suffix);
169 }
170
171 /* Build the machine code. */
172 static int build_code(BuildCtx *ctx)
173 {
174 int status;
175 int i;
176
177 /* Initialize DynASM structures. */
178 ctx->nglob = GLOB__MAX;
179 ctx->glob = (void **)malloc(ctx->nglob*sizeof(void *));
180 memset(ctx->glob, 0, ctx->nglob*sizeof(void *));
181 ctx->nreloc = 0;
182
183 ctx->globnames = globnames;
184 ctx->extnames = extnames;
185 ctx->relocsym = (const char **)malloc(NRELOCSYM*sizeof(const char *));
186 ctx->nrelocsym = 0;
187 for (i = 0; i < (int)NRELOCSYM; i++) relocmap[i] = -1;
188
189 ctx->dasm_ident = DASM_IDENT;
190 ctx->dasm_arch = DASM_ARCH;
191
192 dasm_init(Dst, DASM_MAXSECTION);
193 dasm_setupglobal(Dst, ctx->glob, ctx->nglob);
194 dasm_setup(Dst, build_actionlist);
195
196 /* Call arch-specific backend to emit the code. */
197 ctx->npc = build_backend(ctx);
198
199 /* Finalize the code. */
200 (void)dasm_checkstep(Dst, -1);
201 if ((status = dasm_link(Dst, &ctx->codesz))) return status;
202 ctx->code = (uint8_t *)malloc(ctx->codesz);
203 if ((status = dasm_encode(Dst, (void *)ctx->code))) return status;
204
205 /* Allocate symbol table and bytecode offsets. */
206 ctx->beginsym = sym_decorate(ctx, "", LABEL_PREFIX "vm_asm_begin");
207 ctx->sym = (BuildSym *)malloc((ctx->npc+ctx->nglob+1)*sizeof(BuildSym));
208 ctx->nsym = 0;
209 ctx->bc_ofs = (int32_t *)malloc(ctx->npc*sizeof(int32_t));
210
211 /* Collect the opcodes (PC labels). */
212 for (i = 0; i < ctx->npc; i++) {
213 int32_t ofs = dasm_getpclabel(Dst, i);
214 if (ofs < 0) return 0x22000000|i;
215 ctx->bc_ofs[i] = ofs;
216 if ((LJ_HASJIT ||
217 !(i == BC_JFORI || i == BC_JFORL || i == BC_JITERL || i == BC_JLOOP ||
218 i == BC_IFORL || i == BC_IITERL || i == BC_ILOOP)) &&
219 (LJ_HASFFI || i != BC_KCDATA))
220 sym_insert(ctx, ofs, LABEL_PREFIX_BC, bc_names[i]);
221 }
222
223 /* Collect the globals (named labels). */
224 for (i = 0; i < ctx->nglob; i++) {
225 const char *gl = globnames[i];
226 int len = (int)strlen(gl);
227 if (!ctx->glob[i]) {
228 fprintf(stderr, "Error: undefined global %s\n", gl);
229 exit(2);
230 }
231 /* Skip the _Z symbols. */
232 if (!(len >= 2 && gl[len-2] == '_' && gl[len-1] == 'Z'))
233 sym_insert(ctx, (int32_t)((uint8_t *)(ctx->glob[i]) - ctx->code),
234 LABEL_PREFIX, globnames[i]);
235 }
236
237 /* Close the address range. */
238 sym_insert(ctx, (int32_t)ctx->codesz, "", "");
239 ctx->nsym--;
240
241 dasm_free(Dst);
242
243 return 0;
244 }
245
246 /* -- Generate VM enums --------------------------------------------------- */
247
248 const char *const bc_names[] = {
249 #define BCNAME(name, ma, mb, mc, mt) #name,
250 BCDEF(BCNAME)
251 #undef BCNAME
252 NULL
253 };
254
255 #if LJ_HASJIT
256 const char *const ir_names[] = {
257 #define IRNAME(name, m, m1, m2) #name,
258 IRDEF(IRNAME)
259 #undef IRNAME
260 NULL
261 };
262
263 const char *const irt_names[] = {
264 #define IRTNAME(name, size) #name,
265 IRTDEF(IRTNAME)
266 #undef IRTNAME
267 NULL
268 };
269
270 const char *const irfpm_names[] = {
271 #define FPMNAME(name) #name,
272 IRFPMDEF(FPMNAME)
273 #undef FPMNAME
274 NULL
275 };
276
277 const char *const irfield_names[] = {
278 #define FLNAME(name, ofs) #name,
279 IRFLDEF(FLNAME)
280 #undef FLNAME
281 NULL
282 };
283
284 const char *const ircall_names[] = {
285 #define IRCALLNAME(cond, name, nargs, kind, type, flags) #name,
286 IRCALLDEF(IRCALLNAME)
287 #undef IRCALLNAME
288 NULL
289 };
290
291 static const char *const trace_errors[] = {
292 #define TREDEF(name, msg) msg,
293 #include "lj_traceerr.h"
294 NULL
295 };
296 #endif
297
298 #if LJ_HASJIT
299 static const char *lower(char *buf, const char *s)
300 {
301 char *p = buf;
302 while (*s) {
303 *p++ = (*s >= 'A' && *s <= 'Z') ? *s+0x20 : *s;
304 s++;
305 }
306 *p = '\0';
307 return buf;
308 }
309 #endif
310
311 /* Emit C source code for bytecode-related definitions. */
312 static void emit_bcdef(BuildCtx *ctx)
313 {
314 int i;
315 fprintf(ctx->fp, "/* This is a generated file. DO NOT EDIT! */\n\n");
316 fprintf(ctx->fp, "LJ_DATADEF const uint16_t lj_bc_ofs[] = {\n");
317 for (i = 0; i < ctx->npc; i++) {
318 if (i != 0)
319 fprintf(ctx->fp, ",\n");
320 fprintf(ctx->fp, "%d", ctx->bc_ofs[i]);
321 }
322 }
323
324 /* Emit VM definitions as Lua code for debug modules. */
325 static void emit_vmdef(BuildCtx *ctx)
326 {
327 #if LJ_HASJIT
328 char buf[80];
329 #endif
330 int i;
331 fprintf(ctx->fp, "-- This is a generated file. DO NOT EDIT!\n\n");
332 fprintf(ctx->fp, "assert(require(\"jit\").version == \"%s\", \"LuaJIT core/library version mismatch\")\n\n", LUAJIT_VERSION);
333 fprintf(ctx->fp, "return {\n\n");
334
335 fprintf(ctx->fp, "bcnames = \"");
336 for (i = 0; bc_names[i]; i++) fprintf(ctx->fp, "%-6s", bc_names[i]);
337 fprintf(ctx->fp, "\",\n\n");
338
339 #if LJ_HASJIT
340 fprintf(ctx->fp, "irnames = \"");
341 for (i = 0; ir_names[i]; i++) fprintf(ctx->fp, "%-6s", ir_names[i]);
342 fprintf(ctx->fp, "\",\n\n");
343
344 fprintf(ctx->fp, "irfpm = { [0]=");
345 for (i = 0; irfpm_names[i]; i++)
346 fprintf(ctx->fp, "\"%s\", ", lower(buf, irfpm_names[i]));
347 fprintf(ctx->fp, "},\n\n");
348
349 fprintf(ctx->fp, "irfield = { [0]=");
350 for (i = 0; irfield_names[i]; i++) {
351 char *p;
352 lower(buf, irfield_names[i]);
353 p = strchr(buf, '_');
354 if (p) *p = '.';
355 fprintf(ctx->fp, "\"%s\", ", buf);
356 }
357 fprintf(ctx->fp, "},\n\n");
358
359 fprintf(ctx->fp, "ircall = {\n[0]=");
360 for (i = 0; ircall_names[i]; i++)
361 fprintf(ctx->fp, "\"%s\",\n", ircall_names[i]);
362 fprintf(ctx->fp, "},\n\n");
363
364 fprintf(ctx->fp, "traceerr = {\n[0]=");
365 for (i = 0; trace_errors[i]; i++)
366 fprintf(ctx->fp, "\"%s\",\n", trace_errors[i]);
367 fprintf(ctx->fp, "},\n\n");
368 #endif
369 }
370
371 /* -- Argument parsing ---------------------------------------------------- */
372
373 /* Build mode names. */
374 static const char *const modenames[] = {
375 #define BUILDNAME(name) #name,
376 BUILDDEF(BUILDNAME)
377 #undef BUILDNAME
378 NULL
379 };
380
381 /* Print usage information and exit. */
382 static void usage(void)
383 {
384 int i;
385 fprintf(stderr, LUAJIT_VERSION " VM builder.\n");
386 fprintf(stderr, LUAJIT_COPYRIGHT ", " LUAJIT_URL "\n");
387 fprintf(stderr, "Target architecture: " LJ_ARCH_NAME "\n\n");
388 fprintf(stderr, "Usage: buildvm -m mode [-o outfile] [infiles...]\n\n");
389 fprintf(stderr, "Available modes:\n");
390 for (i = 0; i < BUILD__MAX; i++)
391 fprintf(stderr, " %s\n", modenames[i]);
392 exit(1);
393 }
394
395 /* Parse the output mode name. */
396 static BuildMode parsemode(const char *mode)
397 {
398 int i;
399 for (i = 0; modenames[i]; i++)
400 if (!strcmp(mode, modenames[i]))
401 return (BuildMode)i;
402 usage();
403 return (BuildMode)-1;
404 }
405
406 /* Parse arguments. */
407 static void parseargs(BuildCtx *ctx, char **argv)
408 {
409 const char *a;
410 int i;
411 ctx->mode = (BuildMode)-1;
412 ctx->outname = "-";
413 for (i = 1; (a = argv[i]) != NULL; i++) {
414 if (a[0] != '-')
415 break;
416 switch (a[1]) {
417 case '-':
418 if (a[2]) goto err;
419 i++;
420 goto ok;
421 case '\0':
422 goto ok;
423 case 'm':
424 i++;
425 if (a[2] || argv[i] == NULL) goto err;
426 ctx->mode = parsemode(argv[i]);
427 break;
428 case 'o':
429 i++;
430 if (a[2] || argv[i] == NULL) goto err;
431 ctx->outname = argv[i];
432 break;
433 default: err:
434 usage();
435 break;
436 }
437 }
438 ok:
439 ctx->args = argv+i;
440 if (ctx->mode == (BuildMode)-1) goto err;
441 }
442
443 int main(int argc, char **argv)
444 {
445 BuildCtx ctx_;
446 BuildCtx *ctx = &ctx_;
447 int status, binmode;
448
449 if (sizeof(void *) != 4*LJ_32+8*LJ_64) {
450 fprintf(stderr,"Error: pointer size mismatch in cross-build.\n");
451 fprintf(stderr,"Try: make HOST_CC=\"gcc -m32\" CROSS=...\n\n");
452 return 1;
453 }
454
455 UNUSED(argc);
456 parseargs(ctx, argv);
457
458 if ((status = build_code(ctx))) {
459 fprintf(stderr,"Error: DASM error %08x\n", status);
460 return 1;
461 }
462
463 switch (ctx->mode) {
464 case BUILD_peobj:
465 case BUILD_raw:
466 binmode = 1;
467 break;
468 default:
469 binmode = 0;
470 break;
471 }
472
473 if (ctx->outname[0] == '-' && ctx->outname[1] == '\0') {
474 ctx->fp = stdout;
475 #if defined(_WIN32)
476 if (binmode)
477 _setmode(_fileno(stdout), _O_BINARY); /* Yuck. */
478 #endif
479 } else if (!(ctx->fp = fopen(ctx->outname, binmode ? "wb" : "w"))) {
480 fprintf(stderr, "Error: cannot open output file '%s': %s\n",
481 ctx->outname, strerror(errno));
482 exit(1);
483 }
484
485 switch (ctx->mode) {
486 case BUILD_elfasm:
487 case BUILD_coffasm:
488 case BUILD_machasm:
489 emit_asm(ctx);
490 emit_asm_debug(ctx);
491 break;
492 case BUILD_peobj:
493 emit_peobj(ctx);
494 break;
495 case BUILD_raw:
496 emit_raw(ctx);
497 break;
498 case BUILD_bcdef:
499 emit_bcdef(ctx);
500 emit_lib(ctx);
501 break;
502 case BUILD_vmdef:
503 emit_vmdef(ctx);
504 emit_lib(ctx);
505 fprintf(ctx->fp, "}\n\n");
506 break;
507 case BUILD_ffdef:
508 case BUILD_libdef:
509 case BUILD_recdef:
510 emit_lib(ctx);
511 break;
512 case BUILD_folddef:
513 emit_fold(ctx);
514 break;
515 default:
516 break;
517 }
518
519 fflush(ctx->fp);
520 if (ferror(ctx->fp)) {
521 fprintf(stderr, "Error: cannot write to output file: %s\n",
522 strerror(errno));
523 exit(1);
524 }
525 fclose(ctx->fp);
526
527 return 0;
528 }
529