11373217526

Committed 16 Oct 2024 08:10PM UTC coverage: 92.917% (-0.02%) from 92.934%

Build # 11373217526

Build Type

push

github

Committed by

Buristan

Commit Message

Restore state when recording __concat metamethod throws an error.

Thanks to Sergey Kaplun.

(cherry picked from commit 7421a1b33)

Since neither `rec_cat()` nor `lj_record_ret()` restore the Lua stack,
if the error is raised, it leads either to a crash in `BC_RET` or to the
"unbalanced stack" assertion failure.

This patch protects the `rec_mm_arith()`, which can raise an error. Its
caller returns the negated error code to be rethrown in case of the
caught error.

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 420748c99)

Run Details

5695 of 6032 branches covered (94.41%)

Branch coverage included in aggregate %.

15 of 16 new or added lines in 1 file covered. (93.75%)

13 existing lines in 5 files now uncovered.

21696 of 23447 relevant lines covered (92.53%)

2933791.98 hits per line

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

90.0

/src/lj_vmmath.c

/*
** Math helper functions for assembler VM.
** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
*/

#define lj_vmmath_c
#define LUA_CORE

#include <errno.h>
#include <math.h>

#include "lj_obj.h"
#include "lj_ir.h"
#include "lj_vm.h"

/* -- Wrapper functions --------------------------------------------------- */

#if LJ_TARGET_X86 && __ELF__ && __PIC__
/* Wrapper functions to deal with the ELF/x86 PIC disaster. */
LJ_FUNCA double lj_wrap_log(double x) { return log(x); }
LJ_FUNCA double lj_wrap_log10(double x) { return log10(x); }
LJ_FUNCA double lj_wrap_exp(double x) { return exp(x); }
LJ_FUNCA double lj_wrap_sin(double x) { return sin(x); }
LJ_FUNCA double lj_wrap_cos(double x) { return cos(x); }
LJ_FUNCA double lj_wrap_tan(double x) { return tan(x); }
LJ_FUNCA double lj_wrap_asin(double x) { return asin(x); }
LJ_FUNCA double lj_wrap_acos(double x) { return acos(x); }
LJ_FUNCA double lj_wrap_atan(double x) { return atan(x); }
LJ_FUNCA double lj_wrap_sinh(double x) { return sinh(x); }
LJ_FUNCA double lj_wrap_cosh(double x) { return cosh(x); }
LJ_FUNCA double lj_wrap_tanh(double x) { return tanh(x); }
LJ_FUNCA double lj_wrap_atan2(double x, double y) { return atan2(x, y); }
LJ_FUNCA double lj_wrap_pow(double x, double y) { return pow(x, y); }
LJ_FUNCA double lj_wrap_fmod(double x, double y) { return fmod(x, y); }
#endif

/* -- Helper functions ---------------------------------------------------- */

double lj_vm_foldarith(double x, double y, int op)
{
  switch (op) {
  case IR_ADD - IR_ADD: return x+y; break;
  case IR_SUB - IR_ADD: return x-y; break;
  case IR_MUL - IR_ADD: return x*y; break;
  case IR_DIV - IR_ADD: return x/y; break;
  case IR_MOD - IR_ADD: return x-lj_vm_floor(x/y)*y; break;
  case IR_POW - IR_ADD: return pow(x, y); break;
  case IR_NEG - IR_ADD: return -x; break;
  case IR_ABS - IR_ADD: return fabs(x); break;
#if LJ_HASJIT
  case IR_LDEXP - IR_ADD: return ldexp(x, (int)y); break;
  case IR_MIN - IR_ADD: return x < y ? x : y; break;
  case IR_MAX - IR_ADD: return x > y ? x : y; break;
#endif
  default: return x;
  }
}

/* -- Helper functions for generated machine code ------------------------- */

#if (LJ_HASJIT && !(LJ_TARGET_ARM || LJ_TARGET_ARM64 || LJ_TARGET_PPC)) || LJ_TARGET_MIPS
int32_t LJ_FASTCALL lj_vm_modi(int32_t a, int32_t b)
{
  uint32_t y, ua, ub;
  /* This must be checked before using this function. */
  lj_assertX(b != 0, "modulo with zero divisor");
  ua = a < 0 ? ~(uint32_t)a+1u : (uint32_t)a;
  ub = b < 0 ? ~(uint32_t)b+1u : (uint32_t)b;
  y = ua % ub;
  if (y != 0 && (a^b) < 0) y = y - ub;
  if (((int32_t)y^b) < 0) y = ~y+1u;
  return (int32_t)y;
}
#endif

#if LJ_HASJIT

#ifdef LUAJIT_NO_LOG2
double lj_vm_log2(double a)
{
  return log(a) * 1.4426950408889634074;
}
#endif

/* Computes fpm(x) for extended math functions. */
double lj_vm_foldfpm(double x, int fpm)
{
  switch (fpm) {
  case IRFPM_FLOOR: return lj_vm_floor(x);
  case IRFPM_CEIL: return lj_vm_ceil(x);
  case IRFPM_TRUNC: return lj_vm_trunc(x);
  case IRFPM_SQRT: return sqrt(x);
  case IRFPM_LOG: return log(x);
  case IRFPM_LOG2: return lj_vm_log2(x);
  default: lj_assertX(0, "bad fpm %d", fpm);
  }
  return 0;
}

#if LJ_HASFFI
int lj_vm_errno(void)
{
  return errno;
}
#endif

#endif

1	/*
2	** Math helper functions for assembler VM.
3	** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
4	*/
5
6	#define lj_vmmath_c
7	#define LUA_CORE
8
9	#include <errno.h>
10	#include <math.h>
11
12	#include "lj_obj.h"
13	#include "lj_ir.h"
14	#include "lj_vm.h"
15
16	/* -- Wrapper functions --------------------------------------------------- */
17
18	#if LJ_TARGET_X86 && __ELF__ && __PIC__
19	/* Wrapper functions to deal with the ELF/x86 PIC disaster. */
20	LJ_FUNCA double lj_wrap_log(double x) { return log(x); }
21	LJ_FUNCA double lj_wrap_log10(double x) { return log10(x); }
22	LJ_FUNCA double lj_wrap_exp(double x) { return exp(x); }
23	LJ_FUNCA double lj_wrap_sin(double x) { return sin(x); }
24	LJ_FUNCA double lj_wrap_cos(double x) { return cos(x); }
25	LJ_FUNCA double lj_wrap_tan(double x) { return tan(x); }
26	LJ_FUNCA double lj_wrap_asin(double x) { return asin(x); }
27	LJ_FUNCA double lj_wrap_acos(double x) { return acos(x); }
28	LJ_FUNCA double lj_wrap_atan(double x) { return atan(x); }
29	LJ_FUNCA double lj_wrap_sinh(double x) { return sinh(x); }
30	LJ_FUNCA double lj_wrap_cosh(double x) { return cosh(x); }
31	LJ_FUNCA double lj_wrap_tanh(double x) { return tanh(x); }
32	LJ_FUNCA double lj_wrap_atan2(double x, double y) { return atan2(x, y); }
33	LJ_FUNCA double lj_wrap_pow(double x, double y) { return pow(x, y); }
34	LJ_FUNCA double lj_wrap_fmod(double x, double y) { return fmod(x, y); }
35	#endif
36
37	/* -- Helper functions ---------------------------------------------------- */
38
39	double lj_vm_foldarith(double x, double y, int op)	30,411✔
40	{
41	switch (op) {	30,411✔
42	case IR_ADD - IR_ADD: return x+y; break;	20,276✔
43	case IR_SUB - IR_ADD: return x-y; break;	1,068✔
44	case IR_MUL - IR_ADD: return x*y; break;	299✔
45	case IR_DIV - IR_ADD: return x/y; break;	62✔
46	case IR_MOD - IR_ADD: return x-lj_vm_floor(x/y)*y; break;	19✔
47	case IR_POW - IR_ADD: return pow(x, y); break;	7,833✔
48	case IR_NEG - IR_ADD: return -x; break;	13✔
49	case IR_ABS - IR_ADD: return fabs(x); break;	7✔
50	#if LJ_HASJIT
51	case IR_LDEXP - IR_ADD: return ldexp(x, (int)y); break;	41✔
52	case IR_MIN - IR_ADD: return x < y ? x : y; break;	4✔
53	case IR_MAX - IR_ADD: return x > y ? x : y; break;	789✔
54	#endif
55	default: return x;
56	}
57	}
58
59	/* -- Helper functions for generated machine code ------------------------- */
60
61	#if (LJ_HASJIT && !(LJ_TARGET_ARM \|\| LJ_TARGET_ARM64 \|\| LJ_TARGET_PPC)) \|\| LJ_TARGET_MIPS
62	int32_t LJ_FASTCALL lj_vm_modi(int32_t a, int32_t b)	6,985✔
63	{
64	uint32_t y, ua, ub;	6,985✔
65	/* This must be checked before using this function. */
66	lj_assertX(b != 0, "modulo with zero divisor");	6,985✔
67	ua = a < 0 ? ~(uint32_t)a+1u : (uint32_t)a;	6,985✔
68	ub = b < 0 ? ~(uint32_t)b+1u : (uint32_t)b;	6,985✔
69	y = ua % ub;	6,985✔
70	if (y != 0 && (a^b) < 0) y = y - ub;	6,985✔
71	if (((int32_t)y^b) < 0) y = ~y+1u;	6,985✔
72	return (int32_t)y;	6,985✔
73	}
74	#endif
75
76	#if LJ_HASJIT
77
78	#ifdef LUAJIT_NO_LOG2
79	double lj_vm_log2(double a)
80	{
81	return log(a) * 1.4426950408889634074;
82	}
83	#endif
84
85	/* Computes fpm(x) for extended math functions. */
86	double lj_vm_foldfpm(double x, int fpm)	9✔
87	{
88	switch (fpm) {	9✔
89	case IRFPM_FLOOR: return lj_vm_floor(x);	4✔
90	case IRFPM_CEIL: return lj_vm_ceil(x);	3✔
91	case IRFPM_TRUNC: return lj_vm_trunc(x);	×
92	case IRFPM_SQRT: return sqrt(x);	1✔
93	case IRFPM_LOG: return log(x);	1✔
94	case IRFPM_LOG2: return lj_vm_log2(x);	×
95	default: lj_assertX(0, "bad fpm %d", fpm);
96	}
97	return 0;
98	}
99
100	#if LJ_HASFFI
UNCOV 101	int lj_vm_errno(void)	×
102	{
UNCOV 103	return errno;	×
104	}
105	#endif
106
107	#endif

tarantool / luajit / 11373217526

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