11139910794

Committed 02 Oct 2024 07:45AM UTC coverage: 92.891% (+0.006%) from 92.885%

Build # 11139910794

Build Type

push

github

Committed by

Buristan

Commit Message

Fix bit op coercion in DUALNUM builds.

Thanks to Sergey Kaplun.

(cherry picked from commit f5fd22203)

The `lj_carith_check64()` function coerces the given number value to the
32-bit wide value. In this case, the 64-bit-wide operands will lose
upper bits.

This patch removes the excess coercion for the DUALNUM mode and drops
the corresponding skipcond introduced for the test in the previous
commit.

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

Part of tarantool/tarantool#10199

Run Details

5684 of 6026 branches covered (94.32%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

21679 of 23431 relevant lines covered (92.52%)

2951479.61 hits per line

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

84.21

/src/lj_load.c

/*
** Load and dump code.
** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
*/

#include <errno.h>
#include <stdio.h>

#define lj_load_c
#define LUA_CORE

#include "lua.h"
#include "lauxlib.h"

#include "lj_obj.h"
#include "lj_gc.h"
#include "lj_err.h"
#include "lj_buf.h"
#include "lj_func.h"
#include "lj_frame.h"
#include "lj_vm.h"
#include "lj_lex.h"
#include "lj_bcdump.h"
#include "lj_parse.h"

/* -- Load Lua source code and bytecode ----------------------------------- */

static TValue *cpparser(lua_State *L, lua_CFunction dummy, void *ud)
{
  LexState *ls = (LexState *)ud;
  GCproto *pt;
  GCfunc *fn;
  int bc;
  UNUSED(dummy);
  cframe_errfunc(L->cframe) = -1;  /* Inherit error function. */
  bc = lj_lex_setup(L, ls);
  if (ls->mode && !strchr(ls->mode, bc ? 'b' : 't')) {
    setstrV(L, L->top++, lj_err_str(L, LJ_ERR_XMODE));
    lj_err_throw(L, LUA_ERRSYNTAX);
  }
  pt = bc ? lj_bcread(ls) : lj_parse(ls);
  fn = lj_func_newL_empty(L, pt, tabref(L->env));
  /* Don't combine above/below into one statement. */
  setfuncV(L, L->top++, fn);
  return NULL;
}

LUA_API int lua_loadx(lua_State *L, lua_Reader reader, void *data,
                      const char *chunkname, const char *mode)
{
  LexState ls;
  int status;
  ls.rfunc = reader;
  ls.rdata = data;
  ls.chunkarg = chunkname ? chunkname : "?";
  ls.mode = mode;
  lj_buf_init(L, &ls.sb);
  status = lj_vm_cpcall(L, NULL, &ls, cpparser);
  lj_lex_cleanup(L, &ls);
  lj_gc_check(L);
  return status;
}

LUA_API int lua_load(lua_State *L, lua_Reader reader, void *data,
                     const char *chunkname)
{
  return lua_loadx(L, reader, data, chunkname, NULL);
}

typedef struct FileReaderCtx {
  FILE *fp;
  char buf[LUAL_BUFFERSIZE];
} FileReaderCtx;

static const char *reader_file(lua_State *L, void *ud, size_t *size)
{
  FileReaderCtx *ctx = (FileReaderCtx *)ud;
  UNUSED(L);
  if (feof(ctx->fp)) return NULL;
  *size = fread(ctx->buf, 1, sizeof(ctx->buf), ctx->fp);
  return *size > 0 ? ctx->buf : NULL;
}

LUALIB_API int luaL_loadfilex(lua_State *L, const char *filename,
                              const char *mode)
{
  FileReaderCtx ctx;
  int status;
  const char *chunkname;
  if (filename) {
    ctx.fp = fopen(filename, "rb");
    if (ctx.fp == NULL) {
      lua_pushfstring(L, "cannot open %s: %s", filename, strerror(errno));
      return LUA_ERRFILE;
    }
    chunkname = lua_pushfstring(L, "@%s", filename);
  } else {
    ctx.fp = stdin;
    chunkname = "=stdin";
  }
  status = lua_loadx(L, reader_file, &ctx, chunkname, mode);
  if (ferror(ctx.fp)) {
    L->top -= filename ? 2 : 1;
    lua_pushfstring(L, "cannot read %s: %s", chunkname+1, strerror(errno));
    if (filename)
      fclose(ctx.fp);
    return LUA_ERRFILE;
  }
  if (filename) {
    L->top--;
    copyTV(L, L->top-1, L->top);
    fclose(ctx.fp);
  }
  return status;
}

LUALIB_API int luaL_loadfile(lua_State *L, const char *filename)
{
  return luaL_loadfilex(L, filename, NULL);
}

typedef struct StringReaderCtx {
  const char *str;
  size_t size;
} StringReaderCtx;

static const char *reader_string(lua_State *L, void *ud, size_t *size)
{
  StringReaderCtx *ctx = (StringReaderCtx *)ud;
  UNUSED(L);
  if (ctx->size == 0) return NULL;
  *size = ctx->size;
  ctx->size = 0;
  return ctx->str;
}

LUALIB_API int luaL_loadbufferx(lua_State *L, const char *buf, size_t size,
                                const char *name, const char *mode)
{
  StringReaderCtx ctx;
  ctx.str = buf;
  ctx.size = size;
  return lua_loadx(L, reader_string, &ctx, name, mode);
}

LUALIB_API int luaL_loadbuffer(lua_State *L, const char *buf, size_t size,
                               const char *name)
{
  return luaL_loadbufferx(L, buf, size, name, NULL);
}

LUALIB_API int luaL_loadstring(lua_State *L, const char *s)
{
  return luaL_loadbuffer(L, s, strlen(s), s);
}

/* -- Dump bytecode ------------------------------------------------------- */

LUA_API int lua_dump(lua_State *L, lua_Writer writer, void *data)
{
  cTValue *o = L->top-1;
  lj_checkapi(L->top > L->base, "top slot empty");
  if (tvisfunc(o) && isluafunc(funcV(o)))
    return lj_bcwrite(L, funcproto(funcV(o)), writer, data, 0);
  else
    return 1;
}


1	/*
2	** Load and dump code.
3	** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
4	*/
5
6	#include <errno.h>
7	#include <stdio.h>
8
9	#define lj_load_c
10	#define LUA_CORE
11
12	#include "lua.h"
13	#include "lauxlib.h"
14
15	#include "lj_obj.h"
16	#include "lj_gc.h"
17	#include "lj_err.h"
18	#include "lj_buf.h"
19	#include "lj_func.h"
20	#include "lj_frame.h"
21	#include "lj_vm.h"
22	#include "lj_lex.h"
23	#include "lj_bcdump.h"
24	#include "lj_parse.h"
25
26	/* -- Load Lua source code and bytecode ----------------------------------- */
27
28	static TValue cpparser(lua_State L, lua_CFunction dummy, void *ud)	53,509✔
29	{
30	LexState ls = (LexState )ud;	53,509✔
31	GCproto *pt;	53,509✔
32	GCfunc *fn;	53,509✔
33	int bc;	53,509✔
34	UNUSED(dummy);	53,509✔
35	cframe_errfunc(L->cframe) = -1; /* Inherit error function. */	53,509✔
36	bc = lj_lex_setup(L, ls);	53,509✔
37	if (ls->mode && !strchr(ls->mode, bc ? 'b' : 't')) {	53,509✔
38	setstrV(L, L->top++, lj_err_str(L, LJ_ERR_XMODE));	×
39	lj_err_throw(L, LUA_ERRSYNTAX);	×
40	}
41	pt = bc ? lj_bcread(ls) : lj_parse(ls);	53,507✔
42	fn = lj_func_newL_empty(L, pt, tabref(L->env));	40,792✔
43	/* Don't combine above/below into one statement. */
44	setfuncV(L, L->top++, fn);	40,792✔
45	return NULL;	40,792✔
46	}
47
48	LUA_API int lua_loadx(lua_State L, lua_Reader reader, void data,	53,509✔
49	const char chunkname, const char mode)
50	{
51	LexState ls;	53,509✔
52	int status;	53,509✔
53	ls.rfunc = reader;	53,509✔
54	ls.rdata = data;	53,509✔
55	ls.chunkarg = chunkname ? chunkname : "?";	53,509✔
56	ls.mode = mode;	53,509✔
57	lj_buf_init(L, &ls.sb);	53,509✔
58	status = lj_vm_cpcall(L, NULL, &ls, cpparser);	53,509✔
59	lj_lex_cleanup(L, &ls);	53,509✔
60	lj_gc_check(L);	53,509✔
61	return status;	53,509✔
62	}
63
64	LUA_API int lua_load(lua_State L, lua_Reader reader, void data,	2✔
65	const char *chunkname)
66	{
67	return lua_loadx(L, reader, data, chunkname, NULL);	2✔
68	}
69
70	typedef struct FileReaderCtx {
71	FILE *fp;
72	char buf[LUAL_BUFFERSIZE];
73	} FileReaderCtx;
74
75	static const char reader_file(lua_State L, void ud, size_t size)	2,721✔
76	{
77	FileReaderCtx ctx = (FileReaderCtx )ud;	2,721✔
78	UNUSED(L);	2,721✔
79	if (feof(ctx->fp)) return NULL;	2,721✔
80	*size = fread(ctx->buf, 1, sizeof(ctx->buf), ctx->fp);	1,602✔
81	return *size > 0 ? ctx->buf : NULL;	1,602✔
82	}
83
84	LUALIB_API int luaL_loadfilex(lua_State L, const char filename,	1,132✔
85	const char *mode)
86	{
87	FileReaderCtx ctx;	1,132✔
88	int status;	1,132✔
89	const char *chunkname;	1,132✔
90	if (filename) {	1,132✔
91	ctx.fp = fopen(filename, "rb");	1,125✔
92	if (ctx.fp == NULL) {	1,125✔
93	lua_pushfstring(L, "cannot open %s: %s", filename, strerror(errno));	4✔
94	return LUA_ERRFILE;	4✔
95	}
96	chunkname = lua_pushfstring(L, "@%s", filename);	1,121✔
97	} else {
98	ctx.fp = stdin;	7✔
99	chunkname = "=stdin";	7✔
100	}
101	status = lua_loadx(L, reader_file, &ctx, chunkname, mode);	1,128✔
102	if (ferror(ctx.fp)) {	1,128✔
103	L->top -= filename ? 2 : 1;	×
104	lua_pushfstring(L, "cannot read %s: %s", chunkname+1, strerror(errno));	×
105	if (filename)	×
106	fclose(ctx.fp);	×
107	return LUA_ERRFILE;	×
108	}
109	if (filename) {	1,128✔
110	L->top--;	1,121✔
111	copyTV(L, L->top-1, L->top);	1,121✔
112	fclose(ctx.fp);	1,121✔
113	}
114	return status;
115	}
116
117	LUALIB_API int luaL_loadfile(lua_State L, const char filename)	1,090✔
118	{
119	return luaL_loadfilex(L, filename, NULL);	1,090✔
120	}
121
122	typedef struct StringReaderCtx {
123	const char *str;
124	size_t size;
125	} StringReaderCtx;
126
127	static const char reader_string(lua_State L, void ud, size_t size)	95,193✔
128	{
129	StringReaderCtx ctx = (StringReaderCtx )ud;	95,193✔
130	UNUSED(L);	95,193✔
131	if (ctx->size == 0) return NULL;	95,193✔
132	*size = ctx->size;	52,213✔
133	ctx->size = 0;	52,213✔
134	return ctx->str;	52,213✔
135	}
136
137	LUALIB_API int luaL_loadbufferx(lua_State L, const char buf, size_t size,	52,222✔
138	const char name, const char mode)
139	{
140	StringReaderCtx ctx;	52,222✔
141	ctx.str = buf;	52,222✔
142	ctx.size = size;	52,222✔
143	return lua_loadx(L, reader_string, &ctx, name, mode);	51,800✔
144	}
145
146	LUALIB_API int luaL_loadbuffer(lua_State L, const char buf, size_t size,	422✔
147	const char *name)
148	{
149	return luaL_loadbufferx(L, buf, size, name, NULL);	417✔
150	}
151
152	LUALIB_API int luaL_loadstring(lua_State L, const char s)	5✔
153	{
154	return luaL_loadbuffer(L, s, strlen(s), s);	5✔
155	}
156
157	/* -- Dump bytecode ------------------------------------------------------- */
158
159	LUA_API int lua_dump(lua_State L, lua_Writer writer, void data)	×
160	{
161	cTValue *o = L->top-1;	×
162	lj_checkapi(L->top > L->base, "top slot empty");	×
163	if (tvisfunc(o) && isluafunc(funcV(o)))	×
164	return lj_bcwrite(L, funcproto(funcV(o)), writer, data, 0);	×
165	else
166	return 1;
167	}
168

tarantool / luajit / 11139910794

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