One Level Up Top Level

src/lj_vmmath.c - luajit-2.0-src

Functions defined

Macros defined

Source code

  1. /*
  2. ** Math helper functions for assembler VM.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. ‌#define lj_vmmath_c
  7. ‌#define LUA_CORE

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

  12. #include "lj_obj.h"
  13. #include "lj_ir.h"
  14. #include "lj_vm.h"

  16. /* -- Wrapper functions --------------------------------------------------- */

  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

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

  39. ‌double lj_vm_foldarith(double x, double y, int op)
  40. {
  41.   switch (op) {
  42.   case IR_ADD - IR_ADD: return x+y; break;
  43.   case IR_SUB - IR_ADD: return x-y; break;
  44.   case IR_MUL - IR_ADD: return x*y; break;
  45.   case IR_DIV - IR_ADD: return x/y; break;
  46.   case IR_MOD - IR_ADD: return x-lj_vm_floor(x/y)*y; break;
  47.   case IR_POW - IR_ADD: return pow(x, y); break;
  48.   case IR_NEG - IR_ADD: return -x; break;
  49.   case IR_ABS - IR_ADD: return fabs(x); break;
  50. #if LJ_HASJIT
  51.   case IR_ATAN2 - IR_ADD: return atan2(x, y); break;
  52.   case IR_LDEXP - IR_ADD: return ldexp(x, (int)y); break;
  53.   case IR_MIN - IR_ADD: return x > y ? y : x; break;
  54.   case IR_MAX - IR_ADD: return x < y ? y : x; break;
  55. #endif
  56.   default: return x;
  57.   }
  58. }

  60. #if LJ_HASJIT

  62. #ifdef LUAJIT_NO_LOG2
  63. ‌double lj_vm_log2(double a)
  64. {
  65.   return log(a) * 1.4426950408889634074;
  66. }
  67. #endif

  69. #ifdef LUAJIT_NO_EXP2
  70. ‌double lj_vm_exp2(double a)
  71. {
  72.   return exp(a * 0.6931471805599453);
  73. }
  74. #endif

  76. #if !(LJ_TARGET_ARM || LJ_TARGET_ARM64 || LJ_TARGET_PPC)
  77. ‌int32_t LJ_FASTCALL lj_vm_modi(int32_t a, int32_t b)
  78. {
  79.   uint32_t y, ua, ub;
  80.   lua_assert(b != 0);  /* This must be checked before using this function. */
  81.   ua = a < 0 ? (uint32_t)-a : (uint32_t)a;
  82.   ub = b < 0 ? (uint32_t)-b : (uint32_t)b;
  83.   y = ua % ub;
  84.   if (y != 0 && (a^b) < 0) y = y - ub;
  85.   if (((int32_t)y^b) < 0) y = (uint32_t)-(int32_t)y;
  86.   return (int32_t)y;
  87. }
  88. #endif

  90. #if !LJ_TARGET_X86ORX64
  91. /* Unsigned x^k. */
  92. ‌static double lj_vm_powui(double x, uint32_t k)
  93. {
  94.   double y;
  95.   lua_assert(k != 0);
  96.   for (; (k & 1) == 0; k >>= 1) x *= x;
  97.   y = x;
  98.   if ((k >>= 1) != 0) {
  99.     for (;;) {
  100.       x *= x;
  101.       if (k == 1) break;
  102.       if (k & 1) y *= x;
  103.       k >>= 1;
  104.     }
  105.     y *= x;
  106.   }
  107.   return y;
  108. }

  110. /* Signed x^k. */
  111. ‌double lj_vm_powi(double x, int32_t k)
  112. {
  113.   if (k > 1)
  114.     return lj_vm_powui(x, (uint32_t)k);
  115.   else if (k == 1)
  116.     return x;
  117.   else if (k == 0)
  118.     return 1.0;
  119.   else
  120.     return 1.0 / lj_vm_powui(x, (uint32_t)-k);
  121. }
  122. #endif

  124. /* Computes fpm(x) for extended math functions. */
  125. ‌double lj_vm_foldfpm(double x, int fpm)
  126. {
  127.   switch (fpm) {
  128.   case IRFPM_FLOOR: return lj_vm_floor(x);
  129.   case IRFPM_CEIL: return lj_vm_ceil(x);
  130.   case IRFPM_TRUNC: return lj_vm_trunc(x);
  131.   case IRFPM_SQRT: return sqrt(x);
  132.   case IRFPM_EXP: return exp(x);
  133.   case IRFPM_EXP2: return lj_vm_exp2(x);
  134.   case IRFPM_LOG: return log(x);
  135.   case IRFPM_LOG2: return lj_vm_log2(x);
  136.   case IRFPM_LOG10: return log10(x);
  137.   case IRFPM_SIN: return sin(x);
  138.   case IRFPM_COS: return cos(x);
  139.   case IRFPM_TAN: return tan(x);
  140.   default: lua_assert(0);
  141.   }
  142.   return 0;
  143. }

  145. #if LJ_HASFFI
  146. ‌int lj_vm_errno(void)
  147. {
  148.   return errno;
  149. }
  150. #endif

  152. #endif

One Level Up Top Level