/**

* Built-in elements providing WebAssembly core functionality.

* @module builtins

*//***/

import {

Compiler,

Constraints,

RuntimeFeatures,

flatten

} from "./compiler";

import {

DiagnosticCode

} from "./diagnostics";

import {

Node,

NodeKind,

Expression,

LiteralKind,

LiteralExpression,

StringLiteralExpression,

CallExpression

} from "./ast";

import {

Type,

TypeKind,

TypeFlags,

Signature

} from "./types";

import {

BinaryOp,

UnaryOp,

HostOp,

AtomicRMWOp,

SIMDExtractOp,

SIMDReplaceOp,

SIMDShiftOp,

SIMDTernaryOp,

NativeType,

ExpressionRef,

ExpressionId,

getExpressionId,

getExpressionType,

getConstValueI64High,

getConstValueI64Low,

getConstValueI32,

getConstValueF32,

getConstValueF64,

Relooper,

RelooperBlockRef

} from "./module";

import {

ElementKind,

FunctionPrototype,

Field,

Global,

DecoratorFlags,

Element

} from "./program";

import {

FlowFlags,

LocalFlags

} from "./flow";

import {

ReportMode

} from "./resolver";

import {

CommonFlags,

Feature,

featureToString,

TypeinfoFlags

} from "./common";

import {

writeI8,

writeI16,

writeI32,

writeF32,

writeF64,

isPowerOf2

} from "./util";

/** Symbols of various compiler built-ins. */

export namespace BuiltinSymbols {

// std/builtins.ts

export const isInteger = "~lib/builtins/isInteger";

export const isFloat = "~lib/builtins/isFloat";

export const isBoolean = "~lib/builtins/isBoolean";

export const isSigned = "~lib/builtins/isSigned";

export const isReference = "~lib/builtins/isReference";

export const isString = "~lib/builtins/isString";

export const isArray = "~lib/builtins/isArray";

export const isArrayLike = "~lib/builtins/isArrayLike";

export const isFunction = "~lib/builtins/isFunction";

export const isNullable = "~lib/builtins/isNullable";

export const isDefined = "~lib/builtins/isDefined";

export const isConstant = "~lib/builtins/isConstant";

export const isManaged = "~lib/builtins/isManaged";

export const isVoid = "~lib/builtins/isVoid";

export const clz = "~lib/builtins/clz";

export const ctz = "~lib/builtins/ctz";

export const popcnt = "~lib/builtins/popcnt";

export const rotl = "~lib/builtins/rotl";

export const rotr = "~lib/builtins/rotr";

export const abs = "~lib/builtins/abs";

export const max = "~lib/builtins/max";

export const min = "~lib/builtins/min";

export const ceil = "~lib/builtins/ceil";

export const floor = "~lib/builtins/floor";

export const copysign = "~lib/builtins/copysign";

export const nearest = "~lib/builtins/nearest";

export const reinterpret = "~lib/builtins/reinterpret";

export const sqrt = "~lib/builtins/sqrt";

export const trunc = "~lib/builtins/trunc";

export const load = "~lib/builtins/load";

export const store = "~lib/builtins/store";

export const atomic_load = "~lib/builtins/atomic.load";

export const atomic_store = "~lib/builtins/atomic.store";

export const atomic_add = "~lib/builtins/atomic.add";

export const atomic_sub = "~lib/builtins/atomic.sub";

export const atomic_and = "~lib/builtins/atomic.and";

export const atomic_or = "~lib/builtins/atomic.or";

export const atomic_xor = "~lib/builtins/atomic.xor";

export const atomic_xchg = "~lib/builtins/atomic.xchg";

export const atomic_cmpxchg = "~lib/builtins/atomic.cmpxchg";

export const atomic_wait = "~lib/builtins/atomic.wait";

export const atomic_notify = "~lib/builtins/atomic.notify";

export const atomic_fence = "~lib/builtins/atomic.fence";

export const sizeof = "~lib/builtins/sizeof";

export const alignof = "~lib/builtins/alignof";

export const offsetof = "~lib/builtins/offsetof";

export const nameof = "~lib/builtins/nameof";

export const lengthof = "~lib/builtins/lengthof";

export const select = "~lib/builtins/select";

export const unreachable = "~lib/builtins/unreachable";

export const changetype = "~lib/builtins/changetype";

export const assert = "~lib/builtins/assert";

export const unchecked = "~lib/builtins/unchecked";

export const call_direct = "~lib/builtins/call_direct";

export const call_indirect = "~lib/builtins/call_indirect";

export const instantiate = "~lib/builtins/instantiate";

export const idof = "~lib/builtins/idof";

export const i8 = "~lib/builtins/i8";

export const i16 = "~lib/builtins/i16";

export const i32 = "~lib/builtins/i32";

export const i64 = "~lib/builtins/i64";

export const isize = "~lib/builtins/isize";

export const u8 = "~lib/builtins/u8";

export const u16 = "~lib/builtins/u16";

export const u32 = "~lib/builtins/u32";

export const u64 = "~lib/builtins/u64";

export const usize = "~lib/builtins/usize";

export const bool = "~lib/builtins/bool";

export const f32 = "~lib/builtins/f32";

export const f64 = "~lib/builtins/f64";

export const v128 = "~lib/builtins/v128";

export const void_ = "~lib/builtins/void";

export const i32_clz = "~lib/builtins/i32.clz";

export const i64_clz = "~lib/builtins/i64.clz";

export const i32_ctz = "~lib/builtins/i32.ctz";

export const i64_ctz = "~lib/builtins/i64.ctz";

export const i32_popcnt = "~lib/builtins/i32.popcnt";

export const i64_popcnt = "~lib/builtins/i64.popcnt";

export const i32_rotl = "~lib/builtins/i32.rotl";

export const i64_rotl = "~lib/builtins/i64.rotl";

export const i32_rotr = "~lib/builtins/i32.rotr";

export const i64_rotr = "~lib/builtins/i64.rotr";

export const f32_abs = "~lib/builtins/f32.abs";

export const f64_abs = "~lib/builtins/f64.abs";

export const f32_max = "~lib/builtins/f32.max";

export const f64_max = "~lib/builtins/f64.max";

export const f32_min = "~lib/builtins/f32.min";

export const f64_min = "~lib/builtins/f64.min";

export const f32_ceil = "~lib/builtins/f32.ceil";

export const f64_ceil = "~lib/builtins/f64.ceil";

export const f32_floor = "~lib/builtins/f32.floor";

export const f64_floor = "~lib/builtins/f64.floor";

export const f32_copysign = "~lib/builtins/f32.copysign";

export const f64_copysign = "~lib/builtins/f64.copysign";

export const f32_nearest = "~lib/builtins/f32.nearest";

export const f64_nearest = "~lib/builtins/f64.nearest";

export const i32_reinterpret_f32 = "~lib/builtins/i32.reinterpret_f32";

export const i64_reinterpret_f64 = "~lib/builtins/i64.reinterpret_f64";

export const f32_reinterpret_i32 = "~lib/builtins/f32.reinterpret_i32";

export const f64_reinterpret_i64 = "~lib/builtins/f64.reinterpret_i64";

export const f32_sqrt = "~lib/builtins/f32.sqrt";

export const f64_sqrt = "~lib/builtins/f64.sqrt";

export const f32_trunc = "~lib/builtins/f32.trunc";

export const f64_trunc = "~lib/builtins/f64.trunc";

export const i32_load8_s = "~lib/builtins/i32.load8_s";

export const i32_load8_u = "~lib/builtins/i32.load8_u";

export const i32_load16_s = "~lib/builtins/i32.load16_s";

export const i32_load16_u = "~lib/builtins/i32.load16_u";

export const i32_load = "~lib/builtins/i32.load";

export const i64_load8_s = "~lib/builtins/i64.load8_s";

export const i64_load8_u = "~lib/builtins/i64.load8_u";

export const i64_load16_s = "~lib/builtins/i64.load16_s";

export const i64_load16_u = "~lib/builtins/i64.load16_u";

export const i64_load32_s = "~lib/builtins/i64.load32_s";

export const i64_load32_u = "~lib/builtins/i64.load32_u";

export const i64_load = "~lib/builtins/i64.load";

export const f32_load = "~lib/builtins/f32.load";

export const f64_load = "~lib/builtins/f64.load";

export const i32_store8 = "~lib/builtins/i32.store8";

export const i32_store16 = "~lib/builtins/i32.store16";

export const i32_store = "~lib/builtins/i32.store";

export const i64_store8 = "~lib/builtins/i64.store8";

export const i64_store16 = "~lib/builtins/i64.store16";

export const i64_store32 = "~lib/builtins/i64.store32";

export const i64_store = "~lib/builtins/i64.store";

export const f32_store = "~lib/builtins/f32.store";

export const f64_store = "~lib/builtins/f64.store";

export const i32_atomic_load8_u = "~lib/builtins/i32.atomic.load8_u";

export const i32_atomic_load16_u = "~lib/builtins/i32.atomic.load16_u";

export const i32_atomic_load = "~lib/builtins/i32.atomic.load";

export const i64_atomic_load8_u = "~lib/builtins/i64.atomic.load8_u";

export const i64_atomic_load16_u = "~lib/builtins/i64.atomic.load16_u";

export const i64_atomic_load32_u = "~lib/builtins/i64.atomic.load32_u";

export const i64_atomic_load = "~lib/builtins/i64.atomic.load";

export const i32_atomic_store8 = "~lib/builtins/i32.atomic.store8";

export const i32_atomic_store16 = "~lib/builtins/i32.atomic.store16";

export const i32_atomic_store = "~lib/builtins/i32.atomic.store";

export const i64_atomic_store8 = "~lib/builtins/i64.atomic.store8";

export const i64_atomic_store16 = "~lib/builtins/i64.atomic.store16";

export const i64_atomic_store32 = "~lib/builtins/i64.atomic.store32";

export const i64_atomic_store = "~lib/builtins/i64.atomic.store";

export const i32_atomic_rmw8_add_u = "~lib/builtins/i32.atomic.rmw8.add_u";

export const i32_atomic_rmw16_add_u = "~lib/builtins/i32.atomic.rmw16.add_u";

export const i32_atomic_rmw_add = "~lib/builtins/i32.atomic.rmw.add";

export const i64_atomic_rmw8_add_u = "~lib/builtins/i64.atomic.rmw8.add_u";

export const i64_atomic_rmw16_add_u = "~lib/builtins/i64.atomic.rmw16.add_u";

export const i64_atomic_rmw32_add_u = "~lib/builtins/i64.atomic.rmw32.add_u";

export const i64_atomic_rmw_add = "~lib/builtins/i64.atomic.rmw.add";

export const i32_atomic_rmw8_sub_u = "~lib/builtins/i32.atomic.rmw8.sub_u";

export const i32_atomic_rmw16_sub_u = "~lib/builtins/i32.atomic.rmw16.sub_u";

export const i32_atomic_rmw_sub = "~lib/builtins/i32.atomic.rmw.sub";

export const i64_atomic_rmw8_sub_u = "~lib/builtins/i64.atomic.rmw8.sub_u";

export const i64_atomic_rmw16_sub_u = "~lib/builtins/i64.atomic.rmw16.sub_u";

export const i64_atomic_rmw32_sub_u = "~lib/builtins/i64.atomic.rmw32.sub_u";

export const i64_atomic_rmw_sub = "~lib/builtins/i64.atomic.rmw.sub";

export const i32_atomic_rmw8_and_u = "~lib/builtins/i32.atomic.rmw8.and_u";

export const i32_atomic_rmw16_and_u = "~lib/builtins/i32.atomic.rmw16.and_u";

export const i32_atomic_rmw_and = "~lib/builtins/i32.atomic.rmw.and";

export const i64_atomic_rmw8_and_u = "~lib/builtins/i64.atomic.rmw8.and_u";

export const i64_atomic_rmw16_and_u = "~lib/builtins/i64.atomic.rmw16.and_u";

export const i64_atomic_rmw32_and_u = "~lib/builtins/i64.atomic.rmw32.and_u";

export const i64_atomic_rmw_and = "~lib/builtins/i64.atomic.rmw.and";

export const i32_atomic_rmw8_or_u = "~lib/builtins/i32.atomic.rmw8.or_u";

export const i32_atomic_rmw16_or_u = "~lib/builtins/i32.atomic.rmw16.or_u";

export const i32_atomic_rmw_or = "~lib/builtins/i32.atomic.rmw.or";

export const i64_atomic_rmw8_or_u = "~lib/builtins/i64.atomic.rmw8.or_u";

export const i64_atomic_rmw16_or_u = "~lib/builtins/i64.atomic.rmw16.or_u";

export const i64_atomic_rmw32_or_u = "~lib/builtins/i64.atomic.rmw32.or_u";

export const i64_atomic_rmw_or = "~lib/builtins/i64.atomic.rmw.or";

export const i32_atomic_rmw8_xor_u = "~lib/builtins/i32.atomic.rmw8.xor_u";

export const i32_atomic_rmw16_xor_u = "~lib/builtins/i32.atomic.rmw16.xor_u";

export const i32_atomic_rmw_xor = "~lib/builtins/i32.atomic.rmw.xor";

export const i64_atomic_rmw8_xor_u = "~lib/builtins/i64.atomic.rmw8.xor_u";

export const i64_atomic_rmw16_xor_u = "~lib/builtins/i64.atomic.rmw16.xor_u";

export const i64_atomic_rmw32_xor_u = "~lib/builtins/i64.atomic.rmw32.xor_u";

export const i64_atomic_rmw_xor = "~lib/builtins/i64.atomic.rmw.xor";

export const i32_atomic_rmw8_xchg_u = "~lib/builtins/i32.atomic.rmw8.xchg_u";

export const i32_atomic_rmw16_xchg_u = "~lib/builtins/i32.atomic.rmw16.xchg_u";

export const i32_atomic_rmw_xchg = "~lib/builtins/i32.atomic.rmw.xchg";

export const i64_atomic_rmw8_xchg_u = "~lib/builtins/i64.atomic.rmw8.xchg_u";

export const i64_atomic_rmw16_xchg_u = "~lib/builtins/i64.atomic.rmw16.xchg_u";

export const i64_atomic_rmw32_xchg_u = "~lib/builtins/i64.atomic.rmw32.xchg_u";

export const i64_atomic_rmw_xchg = "~lib/builtins/i64.atomic.rmw.xchg";

export const i32_atomic_rmw8_cmpxchg_u = "~lib/builtins/i32.atomic.rmw8.cmpxchg_u";

export const i32_atomic_rmw16_cmpxchg_u = "~lib/builtins/i32.atomic.rmw16.cmpxchg_u";

export const i32_atomic_rmw_cmpxchg = "~lib/builtins/i32.atomic.rmw.cmpxchg";

export const i64_atomic_rmw8_cmpxchg_u = "~lib/builtins/i64.atomic.rmw8.cmpxchg_u";

export const i64_atomic_rmw16_cmpxchg_u = "~lib/builtins/i64.atomic.rmw16.cmpxchg_u";

export const i64_atomic_rmw32_cmpxchg_u = "~lib/builtins/i64.atomic.rmw32.cmpxchg_u";

export const i64_atomic_rmw_cmpxchg = "~lib/builtins/i64.atomic.rmw.cmpxchg";

export const i32_wait = "~lib/builtins/i32.wait";

export const i64_wait = "~lib/builtins/i64.wait";

export const v128_splat = "~lib/builtins/v128.splat";

export const v128_extract_lane = "~lib/builtins/v128.extract_lane";

export const v128_replace_lane = "~lib/builtins/v128.replace_lane";

export const v128_shuffle = "~lib/builtins/v128.shuffle";

export const v128_load = "~lib/builtins/v128.load";

export const v128_store = "~lib/builtins/v128.store";

export const v128_add = "~lib/builtins/v128.add";

export const v128_sub = "~lib/builtins/v128.sub";

export const v128_mul = "~lib/builtins/v128.mul";

export const v128_div = "~lib/builtins/v128.div";

export const v128_neg = "~lib/builtins/v128.neg";

export const v128_add_saturate = "~lib/builtins/v128.add_saturate";

export const v128_sub_saturate = "~lib/builtins/v128.sub_saturate";

export const v128_shl = "~lib/builtins/v128.shl";

export const v128_shr = "~lib/builtins/v128.shr";

export const v128_and = "~lib/builtins/v128.and";

export const v128_or = "~lib/builtins/v128.or";

export const v128_xor = "~lib/builtins/v128.xor";

export const v128_not = "~lib/builtins/v128.not";

export const v128_bitselect = "~lib/builtins/v128.bitselect";

export const v128_any_true = "~lib/builtins/v128.any_true";

export const v128_all_true = "~lib/builtins/v128.all_true";

export const v128_min = "~lib/builtins/v128.min";

export const v128_max = "~lib/builtins/v128.max";

export const v128_abs = "~lib/builtins/v128.abs";

export const v128_sqrt = "~lib/builtins/v128.sqrt";

export const v128_eq = "~lib/builtins/v128.eq";

export const v128_ne = "~lib/builtins/v128.ne";

export const v128_lt = "~lib/builtins/v128.lt";

export const v128_le = "~lib/builtins/v128.le";

export const v128_gt = "~lib/builtins/v128.gt";

export const v128_ge = "~lib/builtins/v128.ge";

export const v128_convert = "~lib/builtins/v128.convert";

export const v128_trunc_sat = "~lib/builtins/v128.trunc_sat";

export const v128_narrow = "~lib/builtins/v128.narrow";

export const v128_widen_low = "~lib/builtins/v128.widen_low";

export const v128_widen_high = "~lib/builtins/v128.widen_high";

export const v128_qfma = "~lib/builtins/v128.qfma";

export const v128_qfms = "~lib/builtins/v128.qfms";

export const i8x16 = "~lib/builtins/i8x16";

export const i16x8 = "~lib/builtins/i16x8";

export const i32x4 = "~lib/builtins/i32x4";

export const i64x2 = "~lib/builtins/i64x2";

export const f32x4 = "~lib/builtins/f32x4";

export const f64x2 = "~lib/builtins/f64x2";

export const i8x16_splat = "~lib/builtins/i8x16.splat";

export const i8x16_extract_lane_s = "~lib/builtins/i8x16.extract_lane_s";

export const i8x16_extract_lane_u = "~lib/builtins/i8x16.extract_lane_u";

export const i8x16_replace_lane = "~lib/builtins/i8x16.replace_lane";

export const i8x16_add = "~lib/builtins/i8x16.add";

export const i8x16_sub = "~lib/builtins/i8x16.sub";

export const i8x16_mul = "~lib/builtins/i8x16.mul";

export const i8x16_neg = "~lib/builtins/i8x16.neg";

export const i8x16_add_saturate_s = "~lib/builtins/i8x16.add_saturate_s";

export const i8x16_add_saturate_u = "~lib/builtins/i8x16.add_saturate_u";

export const i8x16_sub_saturate_s = "~lib/builtins/i8x16.sub_saturate_s";

export const i8x16_sub_saturate_u = "~lib/builtins/i8x16.sub_saturate_u";

export const i8x16_shl = "~lib/builtins/i8x16.shl";

export const i8x16_shr_s = "~lib/builtins/i8x16.shr_s";

export const i8x16_shr_u = "~lib/builtins/i8x16.shr_u";

export const i8x16_any_true = "~lib/builtins/i8x16.any_true";

export const i8x16_all_true = "~lib/builtins/i8x16.all_true";

export const i8x16_eq = "~lib/builtins/i8x16.eq";

export const i8x16_ne = "~lib/builtins/i8x16.ne";

export const i8x16_lt_s = "~lib/builtins/i8x16.lt_s";

export const i8x16_lt_u = "~lib/builtins/i8x16.lt_u";

export const i8x16_le_s = "~lib/builtins/i8x16.le_s";

export const i8x16_le_u = "~lib/builtins/i8x16.le_u";

export const i8x16_gt_s = "~lib/builtins/i8x16.gt_s";

export const i8x16_gt_u = "~lib/builtins/i8x16.gt_u";

export const i8x16_ge_s = "~lib/builtins/i8x16.ge_s";

export const i8x16_ge_u = "~lib/builtins/i8x16.ge_u";

export const i8x16_narrow_i16x8_s = "~lib/builtins/i8x16.narrow_i16x8_s";

export const i8x16_narrow_i16x8_u = "~lib/builtins/i8x16.narrow_i16x8_u";

export const i16x8_splat = "~lib/builtins/i16x8.splat";

export const i16x8_extract_lane_s = "~lib/builtins/i16x8.extract_lane_s";

export const i16x8_extract_lane_u = "~lib/builtins/i16x8.extract_lane_u";

export const i16x8_replace_lane = "~lib/builtins/i16x8.replace_lane";

export const i16x8_add = "~lib/builtins/i16x8.add";

export const i16x8_sub = "~lib/builtins/i16x8.sub";

export const i16x8_mul = "~lib/builtins/i16x8.mul";

export const i16x8_neg = "~lib/builtins/i16x8.neg";

export const i16x8_add_saturate_s = "~lib/builtins/i16x8.add_saturate_s";

export const i16x8_add_saturate_u = "~lib/builtins/i16x8.add_saturate_u";

export const i16x8_sub_saturate_s = "~lib/builtins/i16x8.sub_saturate_s";

export const i16x8_sub_saturate_u = "~lib/builtins/i16x8.sub_saturate_u";

export const i16x8_shl = "~lib/builtins/i16x8.shl";

export const i16x8_shr_s = "~lib/builtins/i16x8.shr_s";

export const i16x8_shr_u = "~lib/builtins/i16x8.shr_u";

export const i16x8_any_true = "~lib/builtins/i16x8.any_true";

export const i16x8_all_true = "~lib/builtins/i16x8.all_true";

export const i16x8_eq = "~lib/builtins/i16x8.eq";

export const i16x8_ne = "~lib/builtins/i16x8.ne";

export const i16x8_lt_s = "~lib/builtins/i16x8.lt_s";

export const i16x8_lt_u = "~lib/builtins/i16x8.lt_u";

export const i16x8_le_s = "~lib/builtins/i16x8.le_s";

export const i16x8_le_u = "~lib/builtins/i16x8.le_u";

export const i16x8_gt_s = "~lib/builtins/i16x8.gt_s";

export const i16x8_gt_u = "~lib/builtins/i16x8.gt_u";

export const i16x8_ge_s = "~lib/builtins/i16x8.ge_s";

export const i16x8_ge_u = "~lib/builtins/i16x8.ge_u";

export const i16x8_narrow_i32x4_s = "~lib/builtins/i16x8.narrow_i32x4_s";

export const i16x8_narrow_i32x4_u = "~lib/builtins/i16x8.narrow_i32x4_u";

export const i16x8_widen_low_i8x16_s = "~lib/builtins/i16x8.widen_low_i8x16_s";

export const i16x8_widen_low_i8x16_u = "~lib/builtins/i16x8.widen_low_i8x16_u";

export const i16x8_widen_high_i8x16_s = "~lib/builtins/i16x8.widen_high_i8x16_s";

export const i16x8_widen_high_i8x16_u = "~lib/builtins/i16x8.widen_high_i8x16_u";

export const i32x4_splat = "~lib/builtins/i32x4.splat";

export const i32x4_extract_lane = "~lib/builtins/i32x4.extract_lane";

export const i32x4_replace_lane = "~lib/builtins/i32x4.replace_lane";

export const i32x4_add = "~lib/builtins/i32x4.add";

export const i32x4_sub = "~lib/builtins/i32x4.sub";

export const i32x4_mul = "~lib/builtins/i32x4.mul";

export const i32x4_neg = "~lib/builtins/i32x4.neg";

export const i32x4_shl = "~lib/builtins/i32x4.shl";

export const i32x4_shr_s = "~lib/builtins/i32x4.shr_s";

export const i32x4_shr_u = "~lib/builtins/i32x4.shr_u";

export const i32x4_any_true = "~lib/builtins/i32x4.any_true";

export const i32x4_all_true = "~lib/builtins/i32x4.all_true";

export const i32x4_eq = "~lib/builtins/i32x4.eq";

export const i32x4_ne = "~lib/builtins/i32x4.ne";

export const i32x4_lt_s = "~lib/builtins/i32x4.lt_s";

export const i32x4_lt_u = "~lib/builtins/i32x4.lt_u";

export const i32x4_le_s = "~lib/builtins/i32x4.le_s";

export const i32x4_le_u = "~lib/builtins/i32x4.le_u";

export const i32x4_gt_s = "~lib/builtins/i32x4.gt_s";

export const i32x4_gt_u = "~lib/builtins/i32x4.gt_u";

export const i32x4_ge_s = "~lib/builtins/i32x4.ge_s";

export const i32x4_ge_u = "~lib/builtins/i32x4.ge_u";

export const i32x4_trunc_sat_f32x4_s = "~lib/builtins/i32x4.trunc_sat_f32x4_s";

export const i32x4_trunc_sat_f32x4_u = "~lib/builtins/i32x4.trunc_sat_f32x4_u";

export const i32x4_widen_low_i16x8_s = "~lib/builtins/i32x4.widen_low_i16x8_s";

export const i32x4_widen_low_i16x8_u = "~lib/builtins/i32x4.widen_low_i16x8_u";

export const i32x4_widen_high_i16x8_s = "~lib/builtins/i32x4.widen_high_i16x8_s";

export const i32x4_widen_high_i16x8_u = "~lib/builtins/i32x4.widen_high_i16x8_u";

export const i64x2_splat = "~lib/builtins/i64x2.splat";

export const i64x2_extract_lane = "~lib/builtins/i64x2.extract_lane";

export const i64x2_replace_lane = "~lib/builtins/i64x2.replace_lane";

export const i64x2_add = "~lib/builtins/i64x2.add";

export const i64x2_sub = "~lib/builtins/i64x2.sub"; // i64x2 has no .mul

export const i64x2_neg = "~lib/builtins/i64x2.neg";

export const i64x2_shl = "~lib/builtins/i64x2.shl";

export const i64x2_shr_s = "~lib/builtins/i64x2.shr_s";

export const i64x2_shr_u = "~lib/builtins/i64x2.shr_u";

export const i64x2_any_true = "~lib/builtins/i64x2.any_true";

export const i64x2_all_true = "~lib/builtins/i64x2.all_true"; // i64x2 has no .eq etc.

export const i64x2_trunc_sat_f64x2_s = "~lib/builtins/i64x2.trunc_sat_f64x2_s";

export const i64x2_trunc_sat_f64x2_u = "~lib/builtins/i64x2.trunc_sat_f64x2_u";

export const f32x4_splat = "~lib/builtins/f32x4.splat";

export const f32x4_extract_lane = "~lib/builtins/f32x4.extract_lane";

export const f32x4_replace_lane = "~lib/builtins/f32x4.replace_lane";

export const f32x4_add = "~lib/builtins/f32x4.add";

export const f32x4_sub = "~lib/builtins/f32x4.sub";

export const f32x4_mul = "~lib/builtins/f32x4.mul";

export const f32x4_div = "~lib/builtins/f32x4.div";

export const f32x4_neg = "~lib/builtins/f32x4.neg";

export const f32x4_min = "~lib/builtins/f32x4.min";

export const f32x4_max = "~lib/builtins/f32x4.max";

export const f32x4_abs = "~lib/builtins/f32x4.abs";

export const f32x4_sqrt = "~lib/builtins/f32x4.sqrt";

export const f32x4_eq = "~lib/builtins/f32x4.eq";

export const f32x4_ne = "~lib/builtins/f32x4.ne";

export const f32x4_lt = "~lib/builtins/f32x4.lt";

export const f32x4_le = "~lib/builtins/f32x4.le";

export const f32x4_gt = "~lib/builtins/f32x4.gt";

export const f32x4_ge = "~lib/builtins/f32x4.ge";

export const f32x4_convert_i32x4_s = "~lib/builtins/f32x4.convert_i32x4_s";

export const f32x4_convert_i32x4_u = "~lib/builtins/f32x4.convert_i32x4_u";

export const f32x4_qfma = "~lib/builtins/f32x4.qfma";

export const f32x4_qfms = "~lib/builtins/f32x4.qfms";

export const f64x2_splat = "~lib/builtins/f64x2.splat";

export const f64x2_extract_lane = "~lib/builtins/f64x2.extract_lane";

export const f64x2_replace_lane = "~lib/builtins/f64x2.replace_lane";

export const f64x2_add = "~lib/builtins/f64x2.add";

export const f64x2_sub = "~lib/builtins/f64x2.sub";

export const f64x2_mul = "~lib/builtins/f64x2.mul";

export const f64x2_div = "~lib/builtins/f64x2.div";

export const f64x2_neg = "~lib/builtins/f64x2.neg";

export const f64x2_min = "~lib/builtins/f64x2.min";

export const f64x2_max = "~lib/builtins/f64x2.max";

export const f64x2_abs = "~lib/builtins/f64x2.abs";

export const f64x2_sqrt = "~lib/builtins/f64x2.sqrt";

export const f64x2_eq = "~lib/builtins/f64x2.eq";

export const f64x2_ne = "~lib/builtins/f64x2.ne";

export const f64x2_lt = "~lib/builtins/f64x2.lt";

export const f64x2_le = "~lib/builtins/f64x2.le";

export const f64x2_gt = "~lib/builtins/f64x2.gt";

export const f64x2_ge = "~lib/builtins/f64x2.ge";

export const f64x2_convert_i64x2_s = "~lib/builtins/f64x2.convert_i64x2_s";

export const f64x2_convert_i64x2_u = "~lib/builtins/f64x2.convert_i64x2_u";

export const f64x2_qfma = "~lib/builtins/f64x2.qfma";

export const f64x2_qfms = "~lib/builtins/f64x2.qfms";

export const v8x16_shuffle = "~lib/builtins/v8x16.shuffle";

// internals

export const heap_base = "~lib/heap/__heap_base";

export const rtti_base = "~lib/rt/__rtti_base";

export const visit_globals = "~lib/rt/__visit_globals";

export const visit_members = "~lib/rt/__visit_members";

// std/diagnostics.ts

export const ERROR = "~lib/diagnostics/ERROR";

export const WARNING = "~lib/diagnostics/WARNING";

export const INFO = "~lib/diagnostics/INFO";

// std/memory.ts

export const memory_size = "~lib/memory/memory.size";

export const memory_grow = "~lib/memory/memory.grow";

export const memory_copy = "~lib/memory/memory.copy";

export const memory_fill = "~lib/memory/memory.fill";

export const memory_allocate = "~lib/memory/memory.allocate";

export const memory_free = "~lib/memory/memory.free";

export const memory_reset = "~lib/memory/memory.reset";

// std/runtime.ts

export const runtime_instanceof = "~lib/runtime/runtime.instanceof";

export const runtime_flags = "~lib/runtime/runtime.flags";

export const runtime_allocate = "~lib/util/runtime/allocate";

export const runtime_reallocate = "~lib/util/runtime/reallocate";

export const runtime_register = "~lib/util/runtime/register";

export const runtime_discard = "~lib/util/runtime/discard";

export const runtime_makeArray = "~lib/util/runtime/makeArray";

// std/typedarray.ts

export const Int8Array = "~lib/typedarray/Int8Array";

export const Uint8Array = "~lib/typedarray/Uint8Array";

export const Int16Array = "~lib/typedarray/Int16Array";

export const Uint16Array = "~lib/typedarray/Uint16Array";

export const Int32Array = "~lib/typedarray/Int32Array";

export const Uint32Array = "~lib/typedarray/Uint32Array";

export const Int64Array = "~lib/typedarray/Int64Array";

export const Uint64Array = "~lib/typedarray/Uint64Array";

export const Uint8ClampedArray = "~lib/typedarray/Uint8ClampedArray";

export const Float32Array = "~lib/typedarray/Float32Array";

export const Float64Array = "~lib/typedarray/Float64Array";

// compiler generated

export const started = "~lib/started";

export const argc = "~lib/argc";

export const setargc = "~lib/setargc";

export const capabilities = "~lib/capabilities";

}

/** Compiles a call to a built-in function. */

export function compileCall(

/* Compiler reference. */

compiler: Compiler,

/** Respective function prototype. */

prototype: FunctionPrototype,

/** Pre-resolved type arguments. */

typeArguments: Type[] | null,

/** Operand expressions. */

operands: Expression[],

/** Contextual type. */

contextualType: Type,

/** Respective call expression. */

reportNode: CallExpression,

/** Indicates that contextual type is ASM type. */

isAsm: bool = false

): ExpressionRef {

var module = compiler.module;

switch (prototype.internalName) {

// === Static type evaluation =================================================================

case BuiltinSymbols.isInteger: { // isInteger<T!>() / isInteger<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return type.is(TypeFlags.INTEGER) && !type.is(TypeFlags.REFERENCE)

? module.i32(1)

: module.i32(0);

}

case BuiltinSymbols.isFloat: { // isFloat<T!>() / isFloat<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return type.is(TypeFlags.FLOAT)

? module.i32(1)

: module.i32(0);

}

case BuiltinSymbols.isBoolean: { // isBoolean<T!>() / isBoolean<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return type == Type.bool

? module.i32(1)

: module.i32(0);

}

case BuiltinSymbols.isSigned: { // isSigned<T!>() / isSigned<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return type.is(TypeFlags.SIGNED)

? module.i32(1)

: module.i32(0);

}

case BuiltinSymbols.isReference: { // isReference<T!>() / isReference<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return type.is(TypeFlags.REFERENCE)

? module.i32(1)

: module.i32(0);

}

case BuiltinSymbols.isString: { // isString<T!>() / isString<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

if (type.is(TypeFlags.REFERENCE)) {

let classReference = type.classReference;

if (classReference) {

let stringInstance = compiler.program.stringInstance;

if (stringInstance && classReference.isAssignableTo(stringInstance)) return module.i32(1);

}

}

return module.i32(0);

}

case BuiltinSymbols.isArray: { // isArray<T!>() / isArray<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

if (type.is(TypeFlags.REFERENCE)) {

let classReference = type.classReference;

if (classReference) {

return module.i32(classReference.prototype.extends(compiler.program.arrayPrototype) ? 1 : 0);

}

}

return module.i32(0);

}

case BuiltinSymbols.isArrayLike: { // isArrayLike<T!>() / isArrayLike<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

if (type.is(TypeFlags.REFERENCE)) {

let classReference = type.classReference;

if (classReference) {

return module.i32(classReference.isArrayLike ? 1 : 0);

}

}

return module.i32(0);

}

case BuiltinSymbols.isFunction: { // isFunction<T!> / isFunction<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.signatureReference ? 1 : 0);

}

case BuiltinSymbols.isNullable: { // isNullable<T!> / isNullable<T?>(value: T) -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.is(TypeFlags.NULLABLE) ? 1 : 0);

}

case BuiltinSymbols.isDefined: { // isDefined(expression) -> bool

compiler.currentType = Type.bool;

if (

checkTypeAbsent(typeArguments, reportNode, prototype) |

checkArgsRequired(operands, 1, reportNode, compiler)

) return module.unreachable();

let element = compiler.resolver.lookupExpression(

operands[0],

compiler.currentFlow,

Type.auto,

ReportMode.SWALLOW

);

return module.i32(element ? 1 : 0);

}

case BuiltinSymbols.isConstant: { // isConstant(expression) -> bool

compiler.currentType = Type.bool;

if (

checkTypeAbsent(typeArguments, reportNode, prototype) |

checkArgsRequired(operands, 1, reportNode, compiler)

) return module.unreachable();

let expr = compiler.compileExpression(operands[0], Type.auto);

compiler.currentType = Type.bool;

return module.i32(getExpressionId(expr) == ExpressionId.Const ? 1 : 0);

}

case BuiltinSymbols.isManaged: { // isManaged<T!>() -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.isManaged ? 1 : 0);

}

case BuiltinSymbols.isVoid: { // isVoid<T!>() -> bool

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.bool;

if (!type) return module.unreachable();

return module.i32(type.kind == TypeKind.VOID ? 1 : 0);

}

case BuiltinSymbols.lengthof: { // lengthof<T!>() -> i32

let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);

compiler.currentType = Type.i32;

if (!type) return module.unreachable();

let signatureReference = type.signatureReference;

if (!signatureReference) {

compiler.error(

DiagnosticCode.Type_0_has_no_call_signatures,

reportNode.range, type.toString()

);

return module.unreachable();

}

return module.i32(signatureReference.parameterTypes.length);

}

case BuiltinSymbols.sizeof: { // sizeof<T!>() -> usize

compiler.currentType = compiler.options.usizeType;

if (

checkTypeRequired(typeArguments, reportNode, compiler) |

checkArgsRequired(operands, 0, reportNode, compiler)

) return module.unreachable();

let type = typeArguments![0];

let byteSize = type.byteSize;

if (!byteSize) {

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

reportNode.typeArgumentsRange, "sizeof", type.toString()

);

return module.unreachable();

}

if (compiler.options.isWasm64) {

// implicitly wrap if contextual type is a 32-bit integer

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size <= 32) {

compiler.currentType = Type.u32;

return module.i32(byteSize);

}

return module.i64(byteSize, 0);

} else {

// implicitly extend if contextual type is a 64-bit integer

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size == 64) {

compiler.currentType = Type.u64;

return module.i64(byteSize, 0);

}

return module.i32(byteSize);

}

}

case BuiltinSymbols.alignof: { // alignof<T!>() -> usize

compiler.currentType = compiler.options.usizeType;

if (

checkTypeRequired(typeArguments, reportNode, compiler) |

checkArgsRequired(operands, 0, reportNode, compiler)

) return module.unreachable();

let type = typeArguments![0];

let byteSize = type.byteSize;

if (!isPowerOf2(byteSize)) { // implies == 0

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

reportNode.typeArgumentsRange, "alignof", type.toString()

);

return module.unreachable();

}

let alignLog2 = ctz<i32>(byteSize);

if (compiler.options.isWasm64) {

// implicitly wrap if contextual type is a 32-bit integer

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size <= 32) {

compiler.currentType = Type.u32;

return module.i32(alignLog2);

}

return module.i64(alignLog2, 0);

} else {

// implicitly extend if contextual type is a 64-bit integer

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size == 64) {

compiler.currentType = Type.u64;

return module.i64(alignLog2, 0);

}

return module.i32(alignLog2);

}

}

case BuiltinSymbols.offsetof: { // offsetof<T!>(fieldName?: string) -> usize

compiler.currentType = compiler.options.usizeType;

if (

checkTypeRequired(typeArguments, reportNode, compiler) |

checkArgsOptional(operands, 0, 1, reportNode, compiler)

) return module.unreachable();

let type = typeArguments![0];

let classType = type.classReference;

if (!(type.is(TypeFlags.REFERENCE) && classType !== null)) {

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

reportNode.typeArgumentsRange, "offsetof", type.toString()

);

if (compiler.options.isWasm64) {

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size <= 32) {

compiler.currentType = Type.u32;

}

} else {

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size == 64) {

compiler.currentType = Type.u64;

}

}

return module.unreachable();

}

let offset: i32;

if (operands.length) {

if (

operands[0].kind != NodeKind.LITERAL ||

(<LiteralExpression>operands[0]).literalKind != LiteralKind.STRING

) {

compiler.error(

DiagnosticCode.String_literal_expected,

operands[0].range

);

return module.unreachable();

}

let fieldName = (<StringLiteralExpression>operands[0]).value;

let field = classType.members ? classType.members.get(fieldName) : null;

if (!(field && field.kind == ElementKind.FIELD)) {

compiler.error(

DiagnosticCode.Type_0_has_no_property_1,

operands[0].range, classType.internalName, fieldName

);

return module.unreachable();

}

offset = (<Field>field).memoryOffset;

} else {

offset = classType.currentMemoryOffset;

}

if (compiler.options.isWasm64) {

// implicitly wrap if contextual type is a 32-bit integer

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size <= 32) {

compiler.currentType = Type.u32;

return module.i32(offset);

}

return module.i64(offset);

} else {

// implicitly extend if contextual type is a 64-bit integer

if (contextualType.is(TypeFlags.INTEGER) && contextualType.size == 64) {

compiler.currentType = Type.u64;

return module.i64(offset);

}

return module.i32(offset);

}

}

case BuiltinSymbols.nameof: {

let resultType = evaluateConstantType(compiler, typeArguments, operands, reportNode);

if (!resultType) {

compiler.currentType = compiler.program.stringInstance.type;

return module.unreachable();

}

let value: string;

if (resultType.is(TypeFlags.REFERENCE)) {

let classReference = resultType.classReference;

if (classReference) {

value = classReference.name;

} else {

let signatureReference = resultType.signatureReference;

if (signatureReference) {

value = "Function";

} else {

value = "Anyref";

}

}

} else {

switch (resultType.kind) {

case TypeKind.BOOL: { value = "bool"; break; }

case TypeKind.I8: { value = "i8"; break; }

case TypeKind.U8: { value = "u8"; break; }

case TypeKind.I16: { value = "i16"; break; }

case TypeKind.U16: { value = "u16"; break; }

case TypeKind.I32: { value = "i32"; break; }

case TypeKind.U32: { value = "u32"; break; }

case TypeKind.F32: { value = "f32"; break; }

case TypeKind.I64: { value = "i64"; break; }

case TypeKind.U64: { value = "u64"; break; }

case TypeKind.F64: { value = "f64"; break; }

case TypeKind.ISIZE: { value = "isize"; break; }

case TypeKind.USIZE: { value = "usize"; break; }

case TypeKind.V128: { value = "v128"; break; }

case TypeKind.ANYREF: { value = "anyref"; break; }

default: assert(false);

case TypeKind.VOID: { value = "void"; break; }

}

}

return compiler.ensureStaticString(value);

}

// === Math ===================================================================================

case BuiltinSymbols.clz: { // clz<T?>(value: T) -> T

if (

checkTypeOptional(typeArguments, reportNode, compiler, true) |

checkArgsRequired(operands, 1, reportNode, compiler)

) return module.unreachable();

let arg0 = typeArguments

? compiler.compileExpression(operands[0], typeArguments[0], Constraints.CONV_IMPLICIT | Constraints.MUST_WRAP)

: compiler.compileExpression(operands[0], Type.i32, Constraints.MUST_WRAP);

let type = compiler.currentType;

if (!type.is(TypeFlags.REFERENCE)) {

switch (type.kind) {

case TypeKind.BOOL: // not wrapped

case TypeKind.I8:

case TypeKind.U8:

case TypeKind.I16:

case TypeKind.U16:

case TypeKind.I32:

case TypeKind.U32: return module.unary(UnaryOp.ClzI32, arg0);

case TypeKind.USIZE:

case TypeKind.ISIZE: {

return module.unary(

compiler.options.isWasm64

? UnaryOp.ClzI64

: UnaryOp.ClzI32,

arg0

);

}

case TypeKind.I64:

case TypeKind.U64: return module.unary(UnaryOp.ClzI64, arg0);

}

}

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

reportNode.typeArgumentsRange, "clz", type.toString()

);

return module.unreachable();

}

case BuiltinSymbols.ctz: { // ctz<T?>(value: T) -> T

if (

checkTypeOptional(typeArguments, reportNode, compiler, true) |

checkArgsRequired(operands, 1, reportNode, compiler)

) return module.unreachable();

let arg0 = typeArguments

? compiler.compileExpression(operands[0], typeArguments[0], Constraints.CONV_IMPLICIT | Constraints.MUST_WRAP)

: compiler.compileExpression(operands[0], Type.i32, Constraints.MUST_WRAP);

let type = compiler.currentType;

if (!type.is(TypeFlags.REFERENCE)) {

switch (type.kind) {

case TypeKind.BOOL: // not wrapped

case TypeKind.I8:

case TypeKind.U8:

case TypeKind.I16:

case TypeKind.U16:

case TypeKind.I32:

case TypeKind.U32: return module.unary(UnaryOp.CtzI32, arg0);

case TypeKind.USIZE:

case TypeKind.ISIZE: {

return module.unary(

compiler.options.isWasm64

? UnaryOp.CtzI64

: UnaryOp.CtzI32,

arg0

);

}

case TypeKind.I64:

case TypeKind.U64: return module.unary(UnaryOp.CtzI64, arg0);

}

}

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

reportNode.typeArgumentsRange, "ctz", type.toString()

);

return module.unreachable();

}

case BuiltinSymbols.popcnt: { // popcnt<T?>(value: T) -> T

if (

checkTypeOptional(typeArguments, reportNode, compiler, true) |

checkArgsRequired(operands, 1, reportNode, compiler)

) return module.unreachable();

let arg0 = typeArguments

? compiler.compileExpression(operands[0], typeArguments[0], Constraints.CONV_IMPLICIT | Constraints.MUST_WRAP)

: compiler.compileExpression(operands[0], Type.i32, Constraints.MUST_WRAP);

let type = compiler.currentType;

if (!type.is(TypeFlags.REFERENCE)) {

switch (compiler.currentType.kind) {

case TypeKind.BOOL: // not wrapped

case TypeKind.I8:

case TypeKind.U8:

case TypeKind.I16:

case TypeKind.U16:

case TypeKind.I32:

case TypeKind.U32: return module.unary(UnaryOp.PopcntI32, arg0);

case TypeKind.I64:

case TypeKind.U64: return module.unary(UnaryOp.PopcntI64, arg0);

case TypeKind.ISIZE:

case TypeKind.USIZE: {

return module.unary(

compiler.options.isWasm64

? UnaryOp.PopcntI64

: UnaryOp.PopcntI32,

arg0

);

}

}

}

compiler.error(

DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,

reportNode.typeArgumentsRange, "popcnt", type.toString()

);

return module.unreachable();

}

case BuiltinSymbols.rotl: { // rotl<T?>(value: T, shift: T) -> T

if (

checkTypeOptional(typeArguments, reportNode, compiler, true) |

checkArgsRequired(operands, 2, reportNode, compiler)

) return module.unreachable();

let arg0 = typeArguments

? compiler.compileExpression(operands[0], typeArguments[0], Constraints.CONV_IMPLICIT | Constraints.MUST_WRAP)

: compiler.compileExpression(operands[0], Type.i32, Constraints.MUST_WRAP);

let type = compiler.currentType;

if (!type.is(TypeFlags.REFERENCE)) {