Skip to content

Clean up inline-asm definitions, add i32/i64/f32/f64.div(_s/u) #1509

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Oct 16, 2020
Merged

Clean up inline-asm definitions, add i32/i64/f32/f64.div(_s/u) #1509

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
171 changes: 143 additions & 28 deletions src/builtins.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -144,6 +144,7 @@ export namespace BuiltinNames {
export const add = "~lib/builtins/add";
export const sub = "~lib/builtins/sub";
export const mul = "~lib/builtins/mul";
export const div = "~lib/builtins/div";
export const clz = "~lib/builtins/clz";
export const ctz = "~lib/builtins/ctz";
export const popcnt = "~lib/builtins/popcnt";
Expand Down Expand Up @@ -249,6 +250,12 @@ export namespace BuiltinNames {
export const i64_mul = "~lib/builtins/i64.mul";
export const f32_mul = "~lib/builtins/f32.mul";
export const f64_mul = "~lib/builtins/f64.mul";
export const i32_div_s = "~lib/builtins/i32.div_s";
export const i32_div_u = "~lib/builtins/i32.div_u";
export const i64_div_s = "~lib/builtins/i64.div_s";
export const i64_div_u = "~lib/builtins/i64.div_u";
export const f32_div = "~lib/builtins/f32.div";
export const f64_div = "~lib/builtins/f64.div";

export const i32_load8_s = "~lib/builtins/i32.load8_s";
export const i32_load8_u = "~lib/builtins/i32.load8_u";
Expand Down Expand Up @@ -2293,6 +2300,60 @@ function builtin_mul(ctx: BuiltinContext): ExpressionRef {
}
builtins.set(BuiltinNames.mul, builtin_mul);

// div<T?>(left: T, right: T) -> T
function builtin_div(ctx: BuiltinContext): ExpressionRef {
var compiler = ctx.compiler;
var module = compiler.module;
if (checkTypeOptional(ctx, true) | checkArgsRequired(ctx, 2)) {
return module.unreachable();
}
var operands = ctx.operands;
var typeArguments = ctx.typeArguments;
var left = operands[0];
var arg0 = typeArguments
? compiler.compileExpression(
left,
typeArguments[0],
Constraints.CONV_IMPLICIT
)
: compiler.compileExpression(operands[0], Type.auto);
var type = compiler.currentType;
if (type.isValue) {
let arg1: ExpressionRef;
if (!typeArguments && left.isNumericLiteral) {
// prefer right type
arg1 = compiler.compileExpression(
operands[1],
type
);
if (compiler.currentType != type) {
arg0 = compiler.compileExpression(
left,
(type = compiler.currentType),
Constraints.CONV_IMPLICIT
);
}
} else {
arg1 = compiler.compileExpression(
operands[1],
type,
Constraints.CONV_IMPLICIT
);
}
if (type.isNumericValue) {
return compiler.makeDiv(arg0, arg1, type);
}
}
compiler.error(
DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,
ctx.reportNode.typeArgumentsRange,
"div",
type.toString()
);
return module.unreachable();
}
builtins.set(BuiltinNames.div, builtin_div);

// === Atomics ================================================================================

// atomic.load<T!>(offset: usize, immOffset?: usize) -> T*
Expand Down Expand Up @@ -5822,6 +5883,24 @@ function builtin_i64_add(ctx: BuiltinContext): ExpressionRef {
}
builtins.set(BuiltinNames.i64_add, builtin_i64_add);

// f32.add -> add<f32>
function builtin_f32_add(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f32 ];
ctx.contextualType = Type.f32;
return builtin_add(ctx);
}
builtins.set(BuiltinNames.f32_add, builtin_f32_add);

// f64.add -> add<f64>
function builtin_f64_add(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f64 ];
ctx.contextualType = Type.f64;
return builtin_add(ctx);
}
builtins.set(BuiltinNames.f64_add, builtin_f64_add);

// i32.sub -> sub<i32>
function builtin_i32_sub(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
Expand All @@ -5840,6 +5919,24 @@ function builtin_i64_sub(ctx: BuiltinContext): ExpressionRef {
}
builtins.set(BuiltinNames.i64_sub, builtin_i64_sub);

// f32.sub -> sub<f32>
function builtin_f32_sub(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f32 ];
ctx.contextualType = Type.f32;
return builtin_sub(ctx);
}
builtins.set(BuiltinNames.f32_sub, builtin_f32_sub);

// f64.sub -> sub<f64>
function builtin_f64_sub(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f64 ];
ctx.contextualType = Type.f64;
return builtin_sub(ctx);
}
builtins.set(BuiltinNames.f64_sub, builtin_f64_sub);

// i32.mul -> mul<i32>
function builtin_i32_mul(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
Expand All @@ -5858,59 +5955,77 @@ function builtin_i64_mul(ctx: BuiltinContext): ExpressionRef {
}
builtins.set(BuiltinNames.i64_mul, builtin_i64_mul);

// f32.add -> add<f32>
function builtin_f32_add(ctx: BuiltinContext): ExpressionRef {
// f32.mul -> mul<f32>
function builtin_f32_mul(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f32 ];
ctx.contextualType = Type.f32;
return builtin_add(ctx);
return builtin_mul(ctx);
}
builtins.set(BuiltinNames.f32_add, builtin_f32_add);
builtins.set(BuiltinNames.f32_mul, builtin_f32_mul);

// f64.add -> add<f64>
function builtin_f64_add(ctx: BuiltinContext): ExpressionRef {
// f64.mul -> mul<f64>
function builtin_f64_mul(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f64 ];
ctx.contextualType = Type.f64;
return builtin_add(ctx);
return builtin_mul(ctx);
}
builtins.set(BuiltinNames.f64_add, builtin_f64_add);
builtins.set(BuiltinNames.f64_mul, builtin_f64_mul);

// f32.sub -> sub<f32>
function builtin_f32_sub(ctx: BuiltinContext): ExpressionRef {
// i32.div_s -> div<i32>
function builtin_i32_div_s(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f32 ];
ctx.contextualType = Type.f32;
return builtin_sub(ctx);
ctx.typeArguments = [ Type.i32 ];
ctx.contextualType = Type.i32;
return builtin_div(ctx);
}
builtins.set(BuiltinNames.f32_sub, builtin_f32_sub);
builtins.set(BuiltinNames.i32_div_s, builtin_i32_div_s);

// f64.sub -> sub<f64>
function builtin_f64_sub(ctx: BuiltinContext): ExpressionRef {
// i32.div_u -> div<u32>
function builtin_i32_div_u(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f64 ];
ctx.contextualType = Type.f64;
return builtin_sub(ctx);
ctx.typeArguments = [ Type.u32 ];
ctx.contextualType = Type.u32;
return builtin_div(ctx);
}
builtins.set(BuiltinNames.f64_sub, builtin_f64_sub);
builtins.set(BuiltinNames.i32_div_u, builtin_i32_div_u);

// f32.mul -> mul<f32>
function builtin_f32_mul(ctx: BuiltinContext): ExpressionRef {
// i64.div_s -> div_s<i64>
function builtin_i64_div_s(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.i64 ];
ctx.contextualType = Type.i64;
return builtin_div(ctx);
}
builtins.set(BuiltinNames.i64_div_s, builtin_i64_div_s);

// i64.div_u -> div_u<u64>
function builtin_i64_div_u(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.u64 ];
ctx.contextualType = Type.u64;
return builtin_div(ctx);
}
builtins.set(BuiltinNames.i64_div_u, builtin_i64_div_u);

// f32.div -> div<f32>
function builtin_f32_div(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f32 ];
ctx.contextualType = Type.f32;
return builtin_mul(ctx);
return builtin_div(ctx);
}
builtins.set(BuiltinNames.f32_mul, builtin_f32_mul);
builtins.set(BuiltinNames.f32_div, builtin_f32_div);

// f64.mul -> mul<f64>
function builtin_f64_mul(ctx: BuiltinContext): ExpressionRef {
// f64.div -> div<f64>
function builtin_f64_div(ctx: BuiltinContext): ExpressionRef {
checkTypeAbsent(ctx);
ctx.typeArguments = [ Type.f64 ];
ctx.contextualType = Type.f64;
return builtin_mul(ctx);
return builtin_div(ctx);
}
builtins.set(BuiltinNames.f64_mul, builtin_f64_mul);
builtins.set(BuiltinNames.f64_div, builtin_f64_div);

// i32.load8_s -> <i32>load<i8>
function builtin_i32_load8_s(ctx: BuiltinContext): ExpressionRef {
Expand Down
34 changes: 31 additions & 3 deletions std/assembly/builtins.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -132,6 +132,10 @@ export declare function sub<T>(left: T, right: T): T;
@builtin
export declare function mul<T>(left: T, right: T): T;

// @ts-ignore: decorator
@builtin
export declare function div<T>(left: T, right: T): T;

// @ts-ignore: decorator
@unsafe @builtin
export declare function load<T>(ptr: usize, immOffset?: usize, immAlign?: usize): T;
Expand Down Expand Up @@ -314,6 +318,14 @@ export namespace i32 {
@builtin
export declare function mul(left: i32, right:i32): i32;

// @ts-ignore: decorator
@builtin
export declare function div_s(left: i32, right:i32): i32;

// @ts-ignore: decorator
@builtin
export declare function div_u(left: i32, right:i32): i32;

// @ts-ignore: decorator
@builtin
export declare function rotl(value: i32, shift: i32): i32;
Expand Down Expand Up @@ -515,7 +527,15 @@ export namespace i64 {

// @ts-ignore: decorator
@builtin
export declare function mul(left: i64, right:i64): i64;
export declare function mul(left: i64, right:i64): i64;

// @ts-ignore: decorator
@builtin
export declare function div_s(left: i64, right:i64): i64;

// @ts-ignore: decorator
@builtin
export declare function div_u(left: i64, right:i64): i64;

// @ts-ignore: decorator
@builtin
Expand Down Expand Up @@ -952,7 +972,11 @@ export namespace f32 {

// @ts-ignore: decorator
@builtin
export declare function mul(left: f32, right: f32): f32;
export declare function mul(left: f32, right: f32): f32;

// @ts-ignore: decorator
@builtin
export declare function div(left: f32, right: f32): f32;
}

// @ts-ignore: decorator
Expand Down Expand Up @@ -1055,7 +1079,11 @@ export namespace f64 {

// @ts-ignore: decorator
@builtin
export declare function mul(left: f64, right: f64): f64;
export declare function mul(left: f64, right: f64): f64;

// @ts-ignore: decorator
@builtin
export declare function div(left: f64, right: f64): f64;
}

// @ts-ignore: decorator
Expand Down
Loading