src/lj_carith.c

   1 /*
   2 ** C data arithmetic.
   3 ** Copyright (C) 2005-2023 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)
  31 {
  32   TValue *o = L->base;
  33   int ok = 1;
  34   MSize i;
  35   if (o+1 >= L->top)
  36     lj_err_argt(L, 1, LUA_TCDATA);
  37   for (i = 0; i < 2; i++, o++) {
  38     if (tviscdata(o)) {
  39       GCcdata *cd = cdataV(o);
  40       CTypeID id = (CTypeID)cd->ctypeid;
  41       CType *ct = ctype_raw(cts, id);
  42       uint8_t *p = (uint8_t *)cdataptr(cd);
  43       if (ctype_isptr(ct->info)) {
  44         p = (uint8_t *)cdata_getptr(p, ct->size);
  45         if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);
  46       } else if (ctype_isfunc(ct->info)) {
  47         CTypeID id0 = i ? ctype_typeid(cts, ca->ct[0]) : 0;
  48         p = (uint8_t *)*(void **)p;
  49         ct = ctype_get(cts,
  50           lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|id), CTSIZE_PTR));
  51         if (i) {  /* cts->tab may have been reallocated. */
  52           ca->ct[0] = ctype_get(cts, id0);
  53         }
  54       }
  55       if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
  56       ca->ct[i] = ct;
  57       ca->p[i] = p;
  58     } else if (tvisint(o)) {
  59       ca->ct[i] = ctype_get(cts, CTID_INT32);
  60       ca->p[i] = (uint8_t *)&o->i;
  61     } else if (tvisnum(o)) {
  62       ca->ct[i] = ctype_get(cts, CTID_DOUBLE);
  63       ca->p[i] = (uint8_t *)&o->n;
  64     } else if (tvisnil(o)) {
  65       ca->ct[i] = ctype_get(cts, CTID_P_VOID);
  66       ca->p[i] = (uint8_t *)0;
  67     } else if (tvisstr(o)) {
  68       TValue *o2 = i == 0 ? o+1 : o-1;
  69       CType *ct = ctype_raw(cts, cdataV(o2)->ctypeid);
  70       ca->ct[i] = NULL;
  71       ca->p[i] = (uint8_t *)strVdata(o);
  72       ok = 0;
  73       if (ctype_isenum(ct->info)) {
  74         CTSize ofs;
  75         CType *cct = lj_ctype_getfield(cts, ct, strV(o), &ofs);
  76         if (cct && ctype_isconstval(cct->info)) {
  77           ca->ct[i] = ctype_child(cts, cct);
  78           ca->p[i] = (uint8_t *)&cct->size;  /* Assumes ct does not grow. */
  79           ok = 1;
  80         } else {
  81           ca->ct[1-i] = ct;  /* Use enum to improve error message. */
  82           ca->p[1-i] = NULL;
  83           break;
  84         }
  85       }
  86     } else {
  87       ca->ct[i] = NULL;
  88       ca->p[i] = (void *)(intptr_t)1;  /* To make it unequal. */
  89       ok = 0;
  90     }
  91   }
  92   return ok;
  93 }
  94
  95 /* Pointer arithmetic. */
  96 static int carith_ptr(lua_State *L, CTState *cts, CDArith *ca, MMS mm)
  97 {
  98   CType *ctp = ca->ct[0];
  99   uint8_t *pp = ca->p[0];
 100   ptrdiff_t idx;
 101   CTSize sz;
 102   CTypeID id;
 103   GCcdata *cd;
 104   if (ctype_isptr(ctp->info) || ctype_isrefarray(ctp->info)) {
 105     if ((mm == MM_sub || mm == MM_eq || mm == MM_lt || mm == MM_le) &&
 106         (ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
 107       uint8_t *pp2 = ca->p[1];
 108       if (mm == MM_eq) {  /* Pointer equality. Incompatible pointers are ok. */
 109         setboolV(L->top-1, (pp == pp2));
 110         return 1;
 111       }
 112       if (!lj_cconv_compatptr(cts, ctp, ca->ct[1], CCF_IGNQUAL))
 113         return 0;
 114       if (mm == MM_sub) {  /* Pointer difference. */
 115         intptr_t diff;
 116         sz = lj_ctype_size(cts, ctype_cid(ctp->info));  /* Element size. */
 117         if (sz == 0 || sz == CTSIZE_INVALID)
 118           return 0;
 119         diff = ((intptr_t)pp - (intptr_t)pp2) / (int32_t)sz;
 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);
 124         return 1;
 125       } else if (mm == MM_lt) {  /* Pointer comparison (unsigned). */
 126         setboolV(L->top-1, ((uintptr_t)pp < (uintptr_t)pp2));
 127         return 1;
 128       } else {
 129         lj_assertL(mm == MM_le, "bad metamethod %d", mm);
 130         setboolV(L->top-1, ((uintptr_t)pp <= (uintptr_t)pp2));
 131         return 1;
 132       }
 133     }
 134     if (!((mm == MM_add || mm == MM_sub) && ctype_isnum(ca->ct[1]->info)))
 135       return 0;
 136     lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[1],
 137                    (uint8_t *)&idx, ca->p[1], 0);
 138     if (mm == MM_sub) idx = -idx;
 139   } else if (mm == MM_add && ctype_isnum(ctp->info) &&
 140       (ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
 141     /* Swap pointer and index. */
 142     ctp = ca->ct[1]; pp = ca->p[1];
 143     lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[0],
 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. */
 149   if (sz == CTSIZE_INVALID)
 150     return 0;
 151   pp += idx*(int32_t)sz;  /* Compute pointer + index. */
 152   id = lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|ctype_cid(ctp->info)),
 153                        CTSIZE_PTR);
 154   cd = lj_cdata_new(cts, id, CTSIZE_PTR);
 155   *(uint8_t **)cdataptr(cd) = pp;
 156   setcdataV(L, L->top-1, cd);
 157   lj_gc_check(L);
 158   return 1;
 159 }
 160
 161 /* 64 bit integer arithmetic. */
 162 static int carith_int64(lua_State *L, CTState *cts, CDArith *ca, MMS mm)
 163 {
 164   if (ctype_isnum(ca->ct[0]->info) && ca->ct[0]->size <= 8 &&
 165       ctype_isnum(ca->ct[1]->info) && ca->ct[1]->size <= 8) {
 166     CTypeID id = (((ca->ct[0]->info & CTF_UNSIGNED) && ca->ct[0]->size == 8) ||
 167                   ((ca->ct[1]->info & CTF_UNSIGNED) && ca->ct[1]->size == 8)) ?
 168                  CTID_UINT64 : CTID_INT64;
 169     CType *ct = ctype_get(cts, id);
 170     GCcdata *cd;
 171     uint64_t u0, u1, *up;
 172     lj_cconv_ct_ct(cts, ct, ca->ct[0], (uint8_t *)&u0, ca->p[0], 0);
 173     if (mm != MM_unm)
 174       lj_cconv_ct_ct(cts, ct, ca->ct[1], (uint8_t *)&u1, ca->p[1], 0);
 175     switch (mm) {
 176     case MM_eq:
 177       setboolV(L->top-1, (u0 == u1));
 178       return 1;
 179     case MM_lt:
 180       setboolV(L->top-1,
 181                id == CTID_INT64 ? ((int64_t)u0 < (int64_t)u1) : (u0 < u1));
 182       return 1;
 183     case MM_le:
 184       setboolV(L->top-1,
 185                id == CTID_INT64 ? ((int64_t)u0 <= (int64_t)u1) : (u0 <= u1));
 186       return 1;
 187     default: break;
 188     }
 189     cd = lj_cdata_new(cts, id, 8);
 190     up = (uint64_t *)cdataptr(cd);
 191     setcdataV(L, L->top-1, cd);
 192     switch (mm) {
 193     case MM_add: *up = u0 + u1; break;
 194     case MM_sub: *up = u0 - u1; break;
 195     case MM_mul: *up = u0 * u1; break;
 196     case MM_div:
 197       if (id == CTID_INT64)
 198         *up = (uint64_t)lj_carith_divi64((int64_t)u0, (int64_t)u1);
 199       else
 200         *up = lj_carith_divu64(u0, u1);
 201       break;
 202     case MM_mod:
 203       if (id == CTID_INT64)
 204         *up = (uint64_t)lj_carith_modi64((int64_t)u0, (int64_t)u1);
 205       else
 206         *up = lj_carith_modu64(u0, u1);
 207       break;
 208     case MM_pow:
 209       if (id == CTID_INT64)
 210         *up = (uint64_t)lj_carith_powi64((int64_t)u0, (int64_t)u1);
 211       else
 212         *up = lj_carith_powu64(u0, u1);
 213       break;
 214     case MM_unm: *up = ~u0+1u; break;
 215     default:
 216       lj_assertL(0, "bad metamethod %d", mm);
 217       break;
 218     }
 219     lj_gc_check(L);
 220     return 1;
 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)
 227 {
 228   cTValue *tv = NULL;
 229   if (tviscdata(L->base)) {
 230     CTypeID id = cdataV(L->base)->ctypeid;
 231     CType *ct = ctype_raw(cts, id);
 232     if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
 233     tv = lj_ctype_meta(cts, id, mm);
 234   }
 235   if (!tv && L->base+1 < L->top && tviscdata(L->base+1)) {
 236     CTypeID id = cdataV(L->base+1)->ctypeid;
 237     CType *ct = ctype_raw(cts, id);
 238     if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
 239     tv = lj_ctype_meta(cts, id, mm);
 240   }
 241   if (!tv) {
 242     const char *repr[2];
 243     int i, isenum = -1, isstr = -1;
 244     if (mm == MM_eq) {  /* Equality checks never raise an error. */
 245       int eq = ca->p[0] == ca->p[1];
 246       setboolV(L->top-1, eq);
 247       setboolV(&G(L)->tmptv2, eq);  /* Remember for trace recorder. */
 248       return 1;
 249     }
 250     for (i = 0; i < 2; i++) {
 251       if (ca->ct[i] && tviscdata(L->base+i)) {
 252         if (ctype_isenum(ca->ct[i]->info)) isenum = i;
 253         repr[i] = strdata(lj_ctype_repr(L, ctype_typeid(cts, ca->ct[i]), NULL));
 254       } else {
 255         if (tvisstr(&L->base[i])) isstr = i;
 256         repr[i] = lj_typename(&L->base[i]);
 257       }
 258     }
 259     if ((isenum ^ isstr) == 1)
 260       lj_err_callerv(L, LJ_ERR_FFI_BADCONV, repr[isstr], repr[isenum]);
 261     lj_err_callerv(L, mm == MM_len ? LJ_ERR_FFI_BADLEN :
 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);
 267 }
 268
 269 /* Arithmetic operators for cdata. */
 270 int lj_carith_op(lua_State *L, MMS mm)
 271 {
 272   CTState *cts = ctype_cts(L);
 273   CDArith ca;
 274   if (carith_checkarg(L, cts, &ca) && mm != MM_len && mm != MM_concat) {
 275     if (carith_int64(L, cts, &ca, mm) || carith_ptr(L, cts, &ca, mm)) {
 276       copyTV(L, &G(L)->tmptv2, L->top-1);  /* Remember for trace recorder. */
 277       return 1;
 278     }
 279   }
 280   return lj_carith_meta(L, cts, &ca, mm);
 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); }
 295 B64DEF(shr64) { return x >> (sh&63); }
 296 B64DEF(sar64) { return (uint64_t)((int64_t)x >> (sh&63)); }
 297 B64DEF(rol64) { return lj_rol(x, (sh&63)); }
 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)
 303 {
 304   switch (op) {
 305   case IR_BSHL-IR_BSHL: x = lj_carith_shl64(x, sh); break;
 306   case IR_BSHR-IR_BSHL: x = lj_carith_shr64(x, sh); break;
 307   case IR_BSAR-IR_BSHL: x = lj_carith_sar64(x, sh); break;
 308   case IR_BROL-IR_BSHL: x = lj_carith_rol64(x, sh); break;
 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;
 315 }
 316
 317 /* Equivalent to lj_lib_checkbit(), but handles cdata. */
 318 uint64_t lj_carith_check64(lua_State *L, int narg, CTypeID *id)
 319 {
 320   TValue *o = L->base + narg-1;
 321   if (o >= L->top) {
 322   err:
 323     lj_err_argt(L, narg, LUA_TNUMBER);
 324   } else if (LJ_LIKELY(tvisnumber(o))) {
 325     /* Handled below. */
 326   } else if (tviscdata(o)) {
 327     CTState *cts = ctype_cts(L);
 328     uint8_t *sp = (uint8_t *)cdataptr(cdataV(o));
 329     CTypeID sid = cdataV(o)->ctypeid;
 330     CType *s = ctype_get(cts, sid);
 331     uint64_t x;
 332     if (ctype_isref(s->info)) {
 333       sp = *(void **)sp;
 334       sid = ctype_cid(s->info);
 335     }
 336     s = ctype_raw(cts, sid);
 337     if (ctype_isenum(s->info)) s = ctype_child(cts, s);
 338     if ((s->info & (CTMASK_NUM|CTF_BOOL|CTF_FP|CTF_UNSIGNED)) ==
 339         CTINFO(CT_NUM, CTF_UNSIGNED) && s->size == 8)
 340       *id = CTID_UINT64;  /* Use uint64_t, since it has the highest rank. */
 341     else if (!*id)
 342       *id = CTID_INT64;  /* Use int64_t, unless already set. */
 343     lj_cconv_ct_ct(cts, ctype_get(cts, *id), s,
 344                    (uint8_t *)&x, sp, CCF_ARG(narg));
 345     return x;
 346   } else if (!(tvisstr(o) && lj_strscan_number(strV(o), o))) {
 347     goto err;
 348   }
 349   if (LJ_LIKELY(tvisint(o))) {
 350     return (uint32_t)intV(o);
 351   } else {
 352     int32_t i = lj_num2bit(numV(o));
 353     if (LJ_DUALNUM) setintV(o, i);
 354     return (uint32_t)i;
 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)
 370 {
 371   if (b == 0) return U64x(80000000,00000000);
 372   return a / b;
 373 }
 374
 375 /* Signed 64 bit division. */
 376 int64_t lj_carith_divi64(int64_t a, int64_t b)
 377 {
 378   if (b == 0 || (a == (int64_t)U64x(80000000,00000000) && b == -1))
 379     return U64x(80000000,00000000);
 380   return a / b;
 381 }
 382
 383 /* Unsigned 64 bit modulo. */
 384 uint64_t lj_carith_modu64(uint64_t a, uint64_t b)
 385 {
 386   if (b == 0) return U64x(80000000,00000000);
 387   return a % b;
 388 }
 389
 390 /* Signed 64 bit modulo. */
 391 int64_t lj_carith_modi64(int64_t a, int64_t b)
 392 {
 393   if (b == 0) return U64x(80000000,00000000);
 394   if (a == (int64_t)U64x(80000000,00000000) && b == -1) return 0;
 395   return a % b;
 396 }
 397
 398 /* Unsigned 64 bit x^k. */
 399 uint64_t lj_carith_powu64(uint64_t x, uint64_t k)
 400 {
 401   uint64_t y;
 402   if (k == 0)
 403     return 1;
 404   for (; (k & 1) == 0; k >>= 1) x *= x;
 405   y = x;
 406   if ((k >>= 1) != 0) {
 407     for (;;) {
 408       x *= x;
 409       if (k == 1) break;
 410       if (k & 1) y *= x;
 411       k >>= 1;
 412     }
 413     y *= x;
 414   }
 415   return y;
 416 }
 417
 418 /* Signed 64 bit x^k. */
 419 int64_t lj_carith_powi64(int64_t x, int64_t k)
 420 {
 421   if (k == 0)
 422     return 1;
 423   if (k < 0) {
 424     if (x == 0)
 425       return U64x(7fffffff,ffffffff);
 426     else if (x == 1)
 427       return 1;
 428     else if (x == -1)
 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);
 434 }
 435
 436 #endif