9791213758

Committed 04 Jul 2024 08:40AM UTC coverage: 92.804% (+0.1%) from 92.705%

Build # 9791213758

Build Type

push

github

Committed by

Buristan

Commit Message

Avoid negation of signed integers in C that may hold INT*_MIN.

Reported by minoki.
Recent C compilers 'take advantage' of the undefined behavior.
This completely changes the meaning of expressions like (k == -k).

(cherry picked from commit 8a5e398c5)

This patch changes all possibly dangerous -x operations on integers to
the corresponding two's complement. Also, it removes all related UBSAN
suppressions, since they are fixed.

Also, this patch limits the `bit.tohex()` result by 254 characters.

There is no testcase for `strscan_oct()`, `strscan_dec()` or/and
`STRSCAN_U32` format since first the unary minus is parsed first and
only after the number itself is parsed during parsing C syntax. So the
error is raised in `cp_expr_prefix()` instead. For parsing the exponent
header, there is no testcase, since the power is limited by
`STRSCAN_MAXEXP`.

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

Part of tarantool/tarantool#9924
Relates to tarantool/tarantool#8473

Run Details

5677 of 6025 branches covered (94.22%)

Branch coverage included in aggregate %.

24 of 31 new or added lines in 10 files covered. (77.42%)

22 existing lines in 4 files now uncovered.

21662 of 23434 relevant lines covered (92.44%)

2950217.74 hits per line

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

96.25

/src/lj_carith.c

/*
** C data arithmetic.
** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
*/

#include "lj_obj.h"

#if LJ_HASFFI

#include "lj_gc.h"
#include "lj_err.h"
#include "lj_tab.h"
#include "lj_meta.h"
#include "lj_ir.h"
#include "lj_ctype.h"
#include "lj_cconv.h"
#include "lj_cdata.h"
#include "lj_carith.h"
#include "lj_strscan.h"

/* -- C data arithmetic --------------------------------------------------- */

/* Binary operands of an operator converted to ctypes. */
typedef struct CDArith {
  uint8_t *p[2];
  CType *ct[2];
} CDArith;

/* Check arguments for arithmetic metamethods. */
static int carith_checkarg(lua_State *L, CTState *cts, CDArith *ca)
{
  TValue *o = L->base;
  int ok = 1;
  MSize i;
  if (o+1 >= L->top)
    lj_err_argt(L, 1, LUA_TCDATA);
  for (i = 0; i < 2; i++, o++) {
    if (tviscdata(o)) {
      GCcdata *cd = cdataV(o);
      CTypeID id = (CTypeID)cd->ctypeid;
      CType *ct = ctype_raw(cts, id);
      uint8_t *p = (uint8_t *)cdataptr(cd);
      if (ctype_isptr(ct->info)) {
        p = (uint8_t *)cdata_getptr(p, ct->size);
        if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);
      } else if (ctype_isfunc(ct->info)) {
        CTypeID id0 = i ? ctype_typeid(cts, ca->ct[0]) : 0;
        p = (uint8_t *)*(void **)p;
        ct = ctype_get(cts,
          lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|id), CTSIZE_PTR));
        if (i) {  /* cts->tab may have been reallocated. */
          ca->ct[0] = ctype_get(cts, id0);
        }
      }
      if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
      ca->ct[i] = ct;
      ca->p[i] = p;
    } else if (tvisint(o)) {
      ca->ct[i] = ctype_get(cts, CTID_INT32);
      ca->p[i] = (uint8_t *)&o->i;
    } else if (tvisnum(o)) {
      ca->ct[i] = ctype_get(cts, CTID_DOUBLE);
      ca->p[i] = (uint8_t *)&o->n;
    } else if (tvisnil(o)) {
      ca->ct[i] = ctype_get(cts, CTID_P_VOID);
      ca->p[i] = (uint8_t *)0;
    } else if (tvisstr(o)) {
      TValue *o2 = i == 0 ? o+1 : o-1;
      CType *ct = ctype_raw(cts, cdataV(o2)->ctypeid);
      ca->ct[i] = NULL;
      ca->p[i] = (uint8_t *)strVdata(o);
      ok = 0;
      if (ctype_isenum(ct->info)) {
        CTSize ofs;
        CType *cct = lj_ctype_getfield(cts, ct, strV(o), &ofs);
        if (cct && ctype_isconstval(cct->info)) {
          ca->ct[i] = ctype_child(cts, cct);
          ca->p[i] = (uint8_t *)&cct->size;  /* Assumes ct does not grow. */
          ok = 1;
        } else {
          ca->ct[1-i] = ct;  /* Use enum to improve error message. */
          ca->p[1-i] = NULL;
          break;
        }
      }
    } else {
      ca->ct[i] = NULL;
      ca->p[i] = (void *)(intptr_t)1;  /* To make it unequal. */
      ok = 0;
    }
  }
  return ok;
}

/* Pointer arithmetic. */
static int carith_ptr(lua_State *L, CTState *cts, CDArith *ca, MMS mm)
{
  CType *ctp = ca->ct[0];
  uint8_t *pp = ca->p[0];
  ptrdiff_t idx;
  CTSize sz;
  CTypeID id;
  GCcdata *cd;
  if (ctype_isptr(ctp->info) || ctype_isrefarray(ctp->info)) {
    if ((mm == MM_sub || mm == MM_eq || mm == MM_lt || mm == MM_le) &&
        (ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
      uint8_t *pp2 = ca->p[1];
      if (mm == MM_eq) {  /* Pointer equality. Incompatible pointers are ok. */
        setboolV(L->top-1, (pp == pp2));
        return 1;
      }
      if (!lj_cconv_compatptr(cts, ctp, ca->ct[1], CCF_IGNQUAL))
        return 0;
      if (mm == MM_sub) {  /* Pointer difference. */
        intptr_t diff;
        sz = lj_ctype_size(cts, ctype_cid(ctp->info));  /* Element size. */
        if (sz == 0 || sz == CTSIZE_INVALID)
          return 0;
        diff = ((intptr_t)pp - (intptr_t)pp2) / (int32_t)sz;
        /* All valid pointer differences on x64 are in (-2^47, +2^47),
        ** which fits into a double without loss of precision.
        */
        setintptrV(L->top-1, (int32_t)diff);
        return 1;
      } else if (mm == MM_lt) {  /* Pointer comparison (unsigned). */
        setboolV(L->top-1, ((uintptr_t)pp < (uintptr_t)pp2));
        return 1;
      } else {
        lj_assertL(mm == MM_le, "bad metamethod %d", mm);
        setboolV(L->top-1, ((uintptr_t)pp <= (uintptr_t)pp2));
        return 1;
      }
    }
    if (!((mm == MM_add || mm == MM_sub) && ctype_isnum(ca->ct[1]->info)))
      return 0;
    lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[1],
                   (uint8_t *)&idx, ca->p[1], 0);
    if (mm == MM_sub) idx = -idx;
  } else if (mm == MM_add && ctype_isnum(ctp->info) &&
      (ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
    /* Swap pointer and index. */
    ctp = ca->ct[1]; pp = ca->p[1];
    lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[0],
                   (uint8_t *)&idx, ca->p[0], 0);
  } else {
    return 0;
  }
  sz = lj_ctype_size(cts, ctype_cid(ctp->info));  /* Element size. */
  if (sz == CTSIZE_INVALID)
    return 0;
  pp += idx*(int32_t)sz;  /* Compute pointer + index. */
  id = lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|ctype_cid(ctp->info)),
                       CTSIZE_PTR);
  cd = lj_cdata_new(cts, id, CTSIZE_PTR);
  *(uint8_t **)cdataptr(cd) = pp;
  setcdataV(L, L->top-1, cd);
  lj_gc_check(L);
  return 1;
}

/* 64 bit integer arithmetic. */
static int carith_int64(lua_State *L, CTState *cts, CDArith *ca, MMS mm)
{
  if (ctype_isnum(ca->ct[0]->info) && ca->ct[0]->size <= 8 &&
      ctype_isnum(ca->ct[1]->info) && ca->ct[1]->size <= 8) {
    CTypeID id = (((ca->ct[0]->info & CTF_UNSIGNED) && ca->ct[0]->size == 8) ||
                  ((ca->ct[1]->info & CTF_UNSIGNED) && ca->ct[1]->size == 8)) ?
                 CTID_UINT64 : CTID_INT64;
    CType *ct = ctype_get(cts, id);
    GCcdata *cd;
    uint64_t u0, u1, *up;
    lj_cconv_ct_ct(cts, ct, ca->ct[0], (uint8_t *)&u0, ca->p[0], 0);
    if (mm != MM_unm)
      lj_cconv_ct_ct(cts, ct, ca->ct[1], (uint8_t *)&u1, ca->p[1], 0);
    switch (mm) {
    case MM_eq:
      setboolV(L->top-1, (u0 == u1));
      return 1;
    case MM_lt:
      setboolV(L->top-1,
               id == CTID_INT64 ? ((int64_t)u0 < (int64_t)u1) : (u0 < u1));
      return 1;
    case MM_le:
      setboolV(L->top-1,
               id == CTID_INT64 ? ((int64_t)u0 <= (int64_t)u1) : (u0 <= u1));
      return 1;
    default: break;
    }
    cd = lj_cdata_new(cts, id, 8);
    up = (uint64_t *)cdataptr(cd);
    setcdataV(L, L->top-1, cd);
    switch (mm) {
    case MM_add: *up = u0 + u1; break;
    case MM_sub: *up = u0 - u1; break;
    case MM_mul: *up = u0 * u1; break;
    case MM_div:
      if (id == CTID_INT64)
        *up = (uint64_t)lj_carith_divi64((int64_t)u0, (int64_t)u1);
      else
        *up = lj_carith_divu64(u0, u1);
      break;
    case MM_mod:
      if (id == CTID_INT64)
        *up = (uint64_t)lj_carith_modi64((int64_t)u0, (int64_t)u1);
      else
        *up = lj_carith_modu64(u0, u1);
      break;
    case MM_pow:
      if (id == CTID_INT64)
        *up = (uint64_t)lj_carith_powi64((int64_t)u0, (int64_t)u1);
      else
        *up = lj_carith_powu64(u0, u1);
      break;
    case MM_unm: *up = ~u0+1u; break;
    default:
      lj_assertL(0, "bad metamethod %d", mm);
      break;
    }
    lj_gc_check(L);
    return 1;
  }
  return 0;
}

/* Handle ctype arithmetic metamethods. */
static int lj_carith_meta(lua_State *L, CTState *cts, CDArith *ca, MMS mm)
{
  cTValue *tv = NULL;
  if (tviscdata(L->base)) {
    CTypeID id = cdataV(L->base)->ctypeid;
    CType *ct = ctype_raw(cts, id);
    if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
    tv = lj_ctype_meta(cts, id, mm);
  }
  if (!tv && L->base+1 < L->top && tviscdata(L->base+1)) {
    CTypeID id = cdataV(L->base+1)->ctypeid;
    CType *ct = ctype_raw(cts, id);
    if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
    tv = lj_ctype_meta(cts, id, mm);
  }
  if (!tv) {
    const char *repr[2];
    int i, isenum = -1, isstr = -1;
    if (mm == MM_eq) {  /* Equality checks never raise an error. */
      int eq = ca->p[0] == ca->p[1];
      setboolV(L->top-1, eq);
      setboolV(&G(L)->tmptv2, eq);  /* Remember for trace recorder. */
      return 1;
    }
    for (i = 0; i < 2; i++) {
      if (ca->ct[i] && tviscdata(L->base+i)) {
        if (ctype_isenum(ca->ct[i]->info)) isenum = i;
        repr[i] = strdata(lj_ctype_repr(L, ctype_typeid(cts, ca->ct[i]), NULL));
      } else {
        if (tvisstr(&L->base[i])) isstr = i;
        repr[i] = lj_typename(&L->base[i]);
      }
    }
    if ((isenum ^ isstr) == 1)
      lj_err_callerv(L, LJ_ERR_FFI_BADCONV, repr[isstr], repr[isenum]);
    lj_err_callerv(L, mm == MM_len ? LJ_ERR_FFI_BADLEN :
                      mm == MM_concat ? LJ_ERR_FFI_BADCONCAT :
                      mm < MM_add ? LJ_ERR_FFI_BADCOMP : LJ_ERR_FFI_BADARITH,
                   repr[0], repr[1]);
  }
  return lj_meta_tailcall(L, tv);
}

/* Arithmetic operators for cdata. */
int lj_carith_op(lua_State *L, MMS mm)
{
  CTState *cts = ctype_cts(L);
  CDArith ca;
  if (carith_checkarg(L, cts, &ca) && mm != MM_len && mm != MM_concat) {
    if (carith_int64(L, cts, &ca, mm) || carith_ptr(L, cts, &ca, mm)) {
      copyTV(L, &G(L)->tmptv2, L->top-1);  /* Remember for trace recorder. */
      return 1;
    }
  }
  return lj_carith_meta(L, cts, &ca, mm);
}

/* -- 64 bit bit operations helpers --------------------------------------- */

#if LJ_64
#define B64DEF(name) \
  static LJ_AINLINE uint64_t lj_carith_##name(uint64_t x, int32_t sh)
#else
/* Not inlined on 32 bit archs, since some of these are quite lengthy. */
#define B64DEF(name) \
  uint64_t LJ_NOINLINE lj_carith_##name(uint64_t x, int32_t sh)
#endif

B64DEF(shl64) { return x << (sh&63); }
B64DEF(shr64) { return x >> (sh&63); }
B64DEF(sar64) { return (uint64_t)((int64_t)x >> (sh&63)); }
B64DEF(rol64) { return lj_rol(x, (sh&63)); }
B64DEF(ror64) { return lj_ror(x, (sh&63)); }

#undef B64DEF

uint64_t lj_carith_shift64(uint64_t x, int32_t sh, int op)
{
  switch (op) {
  case IR_BSHL-IR_BSHL: x = lj_carith_shl64(x, sh); break;
  case IR_BSHR-IR_BSHL: x = lj_carith_shr64(x, sh); break;
  case IR_BSAR-IR_BSHL: x = lj_carith_sar64(x, sh); break;
  case IR_BROL-IR_BSHL: x = lj_carith_rol64(x, sh); break;
  case IR_BROR-IR_BSHL: x = lj_carith_ror64(x, sh); break;
  default:
    lj_assertX(0, "bad shift op %d", op);
    break;
  }
  return x;
}

/* Equivalent to lj_lib_checkbit(), but handles cdata. */
uint64_t lj_carith_check64(lua_State *L, int narg, CTypeID *id)
{
  TValue *o = L->base + narg-1;
  if (o >= L->top) {
  err:
    lj_err_argt(L, narg, LUA_TNUMBER);
  } else if (LJ_LIKELY(tvisnumber(o))) {
    /* Handled below. */
  } else if (tviscdata(o)) {
    CTState *cts = ctype_cts(L);
    uint8_t *sp = (uint8_t *)cdataptr(cdataV(o));
    CTypeID sid = cdataV(o)->ctypeid;
    CType *s = ctype_get(cts, sid);
    uint64_t x;
    if (ctype_isref(s->info)) {
      sp = *(void **)sp;
      sid = ctype_cid(s->info);
    }
    s = ctype_raw(cts, sid);
    if (ctype_isenum(s->info)) s = ctype_child(cts, s);
    if ((s->info & (CTMASK_NUM|CTF_BOOL|CTF_FP|CTF_UNSIGNED)) ==
        CTINFO(CT_NUM, CTF_UNSIGNED) && s->size == 8)
      *id = CTID_UINT64;  /* Use uint64_t, since it has the highest rank. */
    else if (!*id)
      *id = CTID_INT64;  /* Use int64_t, unless already set. */
    lj_cconv_ct_ct(cts, ctype_get(cts, *id), s,
                   (uint8_t *)&x, sp, CCF_ARG(narg));
    return x;
  } else if (!(tvisstr(o) && lj_strscan_number(strV(o), o))) {
    goto err;
  }
  if (LJ_LIKELY(tvisint(o))) {
    return (uint32_t)intV(o);
  } else {
    int32_t i = lj_num2bit(numV(o));
    if (LJ_DUALNUM) setintV(o, i);
    return (uint32_t)i;
  }
}

/* -- 64 bit integer arithmetic helpers ----------------------------------- */

#if LJ_32 && LJ_HASJIT
/* Signed/unsigned 64 bit multiplication. */
int64_t lj_carith_mul64(int64_t a, int64_t b)
{
  return a * b;
}
#endif

/* Unsigned 64 bit division. */
uint64_t lj_carith_divu64(uint64_t a, uint64_t b)
{
  if (b == 0) return U64x(80000000,00000000);
  return a / b;
}

/* Signed 64 bit division. */
int64_t lj_carith_divi64(int64_t a, int64_t b)
{
  if (b == 0 || (a == (int64_t)U64x(80000000,00000000) && b == -1))
    return U64x(80000000,00000000);
  return a / b;
}

/* Unsigned 64 bit modulo. */
uint64_t lj_carith_modu64(uint64_t a, uint64_t b)
{
  if (b == 0) return U64x(80000000,00000000);
  return a % b;
}

/* Signed 64 bit modulo. */
int64_t lj_carith_modi64(int64_t a, int64_t b)
{
  if (b == 0) return U64x(80000000,00000000);
  if (a == (int64_t)U64x(80000000,00000000) && b == -1) return 0;
  return a % b;
}

/* Unsigned 64 bit x^k. */
uint64_t lj_carith_powu64(uint64_t x, uint64_t k)
{
  uint64_t y;
  if (k == 0)
    return 1;
  for (; (k & 1) == 0; k >>= 1) x *= x;
  y = x;
  if ((k >>= 1) != 0) {
    for (;;) {
      x *= x;
      if (k == 1) break;
      if (k & 1) y *= x;
      k >>= 1;
    }
    y *= x;
  }
  return y;
}

/* Signed 64 bit x^k. */
int64_t lj_carith_powi64(int64_t x, int64_t k)
{
  if (k == 0)
    return 1;
  if (k < 0) {
    if (x == 0)
      return U64x(7fffffff,ffffffff);
    else if (x == 1)
      return 1;
    else if (x == -1)
      return (k & 1) ? -1 : 1;
    else
      return 0;
  }
  return (int64_t)lj_carith_powu64((uint64_t)x, (uint64_t)k);
}

#endif

1	/*
2	** C data arithmetic.
3	** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
4	*/
5
6	#include "lj_obj.h"
7
8	#if LJ_HASFFI
9
10	#include "lj_gc.h"
11	#include "lj_err.h"
12	#include "lj_tab.h"
13	#include "lj_meta.h"
14	#include "lj_ir.h"
15	#include "lj_ctype.h"
16	#include "lj_cconv.h"
17	#include "lj_cdata.h"
18	#include "lj_carith.h"
19	#include "lj_strscan.h"
20
21	/* -- C data arithmetic --------------------------------------------------- */
22
23	/* Binary operands of an operator converted to ctypes. */
24	typedef struct CDArith {
25	uint8_t *p[2];
26	CType *ct[2];
27	} CDArith;
28
29	/* Check arguments for arithmetic metamethods. */
30	static int carith_checkarg(lua_State L, CTState cts, CDArith *ca)	1,915,041✔
31	{
32	TValue *o = L->base;	1,915,041✔
33	int ok = 1;	1,915,041✔
34	MSize i;	1,915,041✔
35	if (o+1 >= L->top)	1,915,041✔
36	lj_err_argt(L, 1, LUA_TCDATA);	×
37	for (i = 0; i < 2; i++, o++) {	5,745,120✔
38	if (tviscdata(o)) {	3,830,081✔
39	GCcdata *cd = cdataV(o);	2,408,219✔
40	CTypeID id = (CTypeID)cd->ctypeid;	2,408,219✔
41	CType *ct = ctype_raw(cts, id);	2,408,219✔
42	uint8_t p = (uint8_t )cdataptr(cd);	2,408,219✔
43	if (ctype_isptr(ct->info)) {	2,408,219✔
44	p = (uint8_t *)cdata_getptr(p, ct->size);	1,410✔
45	if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);	1,422✔
46	} else if (ctype_isfunc(ct->info)) {	2,406,809✔
47	CTypeID id0 = i ? ctype_typeid(cts, ca->ct[0]) : 0;	15✔
48	p = (uint8_t )(void **)p;	15✔
49	ct = ctype_get(cts,	15✔
50	lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR\|id), CTSIZE_PTR));	15✔
51	if (i) { /* cts->tab may have been reallocated. */	15✔
52	ca->ct[0] = ctype_get(cts, id0);	9✔
53	}
54	}
55	if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);	2,408,219✔
56	ca->ct[i] = ct;	2,408,219✔
57	ca->p[i] = p;	2,408,219✔
58	} else if (tvisint(o)) {	1,421,862✔
59	ca->ct[i] = ctype_get(cts, CTID_INT32);
60	ca->p[i] = (uint8_t *)&o->i;
61	} else if (tvisnum(o)) {	1,421,862✔
62	ca->ct[i] = ctype_get(cts, CTID_DOUBLE);	1,421,079✔
63	ca->p[i] = (uint8_t *)&o->n;	1,421,079✔
64	} else if (tvisnil(o)) {	783✔
65	ca->ct[i] = ctype_get(cts, CTID_P_VOID);	149✔
66	ca->p[i] = (uint8_t *)0;	149✔
67	} else if (tvisstr(o)) {	634✔
68	TValue *o2 = i == 0 ? o+1 : o-1;	576✔
69	CType *ct = ctype_raw(cts, cdataV(o2)->ctypeid);	576✔
70	ca->ct[i] = NULL;	576✔
71	ca->p[i] = (uint8_t *)strVdata(o);	576✔
72	ok = 0;	576✔
73	if (ctype_isenum(ct->info)) {	576✔
74	CTSize ofs;	363✔
75	CType *cct = lj_ctype_getfield(cts, ct, strV(o), &ofs);	363✔
76	if (cct && ctype_isconstval(cct->info)) {	363✔
77	ca->ct[i] = ctype_child(cts, cct);	361✔
78	ca->p[i] = (uint8_t )&cct->size; / Assumes ct does not grow. */	361✔
79	ok = 1;	361✔
80	} else {
81	ca->ct[1-i] = ct; /* Use enum to improve error message. */	2✔
82	ca->p[1-i] = NULL;	2✔
83	break;	2✔
84	}
85	}
86	} else {
87	ca->ct[i] = NULL;	58✔
88	ca->p[i] = (void )(intptr_t)1; / To make it unequal. */	58✔
89	ok = 0;	58✔
90	}
91	}
92	return ok;	1,915,041✔
93	}
94
95	/* Pointer arithmetic. */
96	static int carith_ptr(lua_State L, CTState cts, CDArith *ca, MMS mm)	48,450✔
97	{
98	CType *ctp = ca->ct[0];	48,450✔
99	uint8_t *pp = ca->p[0];	48,450✔
100	ptrdiff_t idx;	48,450✔
101	CTSize sz;	48,450✔
102	CTypeID id;	48,450✔
103	GCcdata *cd;	48,450✔
104	if (ctype_isptr(ctp->info) \|\| ctype_isrefarray(ctp->info)) {	48,450✔
105	if ((mm == MM_sub \|\| mm == MM_eq \|\| mm == MM_lt \|\| mm == MM_le) &&	48,293✔
106	(ctype_isptr(ca->ct[1]->info) \|\| ctype_isrefarray(ca->ct[1]->info))) {	673✔
107	uint8_t *pp2 = ca->p[1];	502✔
108	if (mm == MM_eq) { /* Pointer equality. Incompatible pointers are ok. */	502✔
109	setboolV(L->top-1, (pp == pp2));	97✔
110	return 1;	97✔
111	}
112	if (!lj_cconv_compatptr(cts, ctp, ca->ct[1], CCF_IGNQUAL))	405✔
113	return 0;
114	if (mm == MM_sub) { /* Pointer difference. */	404✔
115	intptr_t diff;	121✔
116	sz = lj_ctype_size(cts, ctype_cid(ctp->info)); /* Element size. */	121✔
117	if (sz == 0 \|\| sz == CTSIZE_INVALID)	121✔
118	return 0;
119	diff = ((intptr_t)pp - (intptr_t)pp2) / (int32_t)sz;	121✔
120	/* All valid pointer differences on x64 are in (-2^47, +2^47),
121	** which fits into a double without loss of precision.
122	*/
123	setintptrV(L->top-1, (int32_t)diff);	121✔
124	return 1;	121✔
125	} else if (mm == MM_lt) { /* Pointer comparison (unsigned). */	283✔
126	setboolV(L->top-1, ((uintptr_t)pp < (uintptr_t)pp2));	77✔
127	return 1;	77✔
128	} else {
129	lj_assertL(mm == MM_le, "bad metamethod %d", mm);	206✔
130	setboolV(L->top-1, ((uintptr_t)pp <= (uintptr_t)pp2));	206✔
131	return 1;	206✔
132	}
133	}
134	if (!((mm == MM_add \|\| mm == MM_sub) && ctype_isnum(ca->ct[1]->info)))	47,791✔
135	return 0;
136	lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[1],	47,789✔
137	(uint8_t *)&idx, ca->p[1], 0);
138	if (mm == MM_sub) idx = -idx;	47,789✔
139	} else if (mm == MM_add && ctype_isnum(ctp->info) &&	157✔
140	(ctype_isptr(ca->ct[1]->info) \|\| ctype_isrefarray(ca->ct[1]->info))) {	48✔
141	/* Swap pointer and index. */
142	ctp = ca->ct[1]; pp = ca->p[1];	48✔
143	lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[0],	48✔
144	(uint8_t *)&idx, ca->p[0], 0);
145	} else {
146	return 0;
147	}
148	sz = lj_ctype_size(cts, ctype_cid(ctp->info)); /* Element size. */	47,837✔
149	if (sz == CTSIZE_INVALID)	47,837✔
150	return 0;
151	pp += idx(int32_t)sz; / Compute pointer + index. */	47,835✔
152	id = lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR\|ctype_cid(ctp->info)),	47,835✔
153	CTSIZE_PTR);
154	cd = lj_cdata_new(cts, id, CTSIZE_PTR);	47,835✔
155	(uint8_t *)cdataptr(cd) = pp;	47,835✔
156	setcdataV(L, L->top-1, cd);	47,835✔
157	lj_gc_check(L);	47,835✔
158	return 1;
159	}
160
161	/* 64 bit integer arithmetic. */
162	static int carith_int64(lua_State L, CTState cts, CDArith *ca, MMS mm)	1,914,707✔
163	{
164	if (ctype_isnum(ca->ct[0]->info) && ca->ct[0]->size <= 8 &&	1,914,707✔
165	ctype_isnum(ca->ct[1]->info) && ca->ct[1]->size <= 8) {	1,866,365✔
166	CTypeID id = (((ca->ct[0]->info & CTF_UNSIGNED) && ca->ct[0]->size == 8) \|\|	4,329,221✔
167	((ca->ct[1]->info & CTF_UNSIGNED) && ca->ct[1]->size == 8)) ?	596,707✔
168	CTID_UINT64 : CTID_INT64;	1,866,257✔
169	CType *ct = ctype_get(cts, id);	1,866,257✔
170	GCcdata *cd;	1,866,257✔
171	uint64_t u0, u1, *up;	1,866,257✔
172	lj_cconv_ct_ct(cts, ct, ca->ct[0], (uint8_t *)&u0, ca->p[0], 0);	1,866,257✔
173	if (mm != MM_unm)	1,866,257✔
174	lj_cconv_ct_ct(cts, ct, ca->ct[1], (uint8_t *)&u1, ca->p[1], 0);	1,866,140✔
175	switch (mm) {	1,866,257✔
176	case MM_eq:	103,928✔
177	setboolV(L->top-1, (u0 == u1));	103,928✔
178	return 1;	103,928✔
179	case MM_lt:	40,266✔
180	setboolV(L->top-1,	40,266✔
181	id == CTID_INT64 ? ((int64_t)u0 < (int64_t)u1) : (u0 < u1));
182	return 1;	40,266✔
183	case MM_le:	509,956✔
184	setboolV(L->top-1,	509,956✔
185	id == CTID_INT64 ? ((int64_t)u0 <= (int64_t)u1) : (u0 <= u1));
186	return 1;	509,956✔
187	default: break;	1,212,107✔
188	}
189	cd = lj_cdata_new(cts, id, 8);	1,212,107✔
190	up = (uint64_t *)cdataptr(cd);	1,212,107✔
191	setcdataV(L, L->top-1, cd);	1,212,107✔
192	switch (mm) {	1,212,107✔
193	case MM_add: *up = u0 + u1; break;	371,583✔
194	case MM_sub: *up = u0 - u1; break;	470,207✔
195	case MM_mul: up = u0 u1; break;	369,729✔
196	case MM_div:	229✔
197	if (id == CTID_INT64)	229✔
198	*up = (uint64_t)lj_carith_divi64((int64_t)u0, (int64_t)u1);	169✔
199	else
200	*up = lj_carith_divu64(u0, u1);	60✔
201	break;
202	case MM_mod:	117✔
203	if (id == CTID_INT64)	117✔
204	*up = (uint64_t)lj_carith_modi64((int64_t)u0, (int64_t)u1);	59✔
205	else
206	*up = lj_carith_modu64(u0, u1);	58✔
207	break;
208	case MM_pow:	125✔
209	if (id == CTID_INT64)	125✔
210	*up = (uint64_t)lj_carith_powi64((int64_t)u0, (int64_t)u1);	99✔
211	else
212	*up = lj_carith_powu64(u0, u1);	26✔
213	break;
214	case MM_unm: *up = ~u0+1u; break;	117✔
215	default:
216	lj_assertL(0, "bad metamethod %d", mm);
217	break;
218	}
219	lj_gc_check(L);	1,212,107✔
220	return 1;	1,212,107✔
221	}
222	return 0;
223	}
224
225	/* Handle ctype arithmetic metamethods. */
226	static int lj_carith_meta(lua_State L, CTState cts, CDArith *ca, MMS mm)	448✔
227	{
228	cTValue *tv = NULL;	448✔
229	if (tviscdata(L->base)) {	448✔
230	CTypeID id = cdataV(L->base)->ctypeid;	445✔
231	CType *ct = ctype_raw(cts, id);	445✔
232	if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);	445✔
233	tv = lj_ctype_meta(cts, id, mm);	445✔
234	}
235	if (!tv && L->base+1 < L->top && tviscdata(L->base+1)) {	448✔
236	CTypeID id = cdataV(L->base+1)->ctypeid;	7✔
237	CType *ct = ctype_raw(cts, id);	7✔
238	if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);	7✔
239	tv = lj_ctype_meta(cts, id, mm);	7✔
240	}
241	if (!tv) {	448✔
242	const char *repr[2];	337✔
243	int i, isenum = -1, isstr = -1;	337✔
244	if (mm == MM_eq) { /* Equality checks never raise an error. */	337✔
245	int eq = ca->p[0] == ca->p[1];	330✔
246	setboolV(L->top-1, eq);	330✔
247	setboolV(&G(L)->tmptv2, eq); /* Remember for trace recorder. */	330✔
248	return 1;	330✔
249	}
250	for (i = 0; i < 2; i++) {	21✔
251	if (ca->ct[i] && tviscdata(L->base+i)) {	14✔
252	if (ctype_isenum(ca->ct[i]->info)) isenum = i;	10✔
253	repr[i] = strdata(lj_ctype_repr(L, ctype_typeid(cts, ca->ct[i]), NULL));	10✔
254	} else {
255	if (tvisstr(&L->base[i])) isstr = i;	4✔
256	repr[i] = lj_typename(&L->base[i]);	4✔
257	}
258	}
259	if ((isenum ^ isstr) == 1)	7✔
260	lj_err_callerv(L, LJ_ERR_FFI_BADCONV, repr[isstr], repr[isenum]);	1✔
261	lj_err_callerv(L, mm == MM_len ? LJ_ERR_FFI_BADLEN :	11✔
262	mm == MM_concat ? LJ_ERR_FFI_BADCONCAT :
263	mm < MM_add ? LJ_ERR_FFI_BADCOMP : LJ_ERR_FFI_BADARITH,
264	repr[0], repr[1]);
265	}
266	return lj_meta_tailcall(L, tv);	111✔
267	}
268
269	/* Arithmetic operators for cdata. */
270	int lj_carith_op(lua_State *L, MMS mm)	1,915,041✔
271	{
272	CTState *cts = ctype_cts(L);	1,915,041✔
273	CDArith ca;	1,915,041✔
274	if (carith_checkarg(L, cts, &ca) && mm != MM_len && mm != MM_concat) {	1,915,041✔
275	if (carith_int64(L, cts, &ca, mm) \|\| carith_ptr(L, cts, &ca, mm)) {	1,914,707✔
276	copyTV(L, &G(L)->tmptv2, L->top-1); /* Remember for trace recorder. */	1,914,593✔
277	return 1;	1,914,593✔
278	}
279	}
280	return lj_carith_meta(L, cts, &ca, mm);	448✔
281	}
282
283	/* -- 64 bit bit operations helpers --------------------------------------- */
284
285	#if LJ_64
286	#define B64DEF(name) \
287	static LJ_AINLINE uint64_t lj_carith_##name(uint64_t x, int32_t sh)
288	#else
289	/* Not inlined on 32 bit archs, since some of these are quite lengthy. */
290	#define B64DEF(name) \
291	uint64_t LJ_NOINLINE lj_carith_##name(uint64_t x, int32_t sh)
292	#endif
293
294	B64DEF(shl64) { return x << (sh&63); }	224✔
295	B64DEF(shr64) { return x >> (sh&63); }	112✔
296	B64DEF(sar64) { return (uint64_t)((int64_t)x >> (sh&63)); }	108✔
297	B64DEF(rol64) { return lj_rol(x, (sh&63)); }	171✔
UNCOV 298	B64DEF(ror64) { return lj_ror(x, (sh&63)); }	×
299
300	#undef B64DEF
301
302	uint64_t lj_carith_shift64(uint64_t x, int32_t sh, int op)	615✔
303	{
304	switch (op) {	615✔
305	case IR_BSHL-IR_BSHL: x = lj_carith_shl64(x, sh); break;	224✔
306	case IR_BSHR-IR_BSHL: x = lj_carith_shr64(x, sh); break;	112✔
307	case IR_BSAR-IR_BSHL: x = lj_carith_sar64(x, sh); break;	108✔
308	case IR_BROL-IR_BSHL: x = lj_carith_rol64(x, sh); break;	171✔
UNCOV 309	case IR_BROR-IR_BSHL: x = lj_carith_ror64(x, sh); break;	×
310	default:
311	lj_assertX(0, "bad shift op %d", op);
312	break;
313	}
314	return x;	615✔
315	}
316
317	/* Equivalent to lj_lib_checkbit(), but handles cdata. */
318	uint64_t lj_carith_check64(lua_State L, int narg, CTypeID id)	4,106✔
319	{
320	TValue *o = L->base + narg-1;	4,106✔
321	if (o >= L->top) {	4,106✔
322	err:	12✔
323	lj_err_argt(L, narg, LUA_TNUMBER);	42✔
324	} else if (LJ_LIKELY(tvisnumber(o))) {	4,094✔
325	/* Handled below. */
326	} else if (tviscdata(o)) {	3,281✔
327	CTState *cts = ctype_cts(L);	3,251✔
328	uint8_t sp = (uint8_t )cdataptr(cdataV(o));	3,251✔
329	CTypeID sid = cdataV(o)->ctypeid;	3,251✔
330	CType *s = ctype_get(cts, sid);	3,251✔
331	uint64_t x;	3,251✔
332	if (ctype_isref(s->info)) {	3,251✔
UNCOV 333	sp = (void *)sp;	×
UNCOV 334	sid = ctype_cid(s->info);	×
335	}
336	s = ctype_raw(cts, sid);	3,251✔
337	if (ctype_isenum(s->info)) s = ctype_child(cts, s);	3,251✔
338	if ((s->info & (CTMASK_NUM\|CTF_BOOL\|CTF_FP\|CTF_UNSIGNED)) ==	3,251✔
339	CTINFO(CT_NUM, CTF_UNSIGNED) && s->size == 8)	3,251✔
340	id = CTID_UINT64; / Use uint64_t, since it has the highest rank. */	8✔
341	else if (!*id)	3,243✔
342	id = CTID_INT64; / Use int64_t, unless already set. */	2,080✔
343	lj_cconv_ct_ct(cts, ctype_get(cts, *id), s,	3,251✔
344	(uint8_t *)&x, sp, CCF_ARG(narg));	3,251✔
345	return x;	3,251✔
346	} else if (!(tvisstr(o) && lj_strscan_number(strV(o), o))) {	30✔
347	goto err;	30✔
348	}
349	if (LJ_LIKELY(tvisint(o))) {	813✔
350	return (uint32_t)intV(o);
351	} else {
352	int32_t i = lj_num2bit(numV(o));	813✔
353	if (LJ_DUALNUM) setintV(o, i);	813✔
354	return (uint32_t)i;	813✔
355	}
356	}
357
358	/* -- 64 bit integer arithmetic helpers ----------------------------------- */
359
360	#if LJ_32 && LJ_HASJIT
361	/* Signed/unsigned 64 bit multiplication. */
362	int64_t lj_carith_mul64(int64_t a, int64_t b)
363	{
364	return a * b;
365	}
366	#endif
367
368	/* Unsigned 64 bit division. */
369	uint64_t lj_carith_divu64(uint64_t a, uint64_t b)	102✔
370	{
371	if (b == 0) return U64x(80000000,00000000);	102✔
372	return a / b;	102✔
373	}
374
375	/* Signed 64 bit division. */
376	int64_t lj_carith_divi64(int64_t a, int64_t b)	301✔
377	{
378	if (b == 0 \|\| (a == (int64_t)U64x(80000000,00000000) && b == -1))	301✔
379	return U64x(80000000,00000000);
380	return a / b;	301✔
381	}
382
383	/* Unsigned 64 bit modulo. */
384	uint64_t lj_carith_modu64(uint64_t a, uint64_t b)	101✔
385	{
386	if (b == 0) return U64x(80000000,00000000);	101✔
387	return a % b;	101✔
388	}
389
390	/* Signed 64 bit modulo. */
391	int64_t lj_carith_modi64(int64_t a, int64_t b)	101✔
392	{
393	if (b == 0) return U64x(80000000,00000000);	101✔
394	if (a == (int64_t)U64x(80000000,00000000) && b == -1) return 0;	101✔
395	return a % b;	101✔
396	}
397
398	/* Unsigned 64 bit x^k. */
399	uint64_t lj_carith_powu64(uint64_t x, uint64_t k)	300✔
400	{
401	uint64_t y;	300✔
402	if (k == 0)	300✔
403	return 1;
404	for (; (k & 1) == 0; k >>= 1) x *= x;	579✔
405	y = x;	300✔
406	if ((k >>= 1) != 0) {	300✔
407	for (;;) {	642✔
408	x *= x;	423✔
409	if (k == 1) break;	423✔
410	if (k & 1) y *= x;	219✔
411	k >>= 1;	219✔
412	}
413	y *= x;	204✔
414	}
415	return y;
416	}
417
418	/* Signed 64 bit x^k. */
419	int64_t lj_carith_powi64(int64_t x, int64_t k)	200✔
420	{
421	if (k == 0)	200✔
422	return 1;
423	if (k < 0) {	200✔
424	if (x == 0)	×
425	return U64x(7fffffff,ffffffff);
UNCOV 426	else if (x == 1)	×
427	return 1;
UNCOV 428	else if (x == -1)	×
UNCOV 429	return (k & 1) ? -1 : 1;	×
430	else
431	return 0;
432	}
433	return (int64_t)lj_carith_powu64((uint64_t)x, (uint64_t)k);	200✔
434	}
435
436	#endif

tarantool / luajit / 9791213758

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