11382361258

Committed 17 Oct 2024 09:16AM UTC coverage: 92.945% (-0.04%) from 92.981%

Build # 11382361258

Build Type

push

github

Committed by

Buristan

Commit Message

Limit CSE for IR_CARG to fix loop optimizations.

Thanks to Peter Cawley.

(cherry picked from commit 3bdc6498c)

`IR_CALLXS` for the vararg function contains `IR_CARG(fptr, ctid)` as
the second operand. The `loop_emit_phi()` scans only the first operand
of the IR, so the second is not marked as PHI. In this case, when the IR
appears in both the invariant and variant parts of the loop, CSE may
remove it and thus lead to incorrect emitting results.

This patch tweaks the CSE rules to avoid CSE across the `IR_LOOP`.

Sergey Kaplun:
* added the description and the test for the problem

Part of tarantool/tarantool#10199

Reviewed-by: Sergey Bronnikov <sergeyb@tarantool.org>
Reviewed-by: Maxim Kokryashkin <m.kokryashkin@tarantool.org>
Signed-off-by: Sergey Kaplun <skaplun@tarantool.org>
(cherry picked from commit b52fe9795)

Run Details

5694 of 6033 branches covered (94.38%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 1 file covered. (100.0%)

22 existing lines in 5 files now uncovered.

21708 of 23449 relevant lines covered (92.58%)

2974203.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.98

/src/luajit.c

/*
** LuaJIT frontend. Runs commands, scripts, read-eval-print (REPL) etc.
** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
**
** Major portions taken verbatim or adapted from the Lua interpreter.
** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define luajit_c

#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
#include "luajit.h"

#include "lj_arch.h"

#if LJ_TARGET_POSIX
#include <unistd.h>
#define lua_stdin_is_tty()        isatty(0)
#elif LJ_TARGET_WINDOWS
#include <io.h>
#ifdef __BORLANDC__
#define lua_stdin_is_tty()        isatty(_fileno(stdin))
#else
#define lua_stdin_is_tty()        _isatty(_fileno(stdin))
#endif
#else
#define lua_stdin_is_tty()        1
#endif

#if !LJ_TARGET_CONSOLE
#include <signal.h>
#endif

static lua_State *globalL = NULL;
static const char *progname = LUA_PROGNAME;

#if !LJ_TARGET_CONSOLE
static void lstop(lua_State *L, lua_Debug *ar)
{
  (void)ar;  /* unused arg. */
  lua_sethook(L, NULL, 0, 0);
  /* Avoid luaL_error -- a C hook doesn't add an extra frame. */
  luaL_where(L, 0);
  lua_pushfstring(L, "%sinterrupted!", lua_tostring(L, -1));
  lua_error(L);
}

static void laction(int i)
{
  signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
                         terminate process (default action) */
  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
}
#endif

static void print_usage(void)
{
  fputs("usage: ", stderr);
  fputs(progname, stderr);
  fputs(" [options]... [script [args]...].\n"
  "Available options are:\n"
  "  -e chunk  Execute string " LUA_QL("chunk") ".\n"
  "  -l name   Require library " LUA_QL("name") ".\n"
  "  -b ...    Save or list bytecode.\n"
  "  -j cmd    Perform LuaJIT control command.\n"
  "  -O[opt]   Control LuaJIT optimizations.\n"
  "  -i        Enter interactive mode after executing " LUA_QL("script") ".\n"
  "  -v        Show version information.\n"
  "  -t<cmd>   Execute tool.\n"
  "  -E        Ignore environment variables.\n"
  "  --        Stop handling options.\n"
  "  -         Execute stdin and stop handling options.\n", stderr);
  fflush(stderr);
}

static void print_tools_usage(void)
{
  fputs("usage: ", stderr);
  fputs(progname, stderr);
  fputs(" -t<cmd>\n"
  "Available tools are:\n"
  "  -m [--leak-only] input  Memprof profile data parser.\n"
  "  -s input                Sysprof profile data parser.\n", stderr);
  fflush(stderr);
}

static void l_message(const char *pname, const char *msg)
{
  if (pname) { fputs(pname, stderr); fputc(':', stderr); fputc(' ', stderr); }
  fputs(msg, stderr); fputc('\n', stderr);
  fflush(stderr);
}

static int report(lua_State *L, int status)
{
  if (status && !lua_isnil(L, -1)) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "(error object is not a string)";
    l_message(progname, msg);
    lua_pop(L, 1);
  }
  return status;
}

static int traceback(lua_State *L)
{
  if (!lua_isstring(L, 1)) { /* Non-string error object? Try metamethod. */
    if (lua_isnoneornil(L, 1) ||
        !luaL_callmeta(L, 1, "__tostring") ||
        !lua_isstring(L, -1))
      return 1;  /* Return non-string error object. */
    lua_remove(L, 1);  /* Replace object by result of __tostring metamethod. */
  }
  luaL_traceback(L, L, lua_tostring(L, 1), 1);
  return 1;
}

static int docall(lua_State *L, int narg, int clear)
{
  int status;
  int base = lua_gettop(L) - narg;  /* function index */
  lua_pushcfunction(L, traceback);  /* push traceback function */
  lua_insert(L, base);  /* put it under chunk and args */
#if !LJ_TARGET_CONSOLE
  signal(SIGINT, laction);
#endif
  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
#if !LJ_TARGET_CONSOLE
  signal(SIGINT, SIG_DFL);
#endif
  lua_remove(L, base);  /* remove traceback function */
  /* force a complete garbage collection in case of errors */
  if (status != LUA_OK) lua_gc(L, LUA_GCCOLLECT, 0);
  return status;
}

static void print_version(void)
{
  fputs(LUAJIT_VERSION " -- " LUAJIT_COPYRIGHT ". " LUAJIT_URL "\n", stdout);
}

static void print_jit_status(lua_State *L)
{
  int n;
  const char *s;
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, -1, "jit");  /* Get jit.* module table. */
  lua_remove(L, -2);
  lua_getfield(L, -1, "status");
  lua_remove(L, -2);
  n = lua_gettop(L);
  lua_call(L, 0, LUA_MULTRET);
  fputs(lua_toboolean(L, n) ? "JIT: ON" : "JIT: OFF", stdout);
  for (n++; (s = lua_tostring(L, n)); n++) {
    putc(' ', stdout);
    fputs(s, stdout);
  }
  putc('\n', stdout);
  lua_settop(L, 0);  /* clear stack */
}

static void createargtable(lua_State *L, char **argv, int argc, int argf)
{
  int i;
  lua_createtable(L, argc - argf, argf);
  for (i = 0; i < argc; i++) {
    lua_pushstring(L, argv[i]);
    lua_rawseti(L, -2, i - argf);
  }
  lua_setglobal(L, "arg");
}

static int dofile(lua_State *L, const char *name)
{
  int status = luaL_loadfile(L, name) || docall(L, 0, 1);
  return report(L, status);
}

static int dostring(lua_State *L, const char *s, const char *name)
{
  int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
  return report(L, status);
}

static int dolibrary(lua_State *L, const char *name)
{
  lua_getglobal(L, "require");
  lua_pushstring(L, name);
  return report(L, docall(L, 1, 1));
}

static void write_prompt(lua_State *L, int firstline)
{
  const char *p;
  lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
  p = lua_tostring(L, -1);
  if (p == NULL) p = firstline ? LUA_PROMPT : LUA_PROMPT2;
  fputs(p, stdout);
  fflush(stdout);
  lua_pop(L, 1);  /* remove global */
}

static int incomplete(lua_State *L, int status)
{
  if (status == LUA_ERRSYNTAX) {
    size_t lmsg;
    const char *msg = lua_tolstring(L, -1, &lmsg);
    const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
    if (strstr(msg, LUA_QL("<eof>")) == tp) {
      lua_pop(L, 1);
      return 1;
    }
  }
  return 0;  /* else... */
}

static int pushline(lua_State *L, int firstline)
{
  char buf[LUA_MAXINPUT];
  write_prompt(L, firstline);
  if (fgets(buf, LUA_MAXINPUT, stdin)) {
    size_t len = strlen(buf);
    if (len > 0 && buf[len-1] == '\n')
      buf[len-1] = '\0';
    if (firstline && buf[0] == '=')
      lua_pushfstring(L, "return %s", buf+1);
    else
      lua_pushstring(L, buf);
    return 1;
  }
  return 0;
}

static int loadline(lua_State *L)
{
  int status;
  lua_settop(L, 0);
  if (!pushline(L, 1))
    return -1;  /* no input */
  for (;;) {  /* repeat until gets a complete line */
    status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
    if (!incomplete(L, status)) break;  /* cannot try to add lines? */
    if (!pushline(L, 0))  /* no more input? */
      return -1;
    lua_pushliteral(L, "\n");  /* add a new line... */
    lua_insert(L, -2);  /* ...between the two lines */
    lua_concat(L, 3);  /* join them */
  }
  lua_remove(L, 1);  /* remove line */
  return status;
}

static void dotty(lua_State *L)
{
  int status;
  const char *oldprogname = progname;
  progname = NULL;
  while ((status = loadline(L)) != -1) {
    if (status == LUA_OK) status = docall(L, 0, 0);
    report(L, status);
    if (status == LUA_OK && lua_gettop(L) > 0) {  /* any result to print? */
      lua_getglobal(L, "print");
      lua_insert(L, 1);
      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
        l_message(progname,
          lua_pushfstring(L, "error calling " LUA_QL("print") " (%s)",
                              lua_tostring(L, -1)));
    }
  }
  lua_settop(L, 0);  /* clear stack */
  fputs("\n", stdout);
  fflush(stdout);
  progname = oldprogname;
}

static int handle_script(lua_State *L, char **argx)
{
  int status;
  const char *fname = argx[0];
  if (strcmp(fname, "-") == 0 && strcmp(argx[-1], "--") != 0)
    fname = NULL;  /* stdin */
  status = luaL_loadfile(L, fname);
  if (status == LUA_OK) {
    /* Fetch args from arg table. LUA_INIT or -e might have changed them. */
    int narg = 0;
    lua_getglobal(L, "arg");
    if (lua_istable(L, -1)) {
      do {
        narg++;
        lua_rawgeti(L, -narg, narg);
      } while (!lua_isnil(L, -1));
      lua_pop(L, 1);
      lua_remove(L, -narg);
      narg--;
    } else {
      lua_pop(L, 1);
    }
    status = docall(L, narg, 0);
  }
  return report(L, status);
}

/* Load add-on module. */
static int loadjitmodule(lua_State *L)
{
  lua_getglobal(L, "require");
  lua_pushliteral(L, "jit.");
  lua_pushvalue(L, -3);
  lua_concat(L, 2);
  if (lua_pcall(L, 1, 1, 0)) {
    const char *msg = lua_tostring(L, -1);
    if (msg && !strncmp(msg, "module ", 7))
      goto nomodule;
    return report(L, 1);
  }
  lua_getfield(L, -1, "start");
  if (lua_isnil(L, -1)) {
  nomodule:
    l_message(progname,
              "unknown luaJIT command or jit.* modules not installed");
    return 1;
  }
  lua_remove(L, -2);  /* Drop module table. */
  return 0;
}

/* Run command with options. */
static int runcmdopt(lua_State *L, const char *opt)
{
  int narg = 0;
  if (opt && *opt) {
    for (;;) {  /* Split arguments. */
      const char *p = strchr(opt, ',');
      narg++;
      if (!p) break;
      if (p == opt)
        lua_pushnil(L);
      else
        lua_pushlstring(L, opt, (size_t)(p - opt));
      opt = p + 1;
    }
    if (*opt)
      lua_pushstring(L, opt);
    else
      lua_pushnil(L);
  }
  return report(L, lua_pcall(L, narg, 0, 0));
}

/* JIT engine control command: try jit library first or load add-on module. */
static int dojitcmd(lua_State *L, const char *cmd)
{
  const char *opt = strchr(cmd, '=');
  lua_pushlstring(L, cmd, opt ? (size_t)(opt - cmd) : strlen(cmd));
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, -1, "jit");  /* Get jit.* module table. */
  lua_remove(L, -2);
  lua_pushvalue(L, -2);
  lua_gettable(L, -2);  /* Lookup library function. */
  if (!lua_isfunction(L, -1)) {
    lua_pop(L, 2);  /* Drop non-function and jit.* table, keep module name. */
    if (loadjitmodule(L))
      return 1;
  } else {
    lua_remove(L, -2);  /* Drop jit.* table. */
  }
  lua_remove(L, -2);  /* Drop module name. */
  return runcmdopt(L, opt ? opt+1 : opt);
}

static int runtoolcmd(lua_State *L, const char *tool_name)
{
  lua_getglobal(L, "require");
  lua_pushstring(L, tool_name);
  if (lua_pcall(L, 1, 1, 0)) {
    const char *msg = lua_tostring(L, -1);
    if (msg) {
      if (!strncmp(msg, "module ", 7))
        msg = "unknown luaJIT command or tools not installed";
      l_message(progname, msg);
    }
    return 1;
  }
  lua_getglobal(L, "arg");
  return report(L, lua_pcall(L, 1, 1, 0));
}

static int dotoolcmd(lua_State *L, const char *cmd)
{
  switch (cmd[0]) {
  case 'm':
    return runtoolcmd(L, "memprof");
  case 's':
    return runtoolcmd(L, "sysprof");
  default:
    print_tools_usage();
    break;
  }
  return -1;
}

/* Optimization flags. */
static int dojitopt(lua_State *L, const char *opt)
{
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, -1, "jit.opt");  /* Get jit.opt.* module table. */
  lua_remove(L, -2);
  lua_getfield(L, -1, "start");
  lua_remove(L, -2);
  return runcmdopt(L, opt);
}

/* Save or list bytecode. */
static int dobytecode(lua_State *L, char **argv)
{
  int narg = 0;
  lua_pushliteral(L, "bcsave");
  if (loadjitmodule(L))
    return 1;
  if (argv[0][2]) {
    narg++;
    argv[0][1] = '-';
    lua_pushstring(L, argv[0]+1);
  }
  for (argv++; *argv != NULL; narg++, argv++)
    lua_pushstring(L, *argv);
  report(L, lua_pcall(L, narg, 0, 0));
  return -1;
}

/* check that argument has no extra characters at the end */
#define notail(x)        {if ((x)[2] != '\0') return -1;}

#define FLAGS_INTERACTIVE        1
#define FLAGS_VERSION                2
#define FLAGS_EXEC                4
#define FLAGS_OPTION                8
#define FLAGS_NOENV                16
#define FLAGS_TOOL                32

static int collectargs(char **argv, int *flags)
{
  int i;
  for (i = 1; argv[i] != NULL; i++) {
    if (argv[i][0] != '-')  /* Not an option? */
      return i;
    switch (argv[i][1]) {  /* Check option. */
    case '-':
      notail(argv[i]);
      return i+1;
    case '\0':
      return i;
    case 'i':
      notail(argv[i]);
      *flags |= FLAGS_INTERACTIVE;
      /* fallthrough */
    case 'v':
      notail(argv[i]);
      *flags |= FLAGS_VERSION;
      break;
    case 't':
      *flags |= FLAGS_TOOL;
      return i + 1;
    case 'e':
      *flags |= FLAGS_EXEC;
      /* fallthrough */
    case 'j':  /* LuaJIT extension */
    case 'l':
      *flags |= FLAGS_OPTION;
      if (argv[i][2] == '\0') {
        i++;
        if (argv[i] == NULL) return -1;
      }
      break;
    case 'O': break;  /* LuaJIT extension */
    case 'b':  /* LuaJIT extension */
      if (*flags) return -1;
      *flags |= FLAGS_EXEC;
      return i+1;
    case 'E':
      *flags |= FLAGS_NOENV;
      break;
    default: return -1;  /* invalid option */
    }
  }
  return i;
}

static int runargs(lua_State *L, char **argv, int argn)
{
  int i;
  for (i = 1; i < argn; i++) {
    if (argv[i] == NULL) continue;
    lua_assert(argv[i][0] == '-');
    switch (argv[i][1]) {
    case 'e': {
      const char *chunk = argv[i] + 2;
      if (*chunk == '\0') chunk = argv[++i];
      lua_assert(chunk != NULL);
      if (dostring(L, chunk, "=(command line)") != 0)
        return 1;
      break;
      }
    case 'l': {
      const char *filename = argv[i] + 2;
      if (*filename == '\0') filename = argv[++i];
      lua_assert(filename != NULL);
      if (dolibrary(L, filename))
        return 1;
      break;
      }
    case 'j': {  /* LuaJIT extension. */
      const char *cmd = argv[i] + 2;
      if (*cmd == '\0') cmd = argv[++i];
      lua_assert(cmd != NULL);
      if (dojitcmd(L, cmd))
        return 1;
      break;
      }
    case 't': { /* Tarantool's fork extension. */
      const char *cmd = argv[i] + 2;
      return dotoolcmd(L, cmd) != LUA_OK;
    }
    case 'O':  /* LuaJIT extension. */
      if (dojitopt(L, argv[i] + 2))
        return 1;
      break;
    case 'b':  /* LuaJIT extension. */
      return dobytecode(L, argv+i);
    default: break;
    }
  }
  return LUA_OK;
}

static int handle_luainit(lua_State *L)
{
#if LJ_TARGET_CONSOLE
  const char *init = NULL;
#else
  const char *init = getenv(LUA_INIT);
#endif
  if (init == NULL)
    return LUA_OK;
  else if (init[0] == '@')
    return dofile(L, init+1);
  else
    return dostring(L, init, "=" LUA_INIT);
}

static struct Smain {
  char **argv;
  int argc;
  int status;
} smain;

static int pmain(lua_State *L)
{
  struct Smain *s = &smain;
  char **argv = s->argv;
  int argn;
  int flags = 0;
  globalL = L;
  if (argv[0] && argv[0][0]) progname = argv[0];

  LUAJIT_VERSION_SYM();  /* Linker-enforced version check. */

  argn = collectargs(argv, &flags);
  if (argn < 0) {  /* Invalid args? */
    print_usage();
    s->status = 1;
    return 0;
  }

  if ((flags & FLAGS_NOENV)) {
    lua_pushboolean(L, 1);
    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
  }

  /* Stop collector during library initialization. */
  lua_gc(L, LUA_GCSTOP, 0);
  luaL_openlibs(L);
  lua_gc(L, LUA_GCRESTART, -1);

  createargtable(L, argv, s->argc, (flags & FLAGS_TOOL) ? argn - 1 : argn);

  if (!(flags & FLAGS_NOENV)) {
    s->status = handle_luainit(L);
    if (s->status != LUA_OK) return 0;
  }

  if ((flags & FLAGS_VERSION)) print_version();

  s->status = runargs(L, argv, argn);
  if (s->status != LUA_OK) return 0;

  if (s->argc > argn) {
    s->status = handle_script(L, argv + argn);
    if (s->status != LUA_OK) return 0;
  }

  if ((flags & FLAGS_INTERACTIVE)) {
    print_jit_status(L);
    dotty(L);
  } else if (s->argc == argn && !(flags & (FLAGS_EXEC|FLAGS_VERSION))) {
    if (lua_stdin_is_tty()) {
      print_version();
      print_jit_status(L);
      dotty(L);
    } else {
      dofile(L, NULL);  /* Executes stdin as a file. */
    }
  }
  return 0;
}

int main(int argc, char **argv)
{
  int status;
  lua_State *L = lua_open();
  if (L == NULL) {
    l_message(argv[0], "cannot create state: not enough memory");
    return EXIT_FAILURE;
  }
  smain.argc = argc;
  smain.argv = argv;
  status = lua_cpcall(L, pmain, NULL);
  report(L, status);
  lua_close(L);
  return (status || smain.status > 0) ? EXIT_FAILURE : EXIT_SUCCESS;
}


1	/*
2	** LuaJIT frontend. Runs commands, scripts, read-eval-print (REPL) etc.
3	** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
4	**
5	** Major portions taken verbatim or adapted from the Lua interpreter.
6	** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
7	*/
8
9	#include <stdio.h>
10	#include <stdlib.h>
11	#include <string.h>
12
13	#define luajit_c
14
15	#include "lua.h"
16	#include "lauxlib.h"
17	#include "lualib.h"
18	#include "luajit.h"
19
20	#include "lj_arch.h"
21
22	#if LJ_TARGET_POSIX
23	#include <unistd.h>
24	#define lua_stdin_is_tty() isatty(0)
25	#elif LJ_TARGET_WINDOWS
26	#include <io.h>
27	#ifdef __BORLANDC__
28	#define lua_stdin_is_tty() isatty(_fileno(stdin))
29	#else
30	#define lua_stdin_is_tty() _isatty(_fileno(stdin))
31	#endif
32	#else
33	#define lua_stdin_is_tty() 1
34	#endif
35
36	#if !LJ_TARGET_CONSOLE
37	#include <signal.h>
38	#endif
39
40	static lua_State *globalL = NULL;
41	static const char *progname = LUA_PROGNAME;
42
43	#if !LJ_TARGET_CONSOLE
44	static void lstop(lua_State L, lua_Debug ar)	×
45	{
46	(void)ar; /* unused arg. */	×
47	lua_sethook(L, NULL, 0, 0);	×
48	/* Avoid luaL_error -- a C hook doesn't add an extra frame. */
49	luaL_where(L, 0);	×
50	lua_pushfstring(L, "%sinterrupted!", lua_tostring(L, -1));	×
51	lua_error(L);	×
52	}	×
53
54	static void laction(int i)	×
55	{
56	signal(i, SIG_DFL); /* if another SIGINT happens before lstop,	×
57	terminate process (default action) */
58	lua_sethook(globalL, lstop, LUA_MASKCALL \| LUA_MASKRET \| LUA_MASKCOUNT, 1);	×
59	}	×
60	#endif
61
62	static void print_usage(void)	5✔
63	{
64	fputs("usage: ", stderr);	5✔
65	fputs(progname, stderr);	5✔
66	fputs(" [options]... [script [args]...].\n"	5✔
67	"Available options are:\n"
68	" -e chunk Execute string " LUA_QL("chunk") ".\n"
69	" -l name Require library " LUA_QL("name") ".\n"
70	" -b ... Save or list bytecode.\n"
71	" -j cmd Perform LuaJIT control command.\n"
72	" -O[opt] Control LuaJIT optimizations.\n"
73	" -i Enter interactive mode after executing " LUA_QL("script") ".\n"
74	" -v Show version information.\n"
75	" -t<cmd> Execute tool.\n"
76	" -E Ignore environment variables.\n"
77	" -- Stop handling options.\n"
78	" - Execute stdin and stop handling options.\n", stderr);
79	fflush(stderr);	5✔
80	}	5✔
81
82	static void print_tools_usage(void)	2✔
83	{
84	fputs("usage: ", stderr);	2✔
85	fputs(progname, stderr);	2✔
86	fputs(" -t<cmd>\n"	2✔
87	"Available tools are:\n"
88	" -m [--leak-only] input Memprof profile data parser.\n"
89	" -s input Sysprof profile data parser.\n", stderr);
90	fflush(stderr);	2✔
91	}	2✔
92
93	static void l_message(const char pname, const char msg)	7✔
94	{
95	if (pname) { fputs(pname, stderr); fputc(':', stderr); fputc(' ', stderr); }	7✔
96	fputs(msg, stderr); fputc('\n', stderr);	7✔
97	fflush(stderr);	7✔
98	}	7✔
99
100	static int report(lua_State *L, int status)	633✔
101	{
102	if (status && !lua_isnil(L, -1)) {	633✔
103	const char *msg = lua_tostring(L, -1);	6✔
104	if (msg == NULL) msg = "(error object is not a string)";	6✔
105	l_message(progname, msg);	6✔
106	lua_pop(L, 1);	6✔
107	}
108	return status;	633✔
109	}
110
111	static int traceback(lua_State *L)	4✔
112	{
113	if (!lua_isstring(L, 1)) { /* Non-string error object? Try metamethod. */	4✔
114	if (lua_isnoneornil(L, 1) \|\|	2✔
115	!luaL_callmeta(L, 1, "__tostring") \|\|	1✔
UNCOV 116	!lua_isstring(L, -1))	×
117	return 1; /* Return non-string error object. */	1✔
UNCOV 118	lua_remove(L, 1); /* Replace object by result of __tostring metamethod. */	×
119	}
120	luaL_traceback(L, L, lua_tostring(L, 1), 1);	3✔
121	return 1;	3✔
122	}
123
124	static int docall(lua_State *L, int narg, int clear)	641✔
125	{
126	int status;	641✔
127	int base = lua_gettop(L) - narg; /* function index */	641✔
128	lua_pushcfunction(L, traceback); /* push traceback function */	641✔
129	lua_insert(L, base); /* put it under chunk and args */	641✔
130	#if !LJ_TARGET_CONSOLE
131	signal(SIGINT, laction);	641✔
132	#endif
133	status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);	929✔
134	#if !LJ_TARGET_CONSOLE
135	signal(SIGINT, SIG_DFL);	459✔
136	#endif
137	lua_remove(L, base); /* remove traceback function */	459✔
138	/* force a complete garbage collection in case of errors */
139	if (status != LUA_OK) lua_gc(L, LUA_GCCOLLECT, 0);	459✔
140	return status;	459✔
141	}
142
143	static void print_version(void)	8✔
144	{
145	fputs(LUAJIT_VERSION " -- " LUAJIT_COPYRIGHT ". " LUAJIT_URL "\n", stdout);	8✔
146	}	8✔
147
148	static void print_jit_status(lua_State *L)	4✔
149	{
150	int n;	4✔
151	const char *s;	4✔
152	lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");	4✔
153	lua_getfield(L, -1, "jit"); /* Get jit.* module table. */	4✔
154	lua_remove(L, -2);	4✔
155	lua_getfield(L, -1, "status");	4✔
156	lua_remove(L, -2);	4✔
157	n = lua_gettop(L);	4✔
158	lua_call(L, 0, LUA_MULTRET);	4✔
159	fputs(lua_toboolean(L, n) ? "JIT: ON" : "JIT: OFF", stdout);	4✔
160	for (n++; (s = lua_tostring(L, n)); n++) {	60✔
161	putc(' ', stdout);	56✔
162	fputs(s, stdout);	56✔
163	}
164	putc('\n', stdout);	4✔
165	lua_settop(L, 0); /* clear stack */	4✔
166	}	4✔
167
168	static void createargtable(lua_State L, char *argv, int argc, int argf)	340✔
169	{
170	int i;	340✔
171	lua_createtable(L, argc - argf, argf);	340✔
172	for (i = 0; i < argc; i++) {	2,176✔
173	lua_pushstring(L, argv[i]);	1,496✔
174	lua_rawseti(L, -2, i - argf);	1,496✔
175	}
176	lua_setglobal(L, "arg");	340✔
177	}	340✔
178
179	static int dofile(lua_State L, const char name)	1✔
180	{
181	int status = luaL_loadfile(L, name) \|\| docall(L, 0, 1);	1✔
182	return report(L, status);	1✔
183	}
184
185	static int dostring(lua_State L, const char s, const char *name)	297✔
186	{
187	int status = luaL_loadbuffer(L, s, strlen(s), name) \|\| docall(L, 0, 1);	297✔
188	return report(L, status);	294✔
189	}
190
191	static int dolibrary(lua_State L, const char name)	57✔
192	{
193	lua_getglobal(L, "require");	57✔
194	lua_pushstring(L, name);	57✔
195	return report(L, docall(L, 1, 1));	57✔
196	}
197
198	static void write_prompt(lua_State *L, int firstline)	131✔
199	{
200	const char *p;	131✔
201	lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");	240✔
202	p = lua_tostring(L, -1);	131✔
203	if (p == NULL) p = firstline ? LUA_PROMPT : LUA_PROMPT2;	131✔
204	fputs(p, stdout);	131✔
205	fflush(stdout);	131✔
206	lua_pop(L, 1); /* remove global */	131✔
207	}	131✔
208
209	static int incomplete(lua_State *L, int status)	127✔
210	{
211	if (status == LUA_ERRSYNTAX) {	127✔
212	size_t lmsg;	109✔
213	const char *msg = lua_tolstring(L, -1, &lmsg);	109✔
214	const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);	109✔
215	if (strstr(msg, LUA_QL("<eof>")) == tp) {	109✔
216	lua_pop(L, 1);	109✔
217	return 1;	109✔
218	}
219	}
220	return 0; /* else... */
221	}
222
223	static int pushline(lua_State *L, int firstline)	131✔
224	{
225	char buf[LUA_MAXINPUT];	131✔
226	write_prompt(L, firstline);	131✔
227	if (fgets(buf, LUA_MAXINPUT, stdin)) {	131✔
228	size_t len = strlen(buf);	127✔
229	if (len > 0 && buf[len-1] == '\n')	127✔
230	buf[len-1] = '\0';	125✔
231	if (firstline && buf[0] == '=')	127✔
232	lua_pushfstring(L, "return %s", buf+1);	5✔
233	else
234	lua_pushstring(L, buf);	122✔
235	return 1;	127✔
236	}
237	return 0;
238	}
239
240	static int loadline(lua_State *L)	22✔
241	{
242	int status;	22✔
243	lua_settop(L, 0);	22✔
244	if (!pushline(L, 1))	22✔
245	return -1; /* no input */
246	for (;;) { /* repeat until gets a complete line */	236✔
247	status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");	127✔
248	if (!incomplete(L, status)) break; /* cannot try to add lines? */	127✔
249	if (!pushline(L, 0)) /* no more input? */	109✔
250	return -1;
251	lua_pushliteral(L, "\n"); /* add a new line... */	109✔
252	lua_insert(L, -2); /* ...between the two lines */	109✔
253	lua_concat(L, 3); /* join them */	109✔
254	}
255	lua_remove(L, 1); /* remove line */	18✔
256	return status;	18✔
257	}
258
259	static void dotty(lua_State *L)	4✔
260	{
261	int status;	4✔
262	const char *oldprogname = progname;	4✔
263	progname = NULL;	4✔
264	while ((status = loadline(L)) != -1) {	26✔
265	if (status == LUA_OK) status = docall(L, 0, 0);	18✔
266	report(L, status);	18✔
267	if (status == LUA_OK && lua_gettop(L) > 0) { /* any result to print? */	18✔
268	lua_getglobal(L, "print");	5✔
269	lua_insert(L, 1);	5✔
270	if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)	5✔
271	l_message(progname,	×
272	lua_pushfstring(L, "error calling " LUA_QL("print") " (%s)",
273	lua_tostring(L, -1)));
274	}
275	}
276	lua_settop(L, 0); /* clear stack */	4✔
277	fputs("\n", stdout);	4✔
278	fflush(stdout);	4✔
279	progname = oldprogname;	4✔
280	}	4✔
281
282	static int handle_script(lua_State L, char *argx)	271✔
283	{
284	int status;	271✔
285	const char *fname = argx[0];	271✔
286	if (strcmp(fname, "-") == 0 && strcmp(argx[-1], "--") != 0)	271✔
287	fname = NULL; /* stdin */	4✔
288	status = luaL_loadfile(L, fname);	271✔
289	if (status == LUA_OK) {	271✔
290	/* Fetch args from arg table. LUA_INIT or -e might have changed them. */
291	int narg = 0;	270✔
292	lua_getglobal(L, "arg");	270✔
293	if (lua_istable(L, -1)) {	270✔
294	do {	329✔
295	narg++;	329✔
296	lua_rawgeti(L, -narg, narg);	329✔
297	} while (!lua_isnil(L, -1));	329✔
298	lua_pop(L, 1);	270✔
299	lua_remove(L, -narg);	270✔
300	narg--;	270✔
301	} else {
302	lua_pop(L, 1);	×
303	}
304	status = docall(L, narg, 0);	270✔
305	}
306	return report(L, status);	92✔
307	}
308
309	/* Load add-on module. */
310	static int loadjitmodule(lua_State *L)	17✔
311	{
312	lua_getglobal(L, "require");	17✔
313	lua_pushliteral(L, "jit.");	17✔
314	lua_pushvalue(L, -3);	17✔
315	lua_concat(L, 2);	17✔
316	if (lua_pcall(L, 1, 1, 0)) {	17✔
317	const char *msg = lua_tostring(L, -1);	1✔
318	if (msg && !strncmp(msg, "module ", 7))	1✔
319	goto nomodule;	1✔
320	return report(L, 1);	×
321	}
322	lua_getfield(L, -1, "start");	16✔
323	if (lua_isnil(L, -1)) {	16✔
324	nomodule:	×
325	l_message(progname,	1✔
326	"unknown luaJIT command or jit.* modules not installed");
327	return 1;	1✔
328	}
329	lua_remove(L, -2); /* Drop module table. */	16✔
330	return 0;	16✔
331	}
332
333	/* Run command with options. */
334	static int runcmdopt(lua_State L, const char opt)	10✔
335	{
336	int narg = 0;	10✔
337	if (opt && *opt) {	10✔
338	for (;;) { /* Split arguments. */	10✔
339	const char *p = strchr(opt, ',');	8✔
340	narg++;	8✔
341	if (!p) break;	8✔
342	if (p == opt)	2✔
343	lua_pushnil(L);	×
344	else
345	lua_pushlstring(L, opt, (size_t)(p - opt));	2✔
346	opt = p + 1;	2✔
347	}
348	if (*opt)	6✔
349	lua_pushstring(L, opt);	6✔
350	else
351	lua_pushnil(L);	×
352	}
353	return report(L, lua_pcall(L, narg, 0, 0));	10✔
354	}
355
356	/* JIT engine control command: try jit library first or load add-on module. */
357	static int dojitcmd(lua_State L, const char cmd)	4✔
358	{
359	const char *opt = strchr(cmd, '=');	4✔
360	lua_pushlstring(L, cmd, opt ? (size_t)(opt - cmd) : strlen(cmd));	4✔
361	lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");	4✔
362	lua_getfield(L, -1, "jit"); /* Get jit.* module table. */	4✔
363	lua_remove(L, -2);	4✔
364	lua_pushvalue(L, -2);	4✔
365	lua_gettable(L, -2); /* Lookup library function. */	4✔
366	if (!lua_isfunction(L, -1)) {	4✔
367	lua_pop(L, 2); /* Drop non-function and jit.* table, keep module name. */	1✔
368	if (loadjitmodule(L))	1✔
369	return 1;
370	} else {
371	lua_remove(L, -2); /* Drop jit.* table. */	3✔
372	}
373	lua_remove(L, -2); /* Drop module name. */	3✔
374	return runcmdopt(L, opt ? opt+1 : opt);	3✔
375	}
376
377	static int runtoolcmd(lua_State L, const char tool_name)	18✔
378	{
379	lua_getglobal(L, "require");	18✔
380	lua_pushstring(L, tool_name);	18✔
381	if (lua_pcall(L, 1, 1, 0)) {	18✔
382	const char *msg = lua_tostring(L, -1);	×
383	if (msg) {	×
384	if (!strncmp(msg, "module ", 7))	×
385	msg = "unknown luaJIT command or tools not installed";	×
386	l_message(progname, msg);	×
387	}
388	return 1;	×
389	}
390	lua_getglobal(L, "arg");	18✔
391	return report(L, lua_pcall(L, 1, 1, 0));	18✔
392	}
393
394	static int dotoolcmd(lua_State L, const char cmd)
395	{
396	switch (cmd[0]) {
397	case 'm':
398	return runtoolcmd(L, "memprof");
399	case 's':
400	return runtoolcmd(L, "sysprof");
401	default:
402	print_tools_usage();
403	break;
404	}
405	return -1;
406	}
407
408	/* Optimization flags. */
409	static int dojitopt(lua_State L, const char opt)	7✔
410	{
411	lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");	7✔
412	lua_getfield(L, -1, "jit.opt"); /* Get jit.opt.* module table. */	7✔
413	lua_remove(L, -2);	7✔
414	lua_getfield(L, -1, "start");	7✔
415	lua_remove(L, -2);	7✔
416	return runcmdopt(L, opt);	7✔
417	}
418
419	/* Save or list bytecode. */
420	static int dobytecode(lua_State L, char *argv)	16✔
421	{
422	int narg = 0;	16✔
423	lua_pushliteral(L, "bcsave");	16✔
424	if (loadjitmodule(L))	16✔
425	return 1;
426	if (argv[0][2]) {	16✔
427	narg++;	4✔
428	argv[0][1] = '-';	4✔
429	lua_pushstring(L, argv[0]+1);	4✔
430	}
431	for (argv++; *argv != NULL; narg++, argv++)	57✔
432	lua_pushstring(L, *argv);	41✔
433	report(L, lua_pcall(L, narg, 0, 0));	16✔
434	return -1;	16✔
435	}
436
437	/* check that argument has no extra characters at the end */
438	#define notail(x) {if ((x)[2] != '\0') return -1;}
439
440	#define FLAGS_INTERACTIVE 1
441	#define FLAGS_VERSION 2
442	#define FLAGS_EXEC 4
443	#define FLAGS_OPTION 8
444	#define FLAGS_NOENV 16
445	#define FLAGS_TOOL 32
446
447	static int collectargs(char *argv, int flags)	345✔
448	{
449	int i;	345✔
450	for (i = 1; argv[i] != NULL; i++) {	719✔
451	if (argv[i][0] != '-') /* Not an option? */	689✔
452	return i;	268✔
453	switch (argv[i][1]) { /* Check option. */	421✔
454	case '-':	3✔
455	notail(argv[i]);	3✔
456	return i+1;	2✔
457	case '\0':
458	return i;
459	case 'i':	4✔
460	notail(argv[i]);	4✔
461	*flags \|= FLAGS_INTERACTIVE;	4✔
462	/* fallthrough */
463	case 'v':	8✔
464	notail(argv[i]);	8✔
465	*flags \|= FLAGS_VERSION;	8✔
466	break;	8✔
467	case 't':	20✔
468	*flags \|= FLAGS_TOOL;	20✔
469	return i + 1;	20✔
470	case 'e':	299✔
471	*flags \|= FLAGS_EXEC;	299✔
472	/* fallthrough */
473	case 'j': /* LuaJIT extension */	360✔
474	case 'l':
475	*flags \|= FLAGS_OPTION;	360✔
476	if (argv[i][2] == '\0') {	360✔
477	i++;	346✔
478	if (argv[i] == NULL) return -1;	346✔
479	}
480	break;
481	case 'O': break; /* LuaJIT extension */
482	case 'b': /* LuaJIT extension */	16✔
483	if (*flags) return -1;	16✔
484	*flags \|= FLAGS_EXEC;	16✔
485	return i+1;	16✔
486	case 'E':	1✔
487	*flags \|= FLAGS_NOENV;	1✔
488	break;	1✔
489	default: return -1; /* invalid option */
490	}
491	}
492	return i;
493	}
494
495	static int runargs(lua_State L, char *argv, int argn)	340✔
496	{
497	int i;	340✔
498	for (i = 1; i < argn; i++) {	708✔
499	if (argv[i] == NULL) continue;	412✔
500	lua_assert(argv[i][0] == '-');	412✔
501	switch (argv[i][1]) {	412✔
502	case 'e': {	297✔
503	const char *chunk = argv[i] + 2;	297✔
504	if (*chunk == '\0') chunk = argv[++i];	297✔
505	lua_assert(chunk != NULL);	297✔
506	if (dostring(L, chunk, "=(command line)") != 0)	297✔
507	return 1;
508	break;
509	}
510	case 'l': {	57✔
511	const char *filename = argv[i] + 2;	57✔
512	if (*filename == '\0') filename = argv[++i];	57✔
513	lua_assert(filename != NULL);	57✔
514	if (dolibrary(L, filename))	57✔
515	return 1;
516	break;
517	}
518	case 'j': { /* LuaJIT extension. */	4✔
519	const char *cmd = argv[i] + 2;	4✔
520	if (*cmd == '\0') cmd = argv[++i];	4✔
521	lua_assert(cmd != NULL);	4✔
522	if (dojitcmd(L, cmd))	4✔
523	return 1;
524	break;
525	}
526	case 't': { /* Tarantool's fork extension. */	20✔
527	const char *cmd = argv[i] + 2;	20✔
528	return dotoolcmd(L, cmd) != LUA_OK;	20✔
529	}
530	case 'O': /* LuaJIT extension. */	7✔
531	if (dojitopt(L, argv[i] + 2))	7✔
532	return 1;
533	break;
534	case 'b': /* LuaJIT extension. */	16✔
535	return dobytecode(L, argv+i);	16✔
536	default: break;
537	}
538	}
539	return LUA_OK;
540	}
541
542	static int handle_luainit(lua_State *L)	339✔
543	{
544	#if LJ_TARGET_CONSOLE
545	const char *init = NULL;
546	#else
547	const char *init = getenv(LUA_INIT);	339✔
548	#endif
549	if (init == NULL)	339✔
550	return LUA_OK;
551	else if (init[0] == '@')	×
552	return dofile(L, init+1);	×
553	else
554	return dostring(L, init, "=" LUA_INIT);	×
555	}
556
557	static struct Smain {
558	char **argv;
559	int argc;
560	int status;
561	} smain;
562
563	static int pmain(lua_State *L)	345✔
564	{
565	struct Smain *s = &smain;	345✔
566	char **argv = s->argv;	345✔
567	int argn;	345✔
568	int flags = 0;	345✔
569	globalL = L;	345✔
570	if (argv[0] && argv[0][0]) progname = argv[0];	345✔
571
572	LUAJIT_VERSION_SYM(); /* Linker-enforced version check. */	345✔
573
574	argn = collectargs(argv, &flags);	345✔
575	if (argn < 0) { /* Invalid args? */	345✔
576	print_usage();	5✔
577	s->status = 1;	5✔
578	return 0;	5✔
579	}
580
581	if ((flags & FLAGS_NOENV)) {	340✔
582	lua_pushboolean(L, 1);	1✔
583	lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");	1✔
584	}
585
586	/* Stop collector during library initialization. */
587	lua_gc(L, LUA_GCSTOP, 0);	340✔
588	luaL_openlibs(L);	340✔
589	lua_gc(L, LUA_GCRESTART, -1);	340✔
590
591	createargtable(L, argv, s->argc, (flags & FLAGS_TOOL) ? argn - 1 : argn);	340✔
592
593	if (!(flags & FLAGS_NOENV)) {	340✔
594	s->status = handle_luainit(L);	339✔
595	if (s->status != LUA_OK) return 0;	339✔
596	}
597
598	if ((flags & FLAGS_VERSION)) print_version();	340✔
599
600	s->status = runargs(L, argv, argn);	340✔
601	if (s->status != LUA_OK) return 0;	319✔
602
603	if (s->argc > argn) {	296✔
604	s->status = handle_script(L, argv + argn);	271✔
605	if (s->status != LUA_OK) return 0;	92✔
606	}
607
608	if ((flags & FLAGS_INTERACTIVE)) {	115✔
609	print_jit_status(L);	4✔
610	dotty(L);	4✔
611	} else if (s->argc == argn && !(flags & (FLAGS_EXEC\|FLAGS_VERSION))) {	111✔
612	if (lua_stdin_is_tty()) {	1✔
613	print_version();	×
614	print_jit_status(L);	×
615	dotty(L);	×
616	} else {
617	dofile(L, NULL); /* Executes stdin as a file. */	1✔
618	}
619	}
620	return 0;
621	}
622
623	int main(int argc, char **argv)	345✔
624	{
625	int status;	345✔
626	lua_State *L = lua_open();	345✔
627	if (L == NULL) {	345✔
628	l_message(argv[0], "cannot create state: not enough memory");	×
629	return EXIT_FAILURE;	×
630	}
631	smain.argc = argc;	345✔
632	smain.argv = argv;	345✔
633	status = lua_cpcall(L, pmain, NULL);	345✔
634	report(L, status);	145✔
635	lua_close(L);	145✔
636	return (status \|\| smain.status > 0) ? EXIT_FAILURE : EXIT_SUCCESS;	145✔
637	}
638

tarantool / luajit / 11382361258

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous