//// Dis VM// File: Mathmod.cpp// Author: arr// #include <debug.h>#include "Mathmod.h" using namespace disvm;using namespace disvm::runtime; namespace{    disvm::runtime::builtin::vm_runtab_t Mathmodtab[] = {     "FPcontrol",0x6584767b,Math_FPcontrol,40,0,{0},     "FPstatus",0x6584767b,Math_FPstatus,40,0,{0},     "acos",0xa1d1fe48,Math_acos,40,0,{0},     "acosh",0xa1d1fe48,Math_acosh,40,0,{0},     "asin",0xa1d1fe48,Math_asin,40,0,{0},     "asinh",0xa1d1fe48,Math_asinh,40,0,{0},     "atan",0xa1d1fe48,Math_atan,40,0,{0},     "atan2",0xf293f6cf,Math_atan2,48,0,{0},     "atanh",0xa1d1fe48,Math_atanh,40,0,{0},     "bits32real",0x40a58596,Math_bits32real,40,0,{0},     "bits64real",0x5463c72c,Math_bits64real,40,0,{0},     "cbrt",0xa1d1fe48,Math_cbrt,40,0,{0},     "ceil",0xa1d1fe48,Math_ceil,40,0,{0},     "copysign",0xf293f6cf,Math_copysign,48,0,{0},     "cos",0xa1d1fe48,Math_cos,40,0,{0},     "cosh",0xa1d1fe48,Math_cosh,40,0,{0},     "dot",0xfeca4db6,Math_dot,40,2,{0x0,0xc0,},     "erf",0xa1d1fe48,Math_erf,40,0,{0},     "erfc",0xa1d1fe48,Math_erfc,40,0,{0},     "exp",0xa1d1fe48,Math_exp,40,0,{0},     "expm1",0xa1d1fe48,Math_expm1,40,0,{0},     "export_int",0x3f1d94ee,Math_export_int,40,2,{0x0,0xc0,},     "export_real",0xd1fb0c8c,Math_export_real,40,2,{0x0,0xc0,},     "export_real32",0xd1fb0c8c,Math_export_real32,40,2,{0x0,0xc0,},     "fabs",0xa1d1fe48,Math_fabs,40,0,{0},     "fdim",0xf293f6cf,Math_fdim,48,0,{0},     "finite",0x7b2e5f52,Math_finite,40,0,{0},     "floor",0xa1d1fe48,Math_floor,40,0,{0},     "fmax",0xf293f6cf,Math_fmax,48,0,{0},     "fmin",0xf293f6cf,Math_fmin,48,0,{0},     "fmod",0xf293f6cf,Math_fmod,48,0,{0},     "gemm",0x53b8cd34,Math_gemm,96,3,{0x0,0x0,0xa2,},     "getFPcontrol",0x616977e8,Math_getFPcontrol,32,0,{0},     "getFPstatus",0x616977e8,Math_getFPstatus,32,0,{0},     "hypot",0xf293f6cf,Math_hypot,48,0,{0},     "iamax",0xa5fc2e4d,Math_iamax,40,2,{0x0,0x80,},     "ilogb",0x7b2e5f52,Math_ilogb,40,0,{0},     "import_int",0x3f1d94ee,Math_import_int,40,2,{0x0,0xc0,},     "import_real",0xd1fb0c8c,Math_import_real,40,2,{0x0,0xc0,},     "import_real32",0xd1fb0c8c,Math_import_real32,40,2,{0x0,0xc0,},     "isnan",0x7b2e5f52,Math_isnan,40,0,{0},     "j0",0xa1d1fe48,Math_j0,40,0,{0},     "j1",0xa1d1fe48,Math_j1,40,0,{0},     "jn",0xb61ffc5b,Math_jn,48,0,{0},     "lgamma",0x6e97c646,Math_lgamma,40,0,{0},     "log",0xa1d1fe48,Math_log,40,0,{0},     "log10",0xa1d1fe48,Math_log10,40,0,{0},     "log1p",0xa1d1fe48,Math_log1p,40,0,{0},     "modf",0x6e97c646,Math_modf,40,0,{0},     "nextafter",0xf293f6cf,Math_nextafter,48,0,{0},     "norm1",0x1629207e,Math_norm1,40,2,{0x0,0x80,},     "norm2",0x1629207e,Math_norm2,40,2,{0x0,0x80,},     "pow",0xf293f6cf,Math_pow,48,0,{0},     "pow10",0x40a58596,Math_pow10,40,0,{0},     "realbits32",0x7b2e5f52,Math_realbits32,40,0,{0},     "realbits64",0x9589d476,Math_realbits64,40,0,{0},     "remainder",0xf293f6cf,Math_remainder,48,0,{0},     "rint",0xa1d1fe48,Math_rint,40,0,{0},     "scalbn",0x64fa84ba,Math_scalbn,48,0,{0},     "sin",0xa1d1fe48,Math_sin,40,0,{0},     "sinh",0xa1d1fe48,Math_sinh,40,0,{0},     "sort",0xfc7c7b8,Math_sort,40,2,{0x0,0xc0,},     "sqrt",0xa1d1fe48,Math_sqrt,40,0,{0},     "tan",0xa1d1fe48,Math_tan,40,0,{0},     "tanh",0xa1d1fe48,Math_tanh,40,0,{0},     "y0",0xa1d1fe48,Math_y0,40,0,{0},     "y1",0xa1d1fe48,Math_y1,40,0,{0},     "yn",0xb61ffc5b,Math_yn,48,0,{0},        0    };     const word_t Mathmodlen = 68;} voidMathmodinit(void){    builtin::register_module_exports(Math_PATH, Mathmodlen, Mathmodtab);} voidMath_FPcontrol(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_FPcontrol>();     // [PAL] Properly implement floating point control    debug::log_msg(debug::component_trace_t::builtin, debug::log_level_t::warning, "FPControl is not properly implemented");     *fp.ret = fp.mask;} voidMath_FPstatus(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_FPstatus>();    throw vm_system_exception{ "Function not implemented" };} voidMath_acos(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_acos>();    *fp.ret = std::acos(fp.x);} voidMath_acosh(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_acosh>();    *fp.ret = std::acosh(fp.x);} voidMath_asin(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_asin>();    *fp.ret = std::asin(fp.x);} voidMath_asinh(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_asinh>();    *fp.ret = std::asinh(fp.x);} voidMath_atan(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_atan>();    *fp.ret = std::atan(fp.x);} voidMath_atan2(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_atan2>();    *fp.ret = std::atan2(fp.x, fp.y);} voidMath_atanh(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_atanh>();    *fp.ret = std::atanh(fp.x);} voidMath_bits32real(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_bits32real>();     auto x = fp.b;    float t;    std::memcpy(&t, &x, sizeof(x));     *fp.ret = real_t{ t };} voidMath_bits64real(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_bits64real>();     auto x = fp.b;    real_t t;    std::memcpy(&t, &x, sizeof(x));    static_assert(sizeof(t) == sizeof(x), "Real should be 64-bits");     *fp.ret = t;} voidMath_cbrt(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_cbrt>();    *fp.ret = std::cbrt(fp.x);} voidMath_ceil(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_ceil>();    *fp.ret = std::ceil(fp.x);} voidMath_copysign(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_copysign>();    *fp.ret = std::copysign(fp.x, fp.s);} voidMath_cos(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_cos>();    *fp.ret = std::cos(fp.x);} voidMath_cosh(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_cosh>();    *fp.ret = std::cosh(fp.x);} voidMath_dot(vm_registers_t &r, vm_t &vm){    // Defined as: dot(x, y) = sum(x[i] * y[i])    auto &fp = r.stack.peek_frame()->base<F_Math_dot>();     auto xs = vm_alloc_t::from_allocation<vm_array_t>(fp.x);    auto ys = vm_alloc_t::from_allocation<vm_array_t>(fp.y);    if (xs == nullptr || ys == nullptr)        throw dereference_nil{ "dot product" };     assert(xs->get_element_type()->is_equal(intrinsic_type_desc::type<real_t>().get()));    assert(ys->get_element_type()->is_equal(intrinsic_type_desc::type<real_t>().get()));    const auto x_len = xs->get_length();    if (x_len != ys->get_length())        throw vm_user_exception{ "Array lengths must be equal" };     auto x_raw = reinterpret_cast<real_t *>(xs->at(0));    auto y_raw = reinterpret_cast<real_t *>(ys->at(0));     auto result = real_t{ 0 };    for (auto i = 0; i < x_len; ++i)        result += (x_raw[i] * y_raw[i]);     *fp.ret = result;} voidMath_erf(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_erf>();    *fp.ret = std::erf(fp.x);} voidMath_erfc(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_erfc>();    *fp.ret = std::erfc(fp.x);} voidMath_exp(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_exp>();    *fp.ret = std::exp(fp.x);} voidMath_expm1(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_expm1>();    *fp.ret = std::expm1(fp.x);} voidMath_export_int(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_export_int>();    throw vm_system_exception{ "Function not implemented" };} voidMath_export_real(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_export_real>();     auto buffer = vm_alloc_t::from_allocation<vm_array_t>(fp.b);    assert(buffer->get_element_type()->is_equal(intrinsic_type_desc::type<byte_t>().get()));     auto values = vm_alloc_t::from_allocation<vm_array_t>(fp.x);    assert(values->get_element_type()->is_equal(intrinsic_type_desc::type<real_t>().get()));    const auto values_len = values->get_length();     if (buffer->get_length() != (8 * values_len))        throw vm_user_exception{ "Invalid buffer size based on conversion" };     // Insert as big endian    for (int i = 0; i < values_len; ++i)    {        auto x = values->at<real_t>(i);        uint64_t t;        std::memcpy(&t, &x, sizeof(x));        static_assert(sizeof(t) == sizeof(x), "Real should be 64-bits");         auto base = reinterpret_cast<byte_t *>(buffer->at(i * sizeof(x)));        base[0] = static_cast<byte_t>(t >> 56);        base[1] = static_cast<byte_t>(t >> 48);        base[2] = static_cast<byte_t>(t >> 40);        base[3] = static_cast<byte_t>(t >> 32);        base[4] = static_cast<byte_t>(t >> 24);        base[5] = static_cast<byte_t>(t >> 16);        base[6] = static_cast<byte_t>(t >> 8);        base[7] = static_cast<byte_t>(t);    }} voidMath_export_real32(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_export_real32>();    throw vm_system_exception{ "Function not implemented" };} voidMath_fabs(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_fabs>();    *fp.ret = std::fabs(fp.x);} voidMath_fdim(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_fdim>();    *fp.ret = std::fdim(fp.x, fp.y);} voidMath_finite(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_finite>();    *fp.ret = std::isfinite(fp.x) ? 1 : 0;} voidMath_floor(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_floor>();    *fp.ret = std::floor(fp.x);} voidMath_fmax(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_fmax>();    *fp.ret = std::fmax(fp.x, fp.y);} voidMath_fmin(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_fmin>();    *fp.ret = std::fmin(fp.x, fp.y);} voidMath_fmod(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_fmod>();    *fp.ret = std::fmod(fp.x, fp.y);} voidMath_gemm(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_gemm>();    throw vm_system_exception{ "Function not implemented" };} voidMath_getFPcontrol(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_getFPcontrol>();    throw vm_system_exception{ "Function not implemented" };} voidMath_getFPstatus(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_getFPstatus>();    throw vm_system_exception{ "Function not implemented" };} voidMath_hypot(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_hypot>();    *fp.ret = std::hypot(fp.x, fp.y);} voidMath_iamax(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_iamax>();    throw vm_system_exception{ "Function not implemented" };} voidMath_ilogb(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_ilogb>();    *fp.ret = std::ilogb(fp.x);} voidMath_import_int(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_import_int>();    throw vm_system_exception{ "Function not implemented" };} voidMath_import_real(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_import_real>();     auto buffer = vm_alloc_t::from_allocation<vm_array_t>(fp.b);    assert(buffer->get_element_type()->is_equal(intrinsic_type_desc::type<byte_t>().get()));     auto result = vm_alloc_t::from_allocation<vm_array_t>(fp.x);    assert(result->get_element_type()->is_equal(intrinsic_type_desc::type<real_t>().get()));    const auto result_len = result->get_length();     if (buffer->get_length() != (8 * result_len))        throw vm_user_exception{ "Invalid buffer size based on conversion" };     // Process as big endian    for (int i = 0; i < result_len; ++i)    {        uint64_t t = buffer->at<byte_t>(0);        for (int j = 1; j < 8; ++j)            t = (t << 8) | buffer->at<byte_t>(j);         real_t x;        std::memcpy(&x, &t, sizeof(t));        static_assert(sizeof(t) == sizeof(x), "Real should be 64-bits");         result->at<real_t>(i) = x;    }} voidMath_import_real32(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_import_real32>();    throw vm_system_exception{ "Function not implemented" };} voidMath_isnan(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_isnan>();    *fp.ret = std::isnan(fp.x) ? 1 : 0;} voidMath_j0(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_j0>();    throw vm_system_exception{ "Function not implemented" };} voidMath_j1(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_j1>();    throw vm_system_exception{ "Function not implemented" };} voidMath_jn(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_jn>();    throw vm_system_exception{ "Function not implemented" };} voidMath_lgamma(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_lgamma>();    throw vm_system_exception{ "Function not implemented" };} voidMath_log(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_log>();

Lines 1–500 of 730. Load more