paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-27 17:53:43 +02:00
Code Issues Packages Projects Releases Wiki Activity
0c61c7057a
fpc/compiler/wasm32/nwasminl.pas

1091 lines
44 KiB
ObjectPascal
Raw Blame History

{
Copyright (c) 1998-2002, 2021 by Florian Klaempfl and Nikolay Nikolov
Generate WebAssembly inline nodes
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
****************************************************************************
}
unit nwasminl;
{$i fpcdefs.inc}
interface
uses
node,ncginl,cpubase;
type
{ twasminlinenode }
twasminlinenode = class(tcginlinenode)
private
function first_abs_real:tnode;override;
function first_int_real:tnode;override;
function first_sqrt_real:tnode;override;
function first_trunc_real:tnode;override;
function first_round_real:tnode;override;
function first_popcnt:tnode;override;
procedure second_abs_real;override;
procedure second_int_real;override;
procedure second_sqrt_real;override;
procedure second_trunc_real;override;
procedure second_round_real;override;
procedure second_high; override;
procedure second_popcnt;override;
procedure second_memory_size;
procedure second_memory_grow;
procedure second_memory_fill;
procedure second_memory_copy;
procedure second_unreachable;
procedure second_throw_fpcexception;
procedure second_atomic_fence;
procedure second_atomic_load(op: TAsmOp);
procedure second_atomic_store(op: TAsmOp);
procedure second_atomic_rmw_x_y(op: TAsmOp);
procedure second_atomic_rmw_x_y_z(op: TAsmOp);
procedure second_tls_get(const SymStr: string);
procedure second_set_base_pointer;
protected
function first_sqr_real: tnode; override;
public
function pass_typecheck_cpu: tnode; override;
function first_cpu: tnode; override;
procedure pass_generate_code_cpu; override;
procedure second_length;override;
procedure second_sqr_real; override;
end;
implementation
uses
procinfo,
ninl,ncal,compinnr,
aasmbase,aasmdata,aasmcpu,
cgbase,cgutils,
hlcgobj,hlcgcpu,
defutil,pass_2,verbose,
symtype,symdef,symcpu,
tgobj,tgcpu;
{*****************************************************************************
twasminlinenode
*****************************************************************************}
function twasminlinenode.first_abs_real: tnode;
begin
expectloc:=LOC_FPUREGISTER;
result:=nil;
end;
function twasminlinenode.first_int_real: tnode;
begin
expectloc:=LOC_FPUREGISTER;
result:=nil;
end;
function twasminlinenode.first_sqrt_real: tnode;
begin
expectloc:=LOC_FPUREGISTER;
result:=nil;
end;
function twasminlinenode.first_trunc_real: tnode;
begin
expectloc:=LOC_REGISTER;
result:=nil;
end;
function twasminlinenode.first_round_real: tnode;
begin
expectloc:=LOC_REGISTER;
result:=nil;
end;
function twasminlinenode.first_popcnt: tnode;
begin
expectloc:=LOC_REGISTER;
result:=nil;
end;
procedure twasminlinenode.second_abs_real;
begin
secondpass(left);
hlcg.location_force_fpureg(current_asmdata.CurrAsmList,left.location,left.resultdef,true);
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
case left.location.size of
OS_F32:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f32_abs));
OS_F64:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f64_abs));
else
internalerror(2021092902);
end;
location_reset(location,LOC_FPUREGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_int_real;
begin
secondpass(left);
hlcg.location_force_fpureg(current_asmdata.CurrAsmList,left.location,left.resultdef,true);
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
case left.location.size of
OS_F32:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f32_trunc));
OS_F64:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f64_trunc));
else
internalerror(2021092903);
end;
location_reset(location,LOC_FPUREGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_sqrt_real;
begin
secondpass(left);
hlcg.location_force_fpureg(current_asmdata.CurrAsmList,left.location,left.resultdef,true);
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
case left.location.size of
OS_F32:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f32_sqrt));
OS_F64:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f64_sqrt));
else
internalerror(2021092901);
end;
location_reset(location,LOC_FPUREGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_trunc_real;
begin
secondpass(left);
hlcg.location_force_fpureg(current_asmdata.CurrAsmList,left.location,left.resultdef,true);
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
case left.location.size of
OS_F32:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_i64_trunc_f32_s));
OS_F64:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_i64_trunc_f64_s));
else
internalerror(2021092904);
end;
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_round_real;
begin
secondpass(left);
hlcg.location_force_fpureg(current_asmdata.CurrAsmList,left.location,left.resultdef,true);
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
case left.location.size of
OS_F32:
begin
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f32_nearest));
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_i64_trunc_f32_s));
end;
OS_F64:
begin
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f64_nearest));
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_i64_trunc_f64_s));
end
else
internalerror(2021092905);
end;
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_high;
var
hightype: TWasmBasicType;
begin
secondpass(left);
if not(is_dynamic_array(left.resultdef)) then
Internalerror(2019122801);
{ determine the WasmBasicType of the result }
if is_64bit(resultdef) then
hightype:=wbt_i64
else
hightype:=wbt_i32;
{ length in dynamic arrays is at offset -sizeof(pint) }
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
{ 64-bit pointer values need a <>0 comparison to produce a 32-bit int on the stack (0 or 1) for the 'if' instruction.
32-bit pointer values don't need it, because 'if' already expects and pops a 32-bit int and checks for <>0. }
if is_64bit(left.resultdef) then
begin
thlcgwasm(hlcg).a_load_const_stack(current_asmdata.CurrAsmList,left.resultdef,0,R_INTREGISTER);
thlcgwasm(hlcg).a_cmp_stack_stack(current_asmdata.CurrAsmList,left.resultdef,OC_NE);
end;
{ if not nil }
current_asmdata.CurrAsmList.Concat(taicpu.op_functype(a_if,TWasmFuncType.Create([],[hightype])));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,1);
{ volatility of the dyn. array refers to the volatility of the
string pointer, not of the string data }
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
{ length in dynamic arrays is at offset -ossinttype.size }
thlcgwasm(hlcg).a_op_const_stack(current_asmdata.CurrAsmList,OP_SUB,left.resultdef,ossinttype.size);
{ load length }
if ossinttype.size=8 then
current_asmdata.CurrAsmList.Concat(taicpu.op_const(a_i64_load,0))
else
current_asmdata.CurrAsmList.Concat(taicpu.op_const(a_i32_load,0));
{ else }
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_else));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,1);
{ high=-1 }
thlcgwasm(hlcg).a_load_const_stack(current_asmdata.CurrAsmList,resultdef,-1,R_INTREGISTER);
{ endif }
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_end_if));
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
{$if not defined(cpu64bitalu) and not defined(cpuhighleveltarget)}
if location.size in [OS_64,OS_S64] then
begin
location.register64.reglo := cg.getintregister(current_asmdata.CurrAsmList,OS_32);
location.register64.reghi := cg.getintregister(current_asmdata.CurrAsmList,OS_32);
end
else
{$endif}
location.register := hlcg.getintregister(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_popcnt;
begin
secondpass(left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,left.location,left.resultdef,left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,left.resultdef,left.location.register);
if is_64bit(left.resultdef) then
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_i64_popcnt))
else
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_i32_popcnt));
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_memory_size;
begin
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_memory_size));
thlcgwasm(hlcg).incstack(current_asmdata.CurrAsmList,1);
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_memory_grow;
begin
secondpass(left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,left.location,left.resultdef,left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,left.resultdef,left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_memory_grow));
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_memory_fill;
begin
location_reset(location,LOC_VOID,OS_NO);
secondpass(tcallparanode(tcallparanode(tcallparanode(left).right).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.location,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.location.register);
secondpass(tcallparanode(tcallparanode(left).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.location,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.location.register);
secondpass(tcallparanode(left).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(left).left.location,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_memory_fill));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,3);
end;
procedure twasminlinenode.second_memory_copy;
begin
location_reset(location,LOC_VOID,OS_NO);
secondpass(tcallparanode(tcallparanode(tcallparanode(left).right).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.location,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.location.register);
secondpass(tcallparanode(tcallparanode(left).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.location,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.location.register);
secondpass(tcallparanode(left).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(left).left.location,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_memory_copy));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,3);
end;
procedure twasminlinenode.second_unreachable;
begin
location_reset(location,LOC_VOID,OS_NO);
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_unreachable));
end;
procedure twasminlinenode.second_throw_fpcexception;
begin
location_reset(location,LOC_VOID,OS_NO);
current_asmdata.CurrAsmList.Concat(taicpu.op_sym(a_throw,current_asmdata.WeakRefAsmSymbol(FPC_EXCEPTION_TAG_SYM,AT_WASM_EXCEPTION_TAG)));
end;
procedure twasminlinenode.second_atomic_fence;
begin
location_reset(location,LOC_VOID,OS_NO);
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_atomic_fence));
end;
procedure twasminlinenode.second_atomic_load(op: TAsmOp);
begin
secondpass(left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,left.location,left.resultdef,left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,left.resultdef,left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_const(op,0));
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_atomic_store(op: TAsmOp);
begin
location_reset(location,LOC_VOID,OS_NO);
secondpass(tcallparanode(tcallparanode(left).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.location,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.location.register);
secondpass(tcallparanode(left).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(left).left.location,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_const(op,0));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,2);
end;
procedure twasminlinenode.second_atomic_rmw_x_y(op: TAsmOp);
begin
secondpass(tcallparanode(tcallparanode(left).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.location,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.location.register);
secondpass(tcallparanode(left).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(left).left.location,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_const(op,0));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,1);
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_atomic_rmw_x_y_z(op: TAsmOp);
begin
secondpass(tcallparanode(tcallparanode(tcallparanode(left).right).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.location,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.resultdef,
tcallparanode(tcallparanode(tcallparanode(left).right).right).left.location.register);
secondpass(tcallparanode(tcallparanode(left).right).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.location,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(tcallparanode(left).right).left.resultdef,
tcallparanode(tcallparanode(left).right).left.location.register);
secondpass(tcallparanode(left).left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,
tcallparanode(left).left.location,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,
tcallparanode(left).left.resultdef,
tcallparanode(left).left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_const(op,0));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,2);
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_tls_get(const SymStr: string);
var
sym: TWasmGlobalAsmSymbol;
begin
sym:=TWasmGlobalAsmSymbol(current_asmdata.RefAsmSymbolByClass(TWasmGlobalAsmSymbol,SymStr,AT_WASM_GLOBAL));
sym.WasmGlobalType:=wbt_i32;
current_asmdata.CurrAsmList.Concat(taicpu.op_sym(a_global_get,sym));
thlcgwasm(hlcg).incstack(current_asmdata.CurrAsmList,1);
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
procedure twasminlinenode.second_set_base_pointer;
var
pd: tcpuprocdef;
begin
location_reset(location,LOC_VOID,OS_NO);
secondpass(left);
hlcg.location_force_reg(current_asmdata.CurrAsmList,left.location,left.resultdef,left.resultdef,false);
thlcgwasm(hlcg).a_load_reg_stack(current_asmdata.CurrAsmList,left.resultdef,left.location.register);
pd:=tcpuprocdef(current_procinfo.procdef);
if pd.base_pointer_ref.base<>NR_LOCAL_STACK_POINTER_REG then
ttgwasm(tg).allocbasepointer(current_asmdata.CurrAsmList,pd.base_pointer_ref);
current_asmdata.CurrAsmList.Concat(taicpu.op_ref(a_local_set,pd.base_pointer_ref));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,1);
end;
function twasminlinenode.first_sqr_real: tnode;
begin
expectloc:=LOC_FPUREGISTER;
first_sqr_real:=nil;
end;
function twasminlinenode.pass_typecheck_cpu: tnode;
begin
Result:=nil;
case inlinenumber of
in_wasm32_set_base_pointer:
begin
CheckParameters(1);
resultdef:=voidtype;
end;
in_wasm32_memory_size:
begin
CheckParameters(0);
resultdef:=u32inttype;
end;
in_wasm32_memory_grow:
begin
CheckParameters(1);
resultdef:=u32inttype;
end;
in_wasm32_unreachable:
begin
CheckParameters(0);
resultdef:=voidtype;
end;
in_wasm32_throw_fpcexception:
begin
CheckParameters(0);
resultdef:=voidtype;
end;
in_wasm32_memory_fill:
begin
CheckParameters(3);
resultdef:=voidtype;
end;
in_wasm32_memory_copy:
begin
CheckParameters(3);
resultdef:=voidtype;
end;
in_wasm32_atomic_fence:
begin
CheckParameters(0);
resultdef:=voidtype;
end;
in_wasm32_i32_atomic_rmw8_add_u,
in_wasm32_i32_atomic_rmw16_add_u,
in_wasm32_i32_atomic_rmw_add,
in_wasm32_i32_atomic_rmw8_sub_u,
in_wasm32_i32_atomic_rmw16_sub_u,
in_wasm32_i32_atomic_rmw_sub,
in_wasm32_i32_atomic_rmw8_and_u,
in_wasm32_i32_atomic_rmw16_and_u,
in_wasm32_i32_atomic_rmw_and,
in_wasm32_i32_atomic_rmw8_or_u,
in_wasm32_i32_atomic_rmw16_or_u,
in_wasm32_i32_atomic_rmw_or,
in_wasm32_i32_atomic_rmw8_xor_u,
in_wasm32_i32_atomic_rmw16_xor_u,
in_wasm32_i32_atomic_rmw_xor,
in_wasm32_i32_atomic_rmw8_xchg_u,
in_wasm32_i32_atomic_rmw16_xchg_u,
in_wasm32_i32_atomic_rmw_xchg:
begin
CheckParameters(2);
resultdef:=u32inttype;
end;
in_wasm32_i64_atomic_rmw8_add_u,
in_wasm32_i64_atomic_rmw16_add_u,
in_wasm32_i64_atomic_rmw32_add_u,
in_wasm32_i64_atomic_rmw_add,
in_wasm32_i64_atomic_rmw8_sub_u,
in_wasm32_i64_atomic_rmw16_sub_u,
in_wasm32_i64_atomic_rmw32_sub_u,
in_wasm32_i64_atomic_rmw_sub,
in_wasm32_i64_atomic_rmw8_and_u,
in_wasm32_i64_atomic_rmw16_and_u,
in_wasm32_i64_atomic_rmw32_and_u,
in_wasm32_i64_atomic_rmw_and,
in_wasm32_i64_atomic_rmw8_or_u,
in_wasm32_i64_atomic_rmw16_or_u,
in_wasm32_i64_atomic_rmw32_or_u,
in_wasm32_i64_atomic_rmw_or,
in_wasm32_i64_atomic_rmw8_xor_u,
in_wasm32_i64_atomic_rmw16_xor_u,
in_wasm32_i64_atomic_rmw32_xor_u,
in_wasm32_i64_atomic_rmw_xor,
in_wasm32_i64_atomic_rmw8_xchg_u,
in_wasm32_i64_atomic_rmw16_xchg_u,
in_wasm32_i64_atomic_rmw32_xchg_u,
in_wasm32_i64_atomic_rmw_xchg:
begin
CheckParameters(2);
resultdef:=u64inttype;
end;
in_wasm32_i32_atomic_rmw8_cmpxchg_u,
in_wasm32_i32_atomic_rmw16_cmpxchg_u,
in_wasm32_i32_atomic_rmw_cmpxchg:
begin
CheckParameters(3);
resultdef:=u32inttype;
end;
in_wasm32_i64_atomic_rmw8_cmpxchg_u,
in_wasm32_i64_atomic_rmw16_cmpxchg_u,
in_wasm32_i64_atomic_rmw32_cmpxchg_u,
in_wasm32_i64_atomic_rmw_cmpxchg:
begin
CheckParameters(3);
resultdef:=u64inttype;
end;
in_wasm32_memory_atomic_wait32,
in_wasm32_memory_atomic_wait64:
begin
CheckParameters(3);
resultdef:=s32inttype;
end;
in_wasm32_memory_atomic_notify:
begin
CheckParameters(2);
resultdef:=u32inttype;
end;
in_i32_atomic_load8_u,
in_i32_atomic_load16_u,
in_i32_atomic_load:
begin
CheckParameters(1);
resultdef:=u32inttype;
end;
in_i64_atomic_load8_u,
in_i64_atomic_load16_u,
in_i64_atomic_load32_u,
in_i64_atomic_load:
begin
CheckParameters(1);
resultdef:=u64inttype;
end;
in_i32_atomic_store8,
in_i32_atomic_store16,
in_i32_atomic_store,
in_i64_atomic_store8,
in_i64_atomic_store16,
in_i64_atomic_store32,
in_i64_atomic_store:
begin
CheckParameters(2);
resultdef:=voidtype;
end;
in_wasm32_tls_size,
in_wasm32_tls_align:
begin
CheckParameters(0);
resultdef:=u32inttype;
end;
in_wasm32_tls_base:
begin
CheckParameters(0);
resultdef:=voidpointertype;
end;
else
Result:=inherited pass_typecheck_cpu;
end;
end;
function twasminlinenode.first_cpu: tnode;
begin
Result:=nil;
case inlinenumber of
in_wasm32_memory_size,
in_wasm32_memory_grow:
expectloc:=LOC_REGISTER;
in_wasm32_set_base_pointer,
in_wasm32_memory_fill,
in_wasm32_memory_copy,
in_wasm32_unreachable,
in_wasm32_throw_fpcexception,
in_wasm32_atomic_fence,
in_i32_atomic_store8,
in_i32_atomic_store16,
in_i32_atomic_store,
in_i64_atomic_store8,
in_i64_atomic_store16,
in_i64_atomic_store32,
in_i64_atomic_store:
expectloc:=LOC_VOID;
in_wasm32_i32_atomic_rmw8_add_u,
in_wasm32_i32_atomic_rmw16_add_u,
in_wasm32_i32_atomic_rmw_add,
in_wasm32_i64_atomic_rmw8_add_u,
in_wasm32_i64_atomic_rmw16_add_u,
in_wasm32_i64_atomic_rmw32_add_u,
in_wasm32_i64_atomic_rmw_add,
in_wasm32_i32_atomic_rmw8_sub_u,
in_wasm32_i32_atomic_rmw16_sub_u,
in_wasm32_i32_atomic_rmw_sub,
in_wasm32_i64_atomic_rmw8_sub_u,
in_wasm32_i64_atomic_rmw16_sub_u,
in_wasm32_i64_atomic_rmw32_sub_u,
in_wasm32_i64_atomic_rmw_sub,
in_wasm32_i32_atomic_rmw8_and_u,
in_wasm32_i32_atomic_rmw16_and_u,
in_wasm32_i32_atomic_rmw_and,
in_wasm32_i64_atomic_rmw8_and_u,
in_wasm32_i64_atomic_rmw16_and_u,
in_wasm32_i64_atomic_rmw32_and_u,
in_wasm32_i64_atomic_rmw_and,
in_wasm32_i32_atomic_rmw8_or_u,
in_wasm32_i32_atomic_rmw16_or_u,
in_wasm32_i32_atomic_rmw_or,
in_wasm32_i64_atomic_rmw8_or_u,
in_wasm32_i64_atomic_rmw16_or_u,
in_wasm32_i64_atomic_rmw32_or_u,
in_wasm32_i64_atomic_rmw_or,
in_wasm32_i32_atomic_rmw8_xor_u,
in_wasm32_i32_atomic_rmw16_xor_u,
in_wasm32_i32_atomic_rmw_xor,
in_wasm32_i64_atomic_rmw8_xor_u,
in_wasm32_i64_atomic_rmw16_xor_u,
in_wasm32_i64_atomic_rmw32_xor_u,
in_wasm32_i64_atomic_rmw_xor,
in_wasm32_i32_atomic_rmw8_xchg_u,
in_wasm32_i32_atomic_rmw16_xchg_u,
in_wasm32_i32_atomic_rmw_xchg,
in_wasm32_i64_atomic_rmw8_xchg_u,
in_wasm32_i64_atomic_rmw16_xchg_u,
in_wasm32_i64_atomic_rmw32_xchg_u,
in_wasm32_i64_atomic_rmw_xchg,
in_wasm32_i32_atomic_rmw8_cmpxchg_u,
in_wasm32_i32_atomic_rmw16_cmpxchg_u,
in_wasm32_i32_atomic_rmw_cmpxchg,
in_wasm32_i64_atomic_rmw8_cmpxchg_u,
in_wasm32_i64_atomic_rmw16_cmpxchg_u,
in_wasm32_i64_atomic_rmw32_cmpxchg_u,
in_wasm32_i64_atomic_rmw_cmpxchg,
in_wasm32_memory_atomic_wait32,
in_wasm32_memory_atomic_wait64,
in_wasm32_memory_atomic_notify,
in_i32_atomic_load8_u,
in_i32_atomic_load16_u,
in_i32_atomic_load,
in_i64_atomic_load8_u,
in_i64_atomic_load16_u,
in_i64_atomic_load32_u,
in_i64_atomic_load,
in_wasm32_tls_size,
in_wasm32_tls_align,
in_wasm32_tls_base:
expectloc:=LOC_REGISTER;
else
Result:=inherited first_cpu;
end;
end;
procedure twasminlinenode.pass_generate_code_cpu;
begin
case inlinenumber of
in_wasm32_memory_size:
second_memory_size;
in_wasm32_memory_grow:
second_memory_grow;
in_wasm32_memory_fill:
second_memory_fill;
in_wasm32_memory_copy:
second_memory_copy;
in_wasm32_unreachable:
second_unreachable;
in_wasm32_throw_fpcexception:
second_throw_fpcexception;
in_wasm32_atomic_fence:
second_atomic_fence;
in_wasm32_i32_atomic_rmw8_add_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw8_add_u);
in_wasm32_i32_atomic_rmw16_add_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw16_add_u);
in_wasm32_i32_atomic_rmw_add:
second_atomic_rmw_x_y(a_i32_atomic_rmw_add);
in_wasm32_i64_atomic_rmw8_add_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw8_add_u);
in_wasm32_i64_atomic_rmw16_add_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw16_add_u);
in_wasm32_i64_atomic_rmw32_add_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw32_add_u);
in_wasm32_i64_atomic_rmw_add:
second_atomic_rmw_x_y(a_i64_atomic_rmw_add);
in_wasm32_i32_atomic_rmw8_sub_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw8_sub_u);
in_wasm32_i32_atomic_rmw16_sub_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw16_sub_u);
in_wasm32_i32_atomic_rmw_sub:
second_atomic_rmw_x_y(a_i32_atomic_rmw_sub);
in_wasm32_i64_atomic_rmw8_sub_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw8_sub_u);
in_wasm32_i64_atomic_rmw16_sub_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw16_sub_u);
in_wasm32_i64_atomic_rmw32_sub_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw32_sub_u);
in_wasm32_i64_atomic_rmw_sub:
second_atomic_rmw_x_y(a_i64_atomic_rmw_sub);
in_wasm32_i32_atomic_rmw8_and_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw8_and_u);
in_wasm32_i32_atomic_rmw16_and_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw16_and_u);
in_wasm32_i32_atomic_rmw_and:
second_atomic_rmw_x_y(a_i32_atomic_rmw_and);
in_wasm32_i64_atomic_rmw8_and_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw8_and_u);
in_wasm32_i64_atomic_rmw16_and_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw16_and_u);
in_wasm32_i64_atomic_rmw32_and_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw32_and_u);
in_wasm32_i64_atomic_rmw_and:
second_atomic_rmw_x_y(a_i64_atomic_rmw_and);
in_wasm32_i32_atomic_rmw8_or_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw8_or_u);
in_wasm32_i32_atomic_rmw16_or_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw16_or_u);
in_wasm32_i32_atomic_rmw_or:
second_atomic_rmw_x_y(a_i32_atomic_rmw_or);
in_wasm32_i64_atomic_rmw8_or_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw8_or_u);
in_wasm32_i64_atomic_rmw16_or_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw16_or_u);
in_wasm32_i64_atomic_rmw32_or_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw32_or_u);
in_wasm32_i64_atomic_rmw_or:
second_atomic_rmw_x_y(a_i64_atomic_rmw_or);
in_wasm32_i32_atomic_rmw8_xor_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw8_xor_u);
in_wasm32_i32_atomic_rmw16_xor_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw16_xor_u);
in_wasm32_i32_atomic_rmw_xor:
second_atomic_rmw_x_y(a_i32_atomic_rmw_xor);
in_wasm32_i64_atomic_rmw8_xor_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw8_xor_u);
in_wasm32_i64_atomic_rmw16_xor_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw16_xor_u);
in_wasm32_i64_atomic_rmw32_xor_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw32_xor_u);
in_wasm32_i64_atomic_rmw_xor:
second_atomic_rmw_x_y(a_i64_atomic_rmw_xor);
in_wasm32_i32_atomic_rmw8_xchg_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw8_xchg_u);
in_wasm32_i32_atomic_rmw16_xchg_u:
second_atomic_rmw_x_y(a_i32_atomic_rmw16_xchg_u);
in_wasm32_i32_atomic_rmw_xchg:
second_atomic_rmw_x_y(a_i32_atomic_rmw_xchg);
in_wasm32_i64_atomic_rmw8_xchg_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw8_xchg_u);
in_wasm32_i64_atomic_rmw16_xchg_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw16_xchg_u);
in_wasm32_i64_atomic_rmw32_xchg_u:
second_atomic_rmw_x_y(a_i64_atomic_rmw32_xchg_u);
in_wasm32_i64_atomic_rmw_xchg:
second_atomic_rmw_x_y(a_i64_atomic_rmw_xchg);
in_wasm32_i32_atomic_rmw8_cmpxchg_u:
second_atomic_rmw_x_y_z(a_i32_atomic_rmw8_cmpxchg_u);
in_wasm32_i32_atomic_rmw16_cmpxchg_u:
second_atomic_rmw_x_y_z(a_i32_atomic_rmw16_cmpxchg_u);
in_wasm32_i32_atomic_rmw_cmpxchg:
second_atomic_rmw_x_y_z(a_i32_atomic_rmw_cmpxchg);
in_wasm32_i64_atomic_rmw8_cmpxchg_u:
second_atomic_rmw_x_y_z(a_i64_atomic_rmw8_cmpxchg_u);
in_wasm32_i64_atomic_rmw16_cmpxchg_u:
second_atomic_rmw_x_y_z(a_i64_atomic_rmw16_cmpxchg_u);
in_wasm32_i64_atomic_rmw32_cmpxchg_u:
second_atomic_rmw_x_y_z(a_i64_atomic_rmw32_cmpxchg_u);
in_wasm32_i64_atomic_rmw_cmpxchg:
second_atomic_rmw_x_y_z(a_i64_atomic_rmw_cmpxchg);
in_wasm32_memory_atomic_wait32:
second_atomic_rmw_x_y_z(a_memory_atomic_wait32);
in_wasm32_memory_atomic_wait64:
second_atomic_rmw_x_y_z(a_memory_atomic_wait64);
in_wasm32_memory_atomic_notify:
second_atomic_rmw_x_y(a_memory_atomic_notify);
in_i32_atomic_load8_u:
second_atomic_load(a_i32_atomic_load8_u);
in_i32_atomic_load16_u:
second_atomic_load(a_i32_atomic_load16_u);
in_i32_atomic_load:
second_atomic_load(a_i32_atomic_load);
in_i64_atomic_load8_u:
second_atomic_load(a_i64_atomic_load8_u);
in_i64_atomic_load16_u:
second_atomic_load(a_i64_atomic_load16_u);
in_i64_atomic_load32_u:
second_atomic_load(a_i64_atomic_load32_u);
in_i64_atomic_load:
second_atomic_load(a_i64_atomic_load);
in_i32_atomic_store8:
second_atomic_store(a_i32_atomic_store8);
in_i32_atomic_store16:
second_atomic_store(a_i32_atomic_store16);
in_i32_atomic_store:
second_atomic_store(a_i32_atomic_store);
in_i64_atomic_store8:
second_atomic_store(a_i64_atomic_store8);
in_i64_atomic_store16:
second_atomic_store(a_i64_atomic_store16);
in_i64_atomic_store32:
second_atomic_store(a_i64_atomic_store32);
in_i64_atomic_store:
second_atomic_store(a_i64_atomic_store);
in_wasm32_tls_size:
second_tls_get(TLS_SIZE_SYM);
in_wasm32_tls_align:
second_tls_get(TLS_ALIGN_SYM);
in_wasm32_tls_base:
second_tls_get(TLS_BASE_SYM);
in_wasm32_set_base_pointer:
second_set_base_pointer;
else
inherited pass_generate_code_cpu;
end;
end;
procedure twasminlinenode.second_length;
var
lendef : tdef;
href : treference;
extra_slots: LongInt;
begin
secondpass(left);
if is_shortstring(left.resultdef) then
begin
location_copy(location,left.location);
location.size:=OS_8;
end
else
begin
{ length in ansi/wide strings and high in dynamic arrays is at offset -sizeof(pint) }
hlcg.location_force_reg(current_asmdata.CurrAsmList,left.location,left.resultdef,left.resultdef,false);
thlcgwasm(hlcg).a_cmp_const_reg_stack(current_asmdata.CurrAsmList,left.resultdef,OC_EQ,0,left.location.register);
current_asmdata.CurrAsmList.Concat(taicpu.op_functype(a_if,TWasmFuncType.Create([],[wbt_i32])));
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,1);
current_asmdata.CurrAsmList.Concat(taicpu.op_const(a_i32_const,0));
thlcgwasm(hlcg).incstack(current_asmdata.CurrAsmList,1);
current_asmdata.CurrAsmList.Concat( taicpu.op_none(a_else) );
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,1);
{ the length of a widestring is a 32 bit unsigned int. Since every
character occupies 2 bytes, on a 32 bit platform you can express
the maximum length using 31 bits. On a 64 bit platform, it may be
32 bits. This means that regardless of the platform, a location
with size OS_SINT/ossinttype can hold the length without
overflowing (this code returns an ossinttype value) }
if is_widestring(left.resultdef) then
lendef:=u32inttype
else
lendef:=ossinttype;
{ volatility of the ansistring/widestring refers to the volatility of the
string pointer, not of the string data }
hlcg.reference_reset_base(href,left.resultdef,left.location.register,-lendef.size,ctempposinvalid,lendef.alignment,[]);
extra_slots:=thlcgwasm(hlcg).prepare_stack_for_ref(current_asmdata.CurrAsmList,href,false);
thlcgwasm(hlcg).a_load_ref_stack(current_asmdata.CurrAsmList,lendef,href,extra_slots);
if is_widestring(left.resultdef) then
thlcgwasm(hlcg).a_op_const_stack(current_asmdata.CurrAsmList,OP_SHR,resultdef,1);
{ Dynamic arrays do not have their length attached but their maximum index }
if is_dynamic_array(left.resultdef) then
thlcgwasm(hlcg).a_op_const_stack(current_asmdata.CurrAsmList,OP_ADD,resultdef,1);
current_asmdata.CurrAsmList.Concat( taicpu.op_none(a_end_if) );
location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
end;
procedure twasminlinenode.second_sqr_real;
begin
secondpass(left);
hlcg.location_force_fpureg(current_asmdata.CurrAsmList,left.location,left.resultdef,true);
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
thlcgwasm(hlcg).a_load_loc_stack(current_asmdata.CurrAsmList,left.resultdef,left.location);
case left.location.size of
OS_F32:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f32_mul));
OS_F64:
current_asmdata.CurrAsmList.Concat(taicpu.op_none(a_f64_mul));
else
internalerror(2021060102);
end;
thlcgwasm(hlcg).decstack(current_asmdata.CurrAsmList,1);
location_reset(location,LOC_FPUREGISTER,def_cgsize(resultdef));
location.register:=hlcg.getregisterfordef(current_asmdata.CurrAsmList,resultdef);
thlcgwasm(hlcg).a_load_stack_loc(current_asmdata.CurrAsmList,resultdef,location);
end;
begin
cinlinenode:=twasminlinenode;
end.
Reference in New Issue View Git Blame Copy Permalink