diff --git a/compiler/arm/cgcpu.pas b/compiler/arm/cgcpu.pas index d42587f589..d1604516cb 100644 --- a/compiler/arm/cgcpu.pas +++ b/compiler/arm/cgcpu.pas @@ -40,7 +40,7 @@ unit cgcpu; { true, if the next arithmetic operation should modify the flags } cgsetflags : boolean; - procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override; + procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const paraloc : TCGPara);override; procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override; procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : TCGPara);override; @@ -48,14 +48,14 @@ unit cgcpu; procedure a_call_reg(list : TAsmList;reg: tregister);override; procedure a_call_ref(list : TAsmList;ref: treference);override; - procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; reg: TRegister); override; + procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; reg: TRegister); override; procedure a_op_reg_reg(list : TAsmList; Op: TOpCG; size: TCGSize; src, dst: TRegister); override; procedure a_op_const_reg_reg(list: TAsmList; op: TOpCg; - size: tcgsize; a: aint; src, dst: tregister); override; + size: tcgsize; a: tcgint; src, dst: tregister); override; procedure a_op_reg_reg_reg(list: TAsmList; op: TOpCg; size: tcgsize; src1, src2, dst: tregister); override; - procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation);override; + procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation);override; procedure a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; src1, src2, dst: tregister;setflags : boolean;var ovloc : tlocation);override; { move instructions } @@ -71,7 +71,7 @@ unit cgcpu; procedure a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);override; { comparison operations } - procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel);override; procedure a_cmp_reg_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;reg1,reg2 : tregister;l : tasmlabel); override; @@ -86,10 +86,10 @@ unit cgcpu; procedure a_loadaddr_ref_reg(list : TAsmList;const ref : treference;r : tregister);override; - procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : aint);override; - procedure g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : aint);override; - procedure g_concatcopy_move(list : TAsmList;const source,dest : treference;len : aint); - procedure g_concatcopy_internal(list : TAsmList;const source,dest : treference;len : aint;aligned : boolean); + procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint);override; + procedure g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : tcgint);override; + procedure g_concatcopy_move(list : TAsmList;const source,dest : treference;len : tcgint); + procedure g_concatcopy_internal(list : TAsmList;const source,dest : treference;len : tcgint;aligned : boolean); procedure g_overflowcheck(list: TAsmList; const l: tlocation; def: tdef); override; procedure g_overflowCheck_loc(List:TAsmList;const Loc:TLocation;def:TDef;ovloc : tlocation);override; @@ -102,7 +102,7 @@ unit cgcpu; function handle_load_store(list:TAsmList;op: tasmop;oppostfix : toppostfix;reg:tregister;ref: treference):treference; virtual; procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override; - procedure g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: aint); override; + procedure g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: tcgint); override; procedure g_stackpointer_alloc(list : TAsmList;size : longint);override; procedure a_loadmm_reg_reg(list: TAsmList; fromsize, tosize : tcgsize;reg1, reg2: tregister;shuffle : pmmshuffle); override; @@ -123,7 +123,7 @@ unit cgcpu; procedure init_register_allocators;override; procedure done_register_allocators;override; - procedure a_load_const_reg(list : TAsmList; size: tcgsize; a : aint;reg : tregister);override; + procedure a_load_const_reg(list : TAsmList; size: tcgsize; a : tcgint;reg : tregister);override; procedure a_load_ref_reg(list : TAsmList; fromsize, tosize : tcgsize;const Ref : treference;reg : tregister);override; end; @@ -144,10 +144,10 @@ unit cgcpu; procedure a_call_reg(list : TAsmList;reg: tregister);override; - procedure a_load_const_reg(list : TAsmList; size: tcgsize; a : aint;reg : tregister);override; + procedure a_load_const_reg(list : TAsmList; size: tcgsize; a : tcgint;reg : tregister);override; procedure a_load_ref_reg(list : TAsmList; fromsize, tosize : tcgsize;const Ref : treference;reg : tregister);override; - procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation);override; + procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation);override; procedure a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; src1, src2, dst: tregister;setflags : boolean;var ovloc : tlocation);override; procedure g_flags2reg(list: TAsmList; size: TCgSize; const f: TResFlags; reg: TRegister); override; @@ -245,7 +245,7 @@ unit cgcpu; end; - procedure tarmcgarm.a_load_const_reg(list : TAsmList; size: tcgsize; a : aint;reg : tregister); + procedure tarmcgarm.a_load_const_reg(list : TAsmList; size: tcgsize; a : tcgint;reg : tregister); var imm_shift : byte; l : tasmlabel; @@ -413,7 +413,7 @@ unit cgcpu; end; - procedure tcgarm.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara); + procedure tcgarm.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const paraloc : TCGPara); var ref: treference; begin @@ -558,7 +558,7 @@ unit cgcpu; end; - procedure tcgarm.a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; reg: TRegister); + procedure tcgarm.a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; reg: TRegister); begin a_op_const_reg_reg(list,op,size,a,reg,reg); end; @@ -592,7 +592,7 @@ unit cgcpu; procedure tcgarm.a_op_const_reg_reg(list: TAsmList; op: TOpCg; - size: tcgsize; a: aint; src, dst: tregister); + size: tcgsize; a: tcgint; src, dst: tregister); var ovloc : tlocation; begin @@ -609,7 +609,7 @@ unit cgcpu; end; - procedure tcgarm.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); + procedure tcgarm.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); var shift : byte; tmpreg : tregister; @@ -1321,7 +1321,7 @@ unit cgcpu; { comparison operations } - procedure tcgarm.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure tcgarm.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel); var tmpreg : tregister; @@ -1812,7 +1812,7 @@ unit cgcpu; end; - procedure tcgarm.g_concatcopy_move(list : TAsmList;const source,dest : treference;len : aint); + procedure tcgarm.g_concatcopy_move(list : TAsmList;const source,dest : treference;len : tcgint); var paraloc1,paraloc2,paraloc3 : TCGPara; begin @@ -1839,7 +1839,7 @@ unit cgcpu; end; - procedure tcgarm.g_concatcopy_internal(list : TAsmList;const source,dest : treference;len : aint;aligned : boolean); + procedure tcgarm.g_concatcopy_internal(list : TAsmList;const source,dest : treference;len : tcgint;aligned : boolean); const maxtmpreg=10;{roozbeh: can be reduced to 8 or lower if might conflick with reserved ones,also +2 is used becouse of regs required for referencing} @@ -2042,13 +2042,13 @@ unit cgcpu; end; end; - procedure tcgarm.g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : aint); + procedure tcgarm.g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : tcgint); begin g_concatcopy_internal(list,source,dest,len,false); end; - procedure tcgarm.g_concatcopy(list : TAsmList;const source,dest : treference;len : aint); + procedure tcgarm.g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint); begin if (source.alignment in [1..3]) or (dest.alignment in [1..3]) then @@ -2132,7 +2132,7 @@ unit cgcpu; end; - procedure tcgarm.g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: aint); + procedure tcgarm.g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: tcgint); var hsym : tsym; href : treference; @@ -2848,7 +2848,7 @@ unit cgcpu; end; - procedure Tthumb2cgarm.a_load_const_reg(list : TAsmList; size: tcgsize; a : aint;reg : tregister); + procedure Tthumb2cgarm.a_load_const_reg(list : TAsmList; size: tcgsize; a : tcgint;reg : tregister); var imm_shift : byte; l : tasmlabel; @@ -3014,7 +3014,7 @@ unit cgcpu; end; - procedure Tthumb2cgarm.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); + procedure Tthumb2cgarm.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); var shift : byte; tmpreg : tregister; diff --git a/compiler/cgobj.pas b/compiler/cgobj.pas index af43bb64e8..94b075aba0 100644 --- a/compiler/cgobj.pas +++ b/compiler/cgobj.pas @@ -140,7 +140,7 @@ unit cgobj; @param(a value of constant to send) @param(cgpara where the parameter will be stored) } - procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : TCGPara);virtual; + procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const cgpara : TCGPara);virtual; {# Pass the value of a parameter, which is located in memory, to a routine. A generic version is provided. This routine should @@ -193,7 +193,7 @@ unit cgobj; contains all of the "sizeleft" bytes).) @param(align the alignment of the paraloc in case it's a reference) } - procedure a_load_cgparaloc_ref(list : TAsmList;const paraloc : TCGParaLocation;const ref : treference;sizeleft : aint;align : longint); + procedure a_load_cgparaloc_ref(list : TAsmList;const paraloc : TCGParaLocation;const ref : treference;sizeleft : tcgint;align : longint); {# Load a cgparaloc into any kind of register (int, fp, mm). @@ -236,9 +236,9 @@ unit cgobj; procedure a_call_name_static(list : TAsmList;const s : string);virtual; { move instructions } - procedure a_load_const_reg(list : TAsmList;size : tcgsize;a : aint;register : tregister);virtual; abstract; - procedure a_load_const_ref(list : TAsmList;size : tcgsize;a : aint;const ref : treference);virtual; - procedure a_load_const_loc(list : TAsmList;a : aint;const loc : tlocation); + procedure a_load_const_reg(list : TAsmList;size : tcgsize;a : tcgint;register : tregister);virtual; abstract; + procedure a_load_const_ref(list : TAsmList;size : tcgsize;a : tcgint;const ref : treference);virtual; + procedure a_load_const_loc(list : TAsmList;a : tcgint;const loc : tlocation); procedure a_load_reg_ref(list : TAsmList;fromsize,tosize : tcgsize;register : tregister;const ref : treference);virtual; abstract; procedure a_load_reg_ref_unaligned(list : TAsmList;fromsize,tosize : tcgsize;register : tregister;const ref : treference);virtual; procedure a_load_reg_reg(list : TAsmList;fromsize,tosize : tcgsize;reg1,reg2 : tregister);virtual; abstract; @@ -257,7 +257,7 @@ unit cgobj; procedure a_load_subsetreg_subsetreg(list: TAsmlist; fromsubsetsize, tosubsetsize : tcgsize; const fromsreg, tosreg: tsubsetregister); virtual; procedure a_load_subsetreg_ref(list : TAsmList; subsetsize, tosize: tcgsize; const sreg: tsubsetregister; const destref: treference); virtual; procedure a_load_ref_subsetreg(list : TAsmList; fromsize, subsetsize: tcgsize; const fromref: treference; const sreg: tsubsetregister); virtual; - procedure a_load_const_subsetreg(list: TAsmlist; subsetsize: tcgsize; a: aint; const sreg: tsubsetregister); virtual; + procedure a_load_const_subsetreg(list: TAsmlist; subsetsize: tcgsize; a: tcgint; const sreg: tsubsetregister); virtual; procedure a_load_subsetreg_loc(list: TAsmlist; subsetsize: tcgsize; const sreg: tsubsetregister; const loc: tlocation); virtual; procedure a_load_subsetref_reg(list : TAsmList; subsetsize, tosize: tcgsize; const sref: tsubsetreference; destreg: tregister); virtual; @@ -265,28 +265,28 @@ unit cgobj; procedure a_load_subsetref_subsetref(list: TAsmlist; fromsubsetsize, tosubsetsize : tcgsize; const fromsref, tosref: tsubsetreference); virtual; procedure a_load_subsetref_ref(list : TAsmList; subsetsize, tosize: tcgsize; const sref: tsubsetreference; const destref: treference); virtual; procedure a_load_ref_subsetref(list : TAsmList; fromsize, subsetsize: tcgsize; const fromref: treference; const sref: tsubsetreference); virtual; - procedure a_load_const_subsetref(list: TAsmlist; subsetsize: tcgsize; a: aint; const sref: tsubsetreference); virtual; + procedure a_load_const_subsetref(list: TAsmlist; subsetsize: tcgsize; a: tcgint; const sref: tsubsetreference); virtual; procedure a_load_subsetref_loc(list: TAsmlist; subsetsize: tcgsize; const sref: tsubsetreference; const loc: tlocation); virtual; procedure a_load_subsetref_subsetreg(list: TAsmlist; fromsubsetsize, tosubsetsize : tcgsize; const fromsref: tsubsetreference; const tosreg: tsubsetregister); virtual; procedure a_load_subsetreg_subsetref(list: TAsmlist; fromsubsetsize, tosubsetsize : tcgsize; const fromsreg: tsubsetregister; const tosref: tsubsetreference); virtual; { bit test instructions } procedure a_bit_test_reg_reg_reg(list : TAsmList; bitnumbersize,valuesize,destsize: tcgsize;bitnumber,value,destreg: tregister); virtual; - procedure a_bit_test_const_ref_reg(list: TAsmList; destsize: tcgsize; bitnumber: aint; const ref: treference; destreg: tregister); virtual; - procedure a_bit_test_const_reg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: aint; setreg, destreg: tregister); virtual; - procedure a_bit_test_const_subsetreg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: aint; const setreg: tsubsetregister; destreg: tregister); virtual; + procedure a_bit_test_const_ref_reg(list: TAsmList; destsize: tcgsize; bitnumber: tcgint; const ref: treference; destreg: tregister); virtual; + procedure a_bit_test_const_reg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: tcgint; setreg, destreg: tregister); virtual; + procedure a_bit_test_const_subsetreg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: tcgint; const setreg: tsubsetregister; destreg: tregister); virtual; procedure a_bit_test_reg_ref_reg(list: TAsmList; bitnumbersize, destsize: tcgsize; bitnumber: tregister; const ref: treference; destreg: tregister); virtual; procedure a_bit_test_reg_loc_reg(list: TAsmList; bitnumbersize, destsize: tcgsize; bitnumber: tregister; const loc: tlocation; destreg: tregister); - procedure a_bit_test_const_loc_reg(list: TAsmList; destsize: tcgsize; bitnumber: aint; const loc: tlocation; destreg: tregister); + procedure a_bit_test_const_loc_reg(list: TAsmList; destsize: tcgsize; bitnumber: tcgint; const loc: tlocation; destreg: tregister); { bit set/clear instructions } procedure a_bit_set_reg_reg(list : TAsmList; doset: boolean; bitnumbersize, destsize: tcgsize; bitnumber,dest: tregister); virtual; - procedure a_bit_set_const_ref(list: TAsmList; doset: boolean;destsize: tcgsize; bitnumber: aint; const ref: treference); virtual; - procedure a_bit_set_const_reg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: aint; destreg: tregister); virtual; - procedure a_bit_set_const_subsetreg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: aint; const destreg: tsubsetregister); virtual; + procedure a_bit_set_const_ref(list: TAsmList; doset: boolean;destsize: tcgsize; bitnumber: tcgint; const ref: treference); virtual; + procedure a_bit_set_const_reg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: tcgint; destreg: tregister); virtual; + procedure a_bit_set_const_subsetreg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: tcgint; const destreg: tsubsetregister); virtual; procedure a_bit_set_reg_ref(list: TAsmList; doset: boolean; bitnumbersize: tcgsize; bitnumber: tregister; const ref: treference); virtual; procedure a_bit_set_reg_loc(list: TAsmList; doset: boolean; bitnumbersize: tcgsize; bitnumber: tregister; const loc: tlocation); - procedure a_bit_set_const_loc(list: TAsmList; doset: boolean; bitnumber: aint; const loc: tlocation); + procedure a_bit_set_const_loc(list: TAsmList; doset: boolean; bitnumber: tcgint; const loc: tlocation); { bit scan instructions } procedure a_bit_scan_reg_reg(list: TAsmList; reverse: boolean; size: tcgsize; src, dst: TRegister); virtual; abstract; @@ -323,11 +323,11 @@ unit cgobj; { the op_reg_reg, op_reg_ref or op_reg_loc methods and keep in mind } { that in this case the *second* operand is used as both source and } { destination (JM) } - procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: Aint; reg: TRegister); virtual; abstract; - procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: Aint; const ref: TReference); virtual; - procedure a_op_const_subsetreg(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : aint; const sreg: tsubsetregister); virtual; - procedure a_op_const_subsetref(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : aint; const sref: tsubsetreference); virtual; - procedure a_op_const_loc(list : TAsmList; Op: TOpCG; a: Aint; const loc: tlocation); + procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; reg: TRegister); virtual; abstract; + procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; const ref: TReference); virtual; + procedure a_op_const_subsetreg(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : tcgint; const sreg: tsubsetregister); virtual; + procedure a_op_const_subsetref(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : tcgint; const sref: tsubsetreference); virtual; + procedure a_op_const_loc(list : TAsmList; Op: TOpCG; a: tcgint; const loc: tlocation); procedure a_op_reg_reg(list : TAsmList; Op: TOpCG; size: TCGSize; reg1, reg2: TRegister); virtual; abstract; procedure a_op_reg_ref(list : TAsmList; Op: TOpCG; size: TCGSize; reg: TRegister; const ref: TReference); virtual; procedure a_op_ref_reg(list : TAsmList; Op: TOpCG; size: TCGSize; const ref: TReference; reg: TRegister); virtual; @@ -339,17 +339,17 @@ unit cgobj; { trinary operations for processors that support them, 'emulated' } { on others. None with "ref" arguments since I don't think there } { are any processors that support it (JM) } - procedure a_op_const_reg_reg(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister); virtual; + procedure a_op_const_reg_reg(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister); virtual; procedure a_op_reg_reg_reg(list: TAsmList; op: TOpCg; size: tcgsize; src1, src2, dst: tregister); virtual; - procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); virtual; + procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); virtual; procedure a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; src1, src2, dst: tregister;setflags : boolean;var ovloc : tlocation); virtual; { comparison operations } - procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel); virtual; - procedure a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;const ref : treference; + procedure a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;const ref : treference; l : tasmlabel); virtual; - procedure a_cmp_const_loc_label(list: TAsmList; size: tcgsize;cmp_op: topcmp; a: aint; const loc: tlocation; + procedure a_cmp_const_loc_label(list: TAsmList; size: tcgsize;cmp_op: topcmp; a: tcgint; const loc: tlocation; l : tasmlabel); procedure a_cmp_reg_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;reg1,reg2 : tregister;l : tasmlabel); virtual; abstract; procedure a_cmp_ref_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp; const ref: treference; reg : tregister; l : tasmlabel); virtual; @@ -384,7 +384,7 @@ unit cgobj; @param(a The constant which should be emitted, returns the constant which must be emitted) } - procedure optimize_op_const(var op: topcg; var a : aint);virtual; + procedure optimize_op_const(var op: topcg; var a : tcgint);virtual; {# This routine is used in exception management nodes. It should @@ -405,7 +405,7 @@ unit cgobj; The size of the value to save is OS_S32. The default version saves the exception reason to a temp. memory area. } - procedure g_exception_reason_save_const(list : TAsmList; const href : treference; a: aint);virtual; + procedure g_exception_reason_save_const(list : TAsmList; const href : treference; a: tcgint);virtual; {# This routine is used in exception management nodes. It should load the exception reason to the FUNCTION_RETURN_REG. The saved value @@ -428,7 +428,7 @@ unit cgobj; @param(dest Destination reference of copy) } - procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : aint);virtual; abstract; + procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint);virtual; abstract; {# This should emit the opcode to copy len bytes from the an unaligned source to destination. @@ -438,7 +438,7 @@ unit cgobj; @param(dest Destination reference of copy) } - procedure g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : aint);virtual; + procedure g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : tcgint);virtual; {# This should emit the opcode to a shortrstring from the source to destination. @@ -469,7 +469,7 @@ unit cgobj; procedure g_overflowcheck(list: TAsmList; const Loc:tlocation; def:tdef); virtual;abstract; procedure g_overflowCheck_loc(List:TAsmList;const Loc:TLocation;def:TDef;ovloc : tlocation);virtual; - procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:aint;destreg:tregister);virtual; + procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister);virtual; procedure g_releasevaluepara_openarray(list : TAsmList;const l:tlocation);virtual; {# Emits instructions when compilation is done in profile @@ -516,7 +516,7 @@ unit cgobj; procedure g_restore_registers(list:TAsmList);virtual; procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);virtual;abstract; - procedure g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: aint);virtual; + procedure g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: tcgint);virtual; function g_indirect_sym_load(list:TAsmList;const symname: string; weak: boolean): tregister;virtual; { generate a stub which only purpose is to pass control the given external method, @@ -535,8 +535,8 @@ unit cgobj; procedure a_load_regconst_subsetref_intern(list : TAsmList; fromsize, subsetsize: tcgsize; fromreg: tregister; const sref: tsubsetreference; slopt: tsubsetloadopt); virtual; procedure a_load_regconst_subsetreg_intern(list : TAsmList; fromsize, subsetsize: tcgsize; fromreg: tregister; const sreg: tsubsetregister; slopt: tsubsetloadopt); virtual; - function get_bit_const_ref_sref(bitnumber: aint; const ref: treference): tsubsetreference; - function get_bit_const_reg_sreg(setregsize: tcgsize; bitnumber: aint; setreg: tregister): tsubsetregister; + function get_bit_const_ref_sref(bitnumber: tcgint; const ref: treference): tsubsetreference; + function get_bit_const_reg_sreg(setregsize: tcgsize; bitnumber: tcgint; setreg: tregister): tsubsetregister; function get_bit_reg_ref_sref(list: TAsmList; bitnumbersize: tcgsize; bitnumber: tregister; const ref: treference): tsubsetreference; end; @@ -918,7 +918,7 @@ implementation end; - procedure tcg.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : TCGPara); + procedure tcg.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const cgpara : TCGPara); var ref : treference; begin @@ -944,7 +944,7 @@ implementation tmpreg: tregister; location: pcgparalocation; orgsizeleft, - sizeleft: aint; + sizeleft: tcgint; reghasvalue: boolean; begin location:=cgpara.location; @@ -1121,7 +1121,7 @@ implementation end; - procedure tcg.a_load_cgparaloc_ref(list : TAsmList;const paraloc : TCGParaLocation;const ref : treference;sizeleft : aint;align : longint); + procedure tcg.a_load_cgparaloc_ref(list : TAsmList;const paraloc : TCGParaLocation;const ref : treference;sizeleft : tcgint;align : longint); var href : treference; begin @@ -1266,7 +1266,7 @@ implementation bitmask := (aword(1) shl (stopbit - sreg.startbit)) - 1 else bitmask := high(aword); - a_op_const_reg(list,OP_AND,sreg.subsetregsize,aint(bitmask),tmpreg); + a_op_const_reg(list,OP_AND,sreg.subsetregsize,tcgint(bitmask),tmpreg); end; tmpreg := makeregsize(list,tmpreg,subsetsize); a_load_reg_reg(list,tcgsize2unsigned[subsetsize],subsetsize,tmpreg,tmpreg); @@ -1298,17 +1298,17 @@ implementation a_load_reg_reg(list,fromsize,sreg.subsetregsize,fromreg,tmpreg); a_op_const_reg(list,OP_SHL,sreg.subsetregsize,sreg.startbit,tmpreg); if (slopt <> SL_REGNOSRCMASK) then - a_op_const_reg(list,OP_AND,sreg.subsetregsize,aint(not(bitmask)),tmpreg); + a_op_const_reg(list,OP_AND,sreg.subsetregsize,tcgint(not(bitmask)),tmpreg); end; if (slopt <> SL_SETMAX) then - a_op_const_reg(list,OP_AND,sreg.subsetregsize,aint(bitmask),sreg.subsetreg); + a_op_const_reg(list,OP_AND,sreg.subsetregsize,tcgint(bitmask),sreg.subsetreg); case slopt of SL_SETZERO : ; SL_SETMAX : if (sreg.bitlen <> AIntBits) then a_op_const_reg(list,OP_OR,sreg.subsetregsize, - aint(((aword(1) shl sreg.bitlen)-1) shl sreg.startbit), + tcgint(((aword(1) shl sreg.bitlen)-1) shl sreg.startbit), sreg.subsetreg) else a_load_const_reg(list,sreg.subsetregsize,-1,sreg.subsetreg); @@ -1338,8 +1338,8 @@ implementation bitmask := not(((aword(1) shl stopbit)-1) xor ((aword(1) shl tosreg.startbit)-1)) else bitmask := (aword(1) shl tosreg.startbit) - 1; - a_op_const_reg(list,OP_AND,tosreg.subsetregsize,aint(bitmask),tosreg.subsetreg); - a_op_const_reg(list,OP_AND,tosreg.subsetregsize,aint(not(bitmask)),tmpreg); + a_op_const_reg(list,OP_AND,tosreg.subsetregsize,tcgint(bitmask),tosreg.subsetreg); + a_op_const_reg(list,OP_AND,tosreg.subsetregsize,tcgint(not(bitmask)),tmpreg); a_op_reg_reg(list,OP_OR,tosreg.subsetregsize,tmpreg,tosreg.subsetreg); end else @@ -1371,7 +1371,7 @@ implementation end; - procedure tcg.a_load_const_subsetreg(list: TAsmlist; subsetsize: tcgsize; a: aint; const sreg: tsubsetregister); + procedure tcg.a_load_const_subsetreg(list: TAsmlist; subsetsize: tcgsize; a: tcgint; const sreg: tsubsetregister); var bitmask: aword; stopbit: byte; @@ -1383,8 +1383,8 @@ implementation else bitmask := (aword(1) shl sreg.startbit) - 1; if (((aword(a) shl sreg.startbit) and not bitmask) <> not bitmask) then - a_op_const_reg(list,OP_AND,sreg.subsetregsize,aint(bitmask),sreg.subsetreg); - a_op_const_reg(list,OP_OR,sreg.subsetregsize,aint((aword(a) shl sreg.startbit) and not(bitmask)),sreg.subsetreg); + a_op_const_reg(list,OP_AND,sreg.subsetregsize,tcgint(bitmask),sreg.subsetreg); + a_op_const_reg(list,OP_OR,sreg.subsetregsize,tcgint((aword(a) shl sreg.startbit) and not(bitmask)),sreg.subsetreg); end; @@ -1463,7 +1463,7 @@ implementation procedure tcg.get_subsetref_load_info(const sref: tsubsetreference; out loadsize: tcgsize; out extra_load: boolean); var - intloadsize: aint; + intloadsize: tcgint; begin intloadsize := packedbitsloadsize(sref.bitlen); @@ -1505,7 +1505,7 @@ implementation a_op_const_reg(list,OP_SHL,OS_INT,restbits,valuereg); { mask other bits } if (sref.bitlen <> AIntBits) then - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),valuereg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),valuereg); end; a_op_const_reg(list,OP_SHR,OS_INT,loadbitsize-restbits,extra_value_reg) end @@ -1523,7 +1523,7 @@ implementation a_op_const_reg(list,OP_SHL,OS_INT,loadbitsize-sref.startbit,extra_value_reg); { mask other bits } if (sref.bitlen <> AIntBits) then - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),extra_value_reg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),extra_value_reg); end; end; { merge } @@ -1560,7 +1560,7 @@ implementation a_op_const_reg(list,OP_SHR,OS_INT,loadbitsize-sref.bitlen,valuereg); if (loadbitsize <> AIntBits) then { mask left over bits } - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),valuereg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),valuereg); end; tmpreg := getintregister(list,OS_INT); @@ -1613,7 +1613,7 @@ implementation a_op_const_reg(list,OP_SAR,OS_INT,AIntBits-sref.bitlen,valuereg); end else - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),valuereg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),valuereg); end; end; @@ -1679,7 +1679,7 @@ implementation end; { mask other bits/sign extend } if not(subsetsize in [OS_S8..OS_S128]) then - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),valuereg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),valuereg); end end else @@ -1771,12 +1771,12 @@ implementation maskreg := getintregister(list,OS_INT); if (target_info.endian = endian_big) then begin - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen)-1) shl (loadbitsize-sref.bitlen),maskreg); + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen)-1) shl (loadbitsize-sref.bitlen),maskreg); a_op_reg_reg(list,OP_SHR,OS_INT,sref.bitindexreg,maskreg); end else begin - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen)-1),maskreg); + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),maskreg); a_op_reg_reg(list,OP_SHL,OS_INT,sref.bitindexreg,maskreg); end; a_op_reg_reg(list,OP_NOT,OS_INT,maskreg,maskreg); @@ -1790,7 +1790,7 @@ implementation if (slopt <> SL_SETMAX) then a_load_reg_reg(list,fromsize,OS_INT,fromreg,tmpreg) else if (sref.bitlen <> AIntBits) then - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen) - 1), tmpreg) + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen) - 1), tmpreg) else a_load_const_reg(list,OS_INT,-1,tmpreg); if (target_info.endian = endian_big) then @@ -1809,7 +1809,7 @@ implementation else begin if not(slopt in [SL_REGNOSRCMASK,SL_SETMAX]) then - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),tmpreg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),tmpreg); a_op_reg_reg(list,OP_SHL,OS_INT,sref.bitindexreg,tmpreg); end; a_op_reg_reg(list,OP_OR,OS_INT,tmpreg,valuereg); @@ -1917,12 +1917,12 @@ implementation maskreg := getintregister(list,OS_INT); if (target_info.endian = endian_big) then begin - a_load_const_reg(list,OS_INT,aint(((aword(1) shl sref.bitlen)-1) shl (loadbitsize-sref.bitlen)),maskreg); + a_load_const_reg(list,OS_INT,tcgint(((aword(1) shl sref.bitlen)-1) shl (loadbitsize-sref.bitlen)),maskreg); a_op_reg_reg(list,OP_SHR,OS_INT,sref.bitindexreg,maskreg); end else begin - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen)-1),maskreg); + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),maskreg); a_op_reg_reg(list,OP_SHL,OS_INT,sref.bitindexreg,maskreg); end; @@ -1937,7 +1937,7 @@ implementation if (slopt <> SL_SETMAX) then a_load_reg_reg(list,fromsize,OS_INT,fromreg,tmpreg) else if (sref.bitlen <> AIntBits) then - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen) - 1), tmpreg) + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen) - 1), tmpreg) else a_load_const_reg(list,OS_INT,-1,tmpreg); if (target_info.endian = endian_big) then @@ -1945,14 +1945,14 @@ implementation a_op_const_reg(list,OP_SHL,OS_INT,loadbitsize-sref.bitlen,tmpreg); if not(slopt in [SL_REGNOSRCMASK,SL_SETMAX]) then { mask left over bits } - a_op_const_reg(list,OP_AND,OS_INT,aint(((aword(1) shl sref.bitlen)-1) shl (loadbitsize-sref.bitlen)),tmpreg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint(((aword(1) shl sref.bitlen)-1) shl (loadbitsize-sref.bitlen)),tmpreg); a_op_reg_reg(list,OP_SHR,OS_INT,sref.bitindexreg,tmpreg); end else begin if not(slopt in [SL_REGNOSRCMASK,SL_SETMAX]) then { mask left over bits } - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),tmpreg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),tmpreg); a_op_reg_reg(list,OP_SHL,OS_INT,sref.bitindexreg,tmpreg); end; a_op_reg_reg(list,OP_OR,OS_INT,tmpreg,valuereg); @@ -1974,7 +1974,7 @@ implementation if (slopt <> SL_SETMAX) then a_load_reg_reg(list,fromsize,OS_INT,fromreg,tmpreg) else if (sref.bitlen <> AIntBits) then - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen) - 1), tmpreg) + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen) - 1), tmpreg) else a_load_const_reg(list,OS_INT,-1,tmpreg); end; @@ -1987,7 +1987,7 @@ implementation begin a_op_const_reg_reg(list,OP_ADD,OS_INT,sref.bitlen-2*loadbitsize,sref.bitindexreg,tmpindexreg); a_op_reg_reg(list,OP_NEG,OS_INT,tmpindexreg,tmpindexreg); - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen)-1),maskreg); + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),maskreg); a_op_reg_reg(list,OP_SHL,OS_INT,tmpindexreg,maskreg); end else @@ -1995,7 +1995,7 @@ implementation { Y-x = -(x-Y) } a_op_const_reg_reg(list,OP_SUB,OS_INT,loadbitsize,sref.bitindexreg,tmpindexreg); a_op_reg_reg(list,OP_NEG,OS_INT,tmpindexreg,tmpindexreg); - a_load_const_reg(list,OS_INT,aint((aword(1) shl sref.bitlen)-1),maskreg); + a_load_const_reg(list,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),maskreg); a_op_reg_reg(list,OP_SHR,OS_INT,tmpindexreg,maskreg); end; @@ -2010,7 +2010,7 @@ implementation else begin if not(slopt in [SL_REGNOSRCMASK,SL_SETMAX]) then - a_op_const_reg(list,OP_AND,OS_INT,aint((aword(1) shl sref.bitlen)-1),tmpreg); + a_op_const_reg(list,OP_AND,OS_INT,tcgint((aword(1) shl sref.bitlen)-1),tmpreg); a_op_reg_reg(list,OP_SHR,OS_INT,tmpindexreg,tmpreg); end; a_op_reg_reg(list,OP_OR,OS_INT,tmpreg,extra_value_reg); @@ -2054,7 +2054,7 @@ implementation end; - procedure tcg.a_load_const_subsetref(list: TAsmlist; subsetsize: tcgsize; a: aint; const sref: tsubsetreference); + procedure tcg.a_load_const_subsetref(list: TAsmlist; subsetsize: tcgsize; a: tcgint; const sref: tsubsetreference); var tmpreg: tregister; slopt: tsubsetloadopt; @@ -2062,7 +2062,7 @@ implementation { perform masking of the source value in advance } slopt := SL_REGNOSRCMASK; if (sref.bitlen <> AIntBits) then - aword(a) := aword(a) and ((aword(1) shl sref.bitlen) -1); + a := tcgint(aword(a) and ((aword(1) shl sref.bitlen) -1)); if ( { broken x86 "x shl regbitsize = x" } ((sref.bitlen <> AIntBits) and @@ -2129,7 +2129,7 @@ implementation { generic bit address calculation routines } - function tcg.get_bit_const_ref_sref(bitnumber: aint; const ref: treference): tsubsetreference; + function tcg.get_bit_const_ref_sref(bitnumber: tcgint; const ref: treference): tsubsetreference; begin result.ref:=ref; inc(result.ref.offset,bitnumber div 8); @@ -2139,7 +2139,7 @@ implementation end; - function tcg.get_bit_const_reg_sreg(setregsize: tcgsize; bitnumber: aint; setreg: tregister): tsubsetregister; + function tcg.get_bit_const_reg_sreg(setregsize: tcgsize; bitnumber: tcgint; setreg: tregister): tsubsetregister; begin result.subsetreg:=setreg; result.subsetregsize:=setregsize; @@ -2208,19 +2208,19 @@ implementation end; - procedure tcg.a_bit_test_const_ref_reg(list: TAsmList; destsize: tcgsize; bitnumber: aint; const ref: treference; destreg: tregister); + procedure tcg.a_bit_test_const_ref_reg(list: TAsmList; destsize: tcgsize; bitnumber: tcgint; const ref: treference; destreg: tregister); begin a_load_subsetref_reg(list,OS_8,destsize,get_bit_const_ref_sref(bitnumber,ref),destreg); end; - procedure tcg.a_bit_test_const_reg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: aint; setreg, destreg: tregister); + procedure tcg.a_bit_test_const_reg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: tcgint; setreg, destreg: tregister); begin a_load_subsetreg_reg(list,setregsize,destsize,get_bit_const_reg_sreg(setregsize,bitnumber,setreg),destreg); end; - procedure tcg.a_bit_test_const_subsetreg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: aint; const setreg: tsubsetregister; destreg: tregister); + procedure tcg.a_bit_test_const_subsetreg_reg(list: TAsmList; setregsize, destsize: tcgsize; bitnumber: tcgint; const setreg: tsubsetregister; destreg: tregister); var tmpsreg: tsubsetregister; begin @@ -2276,7 +2276,7 @@ implementation end; - procedure tcg.a_bit_test_const_loc_reg(list: TAsmList; destsize: tcgsize; bitnumber: aint; const loc: tlocation; destreg: tregister); + procedure tcg.a_bit_test_const_loc_reg(list: TAsmList; destsize: tcgsize; bitnumber: tcgint; const loc: tlocation; destreg: tregister); begin case loc.loc of LOC_REFERENCE,LOC_CREFERENCE: @@ -2323,19 +2323,19 @@ implementation end; - procedure tcg.a_bit_set_const_ref(list: TAsmList; doset: boolean;destsize: tcgsize; bitnumber: aint; const ref: treference); + procedure tcg.a_bit_set_const_ref(list: TAsmList; doset: boolean;destsize: tcgsize; bitnumber: tcgint; const ref: treference); begin a_load_const_subsetref(list,OS_8,ord(doset),get_bit_const_ref_sref(bitnumber,ref)); end; - procedure tcg.a_bit_set_const_reg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: aint; destreg: tregister); + procedure tcg.a_bit_set_const_reg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: tcgint; destreg: tregister); begin a_load_const_subsetreg(list,OS_8,ord(doset),get_bit_const_reg_sreg(destsize,bitnumber,destreg)); end; - procedure tcg.a_bit_set_const_subsetreg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: aint; const destreg: tsubsetregister); + procedure tcg.a_bit_set_const_subsetreg(list: TAsmList; doset: boolean; destsize: tcgsize; bitnumber: tcgint; const destreg: tsubsetregister); var tmpsreg: tsubsetregister; begin @@ -2382,7 +2382,7 @@ implementation end; - procedure tcg.a_bit_set_const_loc(list: TAsmList; doset: boolean; bitnumber: aint; const loc: tlocation); + procedure tcg.a_bit_set_const_loc(list: TAsmList; doset: boolean; bitnumber: tcgint; const loc: tlocation); begin case loc.loc of LOC_REFERENCE: @@ -2549,7 +2549,7 @@ implementation end; - procedure tcg.a_load_const_ref(list : TAsmList;size : tcgsize;a : aint;const ref : treference); + procedure tcg.a_load_const_ref(list : TAsmList;size : tcgsize;a : tcgint;const ref : treference); var tmpreg: tregister; begin @@ -2559,7 +2559,7 @@ implementation end; - procedure tcg.a_load_const_loc(list : TAsmList;a : aint;const loc: tlocation); + procedure tcg.a_load_const_loc(list : TAsmList;a : tcgint;const loc: tlocation); begin case loc.loc of LOC_REFERENCE,LOC_CREFERENCE: @@ -2669,7 +2669,7 @@ implementation end; - procedure tcg.optimize_op_const(var op: topcg; var a : aint); + procedure tcg.optimize_op_const(var op: topcg; var a : tcgint); var powerval : longint; begin @@ -2848,7 +2848,7 @@ implementation end; - procedure tcg.a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; const ref: TReference); + procedure tcg.a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; const ref: TReference); var tmpreg : tregister; begin @@ -2859,7 +2859,7 @@ implementation end; - procedure tcg.a_op_const_subsetreg(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : aint; const sreg: tsubsetregister); + procedure tcg.a_op_const_subsetreg(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : tcgint; const sreg: tsubsetregister); var tmpreg: tregister; begin @@ -2870,7 +2870,7 @@ implementation end; - procedure tcg.a_op_const_subsetref(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : aint; const sref: tsubsetreference); + procedure tcg.a_op_const_subsetref(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : tcgint; const sref: tsubsetreference); var tmpreg: tregister; begin @@ -2881,7 +2881,7 @@ implementation end; - procedure tcg.a_op_const_loc(list : TAsmList; Op: TOpCG; a: aint; const loc: tlocation); + procedure tcg.a_op_const_loc(list : TAsmList; Op: TOpCG; a: tcgint; const loc: tlocation); begin case loc.loc of LOC_REGISTER, LOC_CREGISTER: @@ -3008,7 +3008,7 @@ implementation procedure Tcg.a_op_const_reg_reg(list:TAsmList;op:Topcg;size:Tcgsize; - a:aint;src,dst:Tregister); + a:tcgint;src,dst:Tregister); begin a_load_reg_reg(list,size,size,src,dst); @@ -3041,7 +3041,7 @@ implementation end; - procedure tcg.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); + procedure tcg.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); begin a_op_const_reg_reg(list,op,size,a,src,dst); ovloc.loc:=LOC_VOID; @@ -3056,7 +3056,7 @@ implementation procedure tcg.a_cmp_const_reg_label(list: TAsmList; size: tcgsize; - cmp_op: topcmp; a: aint; reg: tregister; l: tasmlabel); + cmp_op: topcmp; a: tcgint; reg: tregister; l: tasmlabel); var tmpreg: tregister; begin @@ -3066,7 +3066,7 @@ implementation end; - procedure tcg.a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;const ref : treference; + procedure tcg.a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;const ref : treference; l : tasmlabel); var tmpreg: tregister; @@ -3077,7 +3077,7 @@ implementation end; - procedure tcg.a_cmp_const_loc_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;const loc : tlocation; + procedure tcg.a_cmp_const_loc_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;const loc : tlocation; l : tasmlabel); var tmpreg : tregister; @@ -3421,7 +3421,7 @@ implementation end; - procedure tcg.g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : aint); + procedure tcg.g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : tcgint); begin g_concatcopy(list,source,dest,len); end; @@ -3878,7 +3878,7 @@ implementation end; hreg:=getintregister(list,OS_INT); a_load_loc_reg(list,OS_INT,l,hreg); - a_op_const_reg(list,OP_SUB,OS_INT,aint(int64(lto)),hreg); + a_op_const_reg(list,OP_SUB,OS_INT,tcgint(int64(lto)),hreg); current_asmdata.getjumplabel(neglabel); { if from_signed then @@ -3890,7 +3890,7 @@ implementation a_cmp_const_reg_label(list,OS_INT,OC_BE,aintmax,hreg,neglabel) else {$endif cpu64bitalu} - a_cmp_const_reg_label(list,OS_INT,OC_BE,aint(int64(hto-lto)),hreg,neglabel); + a_cmp_const_reg_label(list,OS_INT,OC_BE,tcgint(int64(hto-lto)),hreg,neglabel); a_call_name(list,'FPC_RANGEERROR',false); a_label(list,neglabel); end; @@ -3927,7 +3927,7 @@ implementation a_cmp_const_reg_label(list,OS_ADDR,OC_NE,0,reg,oklabel); cgpara1.init; paramanager.getintparaloc(pocall_default,1,cgpara1); - a_load_const_cgpara(list,OS_INT,aint(210),cgpara1); + a_load_const_cgpara(list,OS_INT,tcgint(210),cgpara1); paramanager.freecgpara(list,cgpara1); a_call_name(list,'FPC_HANDLEERROR',false); a_label(list,oklabel); @@ -3974,7 +3974,7 @@ implementation Entry/Exit Code Functions *****************************************************************************} - procedure tcg.g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:aint;destreg:tregister); + procedure tcg.g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister); var sizereg,sourcereg,lenreg : tregister; cgpara1,cgpara2,cgpara3 : TCGPara; @@ -4168,7 +4168,7 @@ implementation end; - procedure tcg.g_exception_reason_save_const(list : TAsmList; const href : treference; a: aint); + procedure tcg.g_exception_reason_save_const(list : TAsmList; const href : treference; a: tcgint); begin a_load_const_ref(list, OS_INT, a, href); end; @@ -4181,7 +4181,7 @@ implementation end; - procedure tcg.g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: aint); + procedure tcg.g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: tcgint); var hsym : tsym; href : treference; diff --git a/compiler/i386/cgcpu.pas b/compiler/i386/cgcpu.pas index 2849d6200e..4b7238ee4b 100644 --- a/compiler/i386/cgcpu.pas +++ b/compiler/i386/cgcpu.pas @@ -40,16 +40,16 @@ unit cgcpu; { passing parameter using push instead of mov } procedure a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);override; - procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);override; + procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const cgpara : tcgpara);override; procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);override; procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : tcgpara);override; procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean);override; - procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:aint;destreg:tregister);override; + procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister);override; procedure g_releasevaluepara_openarray(list : TAsmList;const l:tlocation);override; procedure g_exception_reason_save(list : TAsmList; const href : treference);override; - procedure g_exception_reason_save_const(list : TAsmList; const href : treference; a: aint);override; + procedure g_exception_reason_save_const(list : TAsmList; const href : treference; a: tcgint);override; procedure g_exception_reason_load(list : TAsmList; const href : treference);override; procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override; procedure g_maybe_got_init(list: TAsmList); override; @@ -63,7 +63,7 @@ unit cgcpu; private procedure get_64bit_ops(op:TOpCG;var op1,op2:TAsmOp); end; - + procedure create_codegen; implementation @@ -125,7 +125,7 @@ unit cgcpu; end; - procedure tcg386.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara); + procedure tcg386.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const cgpara : tcgpara); var pushsize : tcgsize; begin @@ -145,7 +145,7 @@ unit cgcpu; procedure tcg386.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara); - procedure pushdata(paraloc:pcgparalocation;ofs:aint); + procedure pushdata(paraloc:pcgparalocation;ofs:tcgint); var pushsize : tcgsize; tmpreg : tregister; @@ -184,7 +184,7 @@ unit cgcpu; end; var - len : aint; + len : tcgint; href : treference; begin { cgpara.size=OS_NO requires a copy on the stack } @@ -353,7 +353,7 @@ unit cgcpu; end; - procedure tcg386.g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:aint;destreg:tregister); + procedure tcg386.g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister); var power,len : longint; opsize : topsize; @@ -471,7 +471,7 @@ unit cgcpu; end; - procedure tcg386.g_exception_reason_save_const(list : TAsmList;const href : treference; a: aint); + procedure tcg386.g_exception_reason_save_const(list : TAsmList;const href : treference; a: tcgint); begin if not paramanager.use_fixed_stack then list.concat(Taicpu.op_const(A_PUSH,tcgsize2opsize[OS_INT],a)) @@ -781,8 +781,8 @@ unit cgcpu; case op of OP_AND,OP_OR,OP_XOR: begin - cg.a_op_const_reg(list,op,OS_32,aint(lo(value)),reg.reglo); - cg.a_op_const_reg(list,op,OS_32,aint(hi(value)),reg.reghi); + cg.a_op_const_reg(list,op,OS_32,tcgint(lo(value)),reg.reglo); + cg.a_op_const_reg(list,op,OS_32,tcgint(hi(value)),reg.reghi); end; OP_ADD, OP_SUB: begin @@ -807,9 +807,9 @@ unit cgcpu; case op of OP_AND,OP_OR,OP_XOR: begin - cg.a_op_const_ref(list,op,OS_32,aint(lo(value)),tempref); + cg.a_op_const_ref(list,op,OS_32,tcgint(lo(value)),tempref); inc(tempref.offset,4); - cg.a_op_const_ref(list,op,OS_32,aint(hi(value)),tempref); + cg.a_op_const_ref(list,op,OS_32,tcgint(hi(value)),tempref); end; OP_ADD, OP_SUB: begin @@ -829,5 +829,5 @@ unit cgcpu; cg := tcg386.create; cg64 := tcg64f386.create; end; - + end. diff --git a/compiler/m68k/cgcpu.pas b/compiler/m68k/cgcpu.pas index 68bb72a66a..a98ffce61b 100644 --- a/compiler/m68k/cgcpu.pas +++ b/compiler/m68k/cgcpu.pas @@ -44,15 +44,15 @@ unit cgcpu; procedure done_register_allocators;override; procedure a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);override; - procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);override; + procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const cgpara : tcgpara);override; procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);override; procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : tcgpara);override; procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override; procedure a_call_reg(list : TAsmList;reg : tregister);override; - procedure a_load_const_reg(list : TAsmList;size : tcgsize;a : aint;register : tregister);override; - procedure a_load_const_ref(list : TAsmList; tosize: tcgsize; a : aint;const ref : treference);override; + procedure a_load_const_reg(list : TAsmList;size : tcgsize;a : tcgint;register : tregister);override; + procedure a_load_const_ref(list : TAsmList; tosize: tcgsize; a : tcgint;const ref : treference);override; procedure a_load_reg_ref(list : TAsmList;fromsize,tosize : tcgsize;register : tregister;const ref : treference);override; procedure a_load_reg_reg(list : TAsmList;fromsize,tosize : tcgsize;reg1,reg2 : tregister);override; @@ -69,27 +69,27 @@ unit cgcpu; procedure a_loadmm_reg_ref(list: TAsmList;fromsize,tosize : tcgsize; reg: tregister; const ref: treference;shuffle : pmmshuffle); override; procedure a_loadmm_reg_cgpara(list: TAsmList; size: tcgsize; reg: tregister;const locpara : TCGPara;shuffle : pmmshuffle); override; - procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: tcgsize; a: aint; reg: TRegister); override; -// procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; const ref: TReference); override; + procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: tcgsize; a: tcgint; reg: TRegister); override; +// procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; const ref: TReference); override; procedure a_op_reg_reg(list : TAsmList; Op: TOpCG; size: TCGSize; reg1, reg2: TRegister); override; - procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel);override; procedure a_cmp_reg_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;reg1,reg2 : tregister;l : tasmlabel); override; procedure a_jmp_always(list : TAsmList;l: tasmlabel); override; procedure a_jmp_flags(list : TAsmList;const f : TResFlags;l: tasmlabel); override; procedure g_flags2reg(list: TAsmList; size: TCgSize; const f: tresflags; reg: TRegister); override; - procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : aint);override; + procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint);override; { generates overflow checking code for a node } procedure g_overflowcheck(list: TAsmList; const l:tlocation; def:tdef); override; - procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:aint;destreg:tregister);override; + procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister);override; procedure g_proc_entry(list : TAsmList;localsize : longint;nostackframe:boolean);override; procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean);override; // procedure g_restore_frame_pointer(list : TAsmList);override; -// procedure g_return_from_proc(list : TAsmList;parasize : aint);override; +// procedure g_return_from_proc(list : TAsmList;parasize : tcgint);override; procedure g_restore_registers(list:TAsmList);override; procedure g_save_registers(list:TAsmList);override; @@ -265,7 +265,7 @@ unit cgcpu; end; - procedure tcg68k.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara); + procedure tcg68k.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : tcgint;const cgpara : tcgpara); var pushsize : tcgsize; ref : treference; @@ -292,7 +292,7 @@ unit cgcpu; procedure tcg68k.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara); - procedure pushdata(paraloc:pcgparalocation;ofs:aint); + procedure pushdata(paraloc:pcgparalocation;ofs:tcgint); var pushsize : tcgsize; tmpreg : tregister; @@ -304,7 +304,7 @@ unit cgcpu; { TODO: FIX ME!!! this also triggers location bug } {if (paraloc^.loc<>LOC_REFERENCE) or (paraloc^.reference.index<>NR_STACK_POINTER_REG) or - (tcgsize2size[paraloc^.size]>sizeof(aint)) then + (tcgsize2size[paraloc^.size]>sizeof(tcgint)) then internalerror(200501162);} { Pushes are needed in reverse order, add the size of the @@ -335,7 +335,7 @@ unit cgcpu; end; var - len : aint; + len : tcgint; href : treference; begin {$ifdef DEBUG_CHARLIE} @@ -490,7 +490,7 @@ unit cgcpu; - procedure tcg68k.a_load_const_reg(list : TAsmList;size : tcgsize;a : aint;register : tregister); + procedure tcg68k.a_load_const_reg(list : TAsmList;size : tcgsize;a : tcgint;register : tregister); begin {$ifdef DEBUG_CHARLIE} // writeln('a_load_const_reg'); @@ -512,7 +512,7 @@ unit cgcpu; end; end; - procedure tcg68k.a_load_const_ref(list : TAsmList; tosize: tcgsize; a : aint;const ref : treference); + procedure tcg68k.a_load_const_ref(list : TAsmList; tosize: tcgsize; a : tcgint;const ref : treference); begin {$ifdef DEBUG_CHARLIE} list.concat(tai_comment.create(strpnew('a_load_const_ref'))); @@ -664,7 +664,7 @@ unit cgcpu; end; - procedure tcg68k.a_op_const_reg(list : TAsmList; Op: TOpCG; size: tcgsize; a: aint; reg: TRegister); + procedure tcg68k.a_op_const_reg(list : TAsmList; Op: TOpCG; size: tcgsize; a: tcgint; reg: TRegister); var scratch_reg : tregister; scratch_reg2: tregister; @@ -817,7 +817,7 @@ unit cgcpu; end; { - procedure tcg68k.a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; const ref: TReference); + procedure tcg68k.a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; const ref: TReference); var opcode: tasmop; begin @@ -1045,7 +1045,7 @@ unit cgcpu; - procedure tcg68k.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure tcg68k.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel); var hregister : tregister; @@ -1158,7 +1158,7 @@ unit cgcpu; - procedure tcg68k.g_concatcopy(list : TAsmList;const source,dest : treference;len : aint); + procedure tcg68k.g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint); var helpsize : longint; @@ -1294,7 +1294,7 @@ unit cgcpu; begin end; - procedure tcg68k.g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:aint;destreg:tregister); + procedure tcg68k.g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister); begin end; @@ -1359,7 +1359,7 @@ unit cgcpu; procedure tcg68k.g_proc_exit(list : TAsmList; parasize: longint; nostackframe: boolean); var // r,hregister : TRegister; - localsize: aint; + localsize: tcgint; spr : TRegister; fpr : TRegister; ref : TReference; @@ -1740,8 +1740,8 @@ unit cgcpu; end; end; { end case } end; - - + + procedure create_codegen; begin cg := tcg68k.create; diff --git a/compiler/mips/cgcpu.pas b/compiler/mips/cgcpu.pas index 2071049bb7..f156237034 100644 --- a/compiler/mips/cgcpu.pas +++ b/compiler/mips/cgcpu.pas @@ -44,10 +44,10 @@ type procedure make_simple_ref_fpu(list: tasmlist; var ref: treference); procedure handle_load_store(list: tasmlist; isstore: boolean; op: tasmop; reg: tregister; ref: treference); procedure handle_load_store_fpu(list: tasmlist; isstore: boolean; op: tasmop; reg: tregister; ref: treference); - procedure handle_reg_const_reg(list: tasmlist; op: Tasmop; src: tregister; a: aint; dst: tregister); + procedure handle_reg_const_reg(list: tasmlist; op: Tasmop; src: tregister; a: tcgint; dst: tregister); { parameter } - procedure a_load_const_cgpara(list: tasmlist; size: tcgsize; a: aint; const paraloc: TCGPara); override; + procedure a_load_const_cgpara(list: tasmlist; size: tcgsize; a: tcgint; const paraloc: TCGPara); override; procedure a_load_ref_cgpara(list: tasmlist; sz: tcgsize; const r: TReference; const paraloc: TCGPara); override; procedure a_loadaddr_ref_cgpara(list: tasmlist; const r: TReference; const paraloc: TCGPara); override; procedure a_loadfpu_reg_cgpara(list: tasmlist; size: tcgsize; const r: tregister; const paraloc: TCGPara); override; @@ -55,15 +55,15 @@ type procedure a_call_name(list: tasmlist; const s: string; weak : boolean); override; procedure a_call_reg(list: tasmlist; Reg: TRegister); override; { General purpose instructions } - procedure a_op_const_reg(list: tasmlist; Op: TOpCG; size: tcgsize; a: aint; reg: TRegister); override; + procedure a_op_const_reg(list: tasmlist; Op: TOpCG; size: tcgsize; a: tcgint; reg: TRegister); override; procedure a_op_reg_reg(list: tasmlist; Op: TOpCG; size: TCGSize; src, dst: TRegister); override; - procedure a_op_const_reg_reg(list: tasmlist; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister); override; + procedure a_op_const_reg_reg(list: tasmlist; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister); override; procedure a_op_reg_reg_reg(list: tasmlist; op: TOpCg; size: tcgsize; src1, src2, dst: tregister); override; - procedure a_op_const_reg_reg_checkoverflow(list: tasmlist; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister; setflags: boolean; var ovloc: tlocation); override; + procedure a_op_const_reg_reg_checkoverflow(list: tasmlist; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister; setflags: boolean; var ovloc: tlocation); override; procedure a_op_reg_reg_reg_checkoverflow(list: tasmlist; op: TOpCg; size: tcgsize; src1, src2, dst: tregister; setflags: boolean; var ovloc: tlocation); override; { move instructions } - procedure a_load_const_reg(list: tasmlist; size: tcgsize; a: aint; reg: tregister); override; - procedure a_load_const_ref(list: tasmlist; size: tcgsize; a: aint; const ref: TReference); override; + procedure a_load_const_reg(list: tasmlist; size: tcgsize; a: tcgint; reg: tregister); override; + procedure a_load_const_ref(list: tasmlist; size: tcgsize; a: tcgint; const ref: TReference); override; procedure a_load_reg_ref(list: tasmlist; FromSize, ToSize: TCgSize; reg: TRegister; const ref: TReference); override; procedure a_load_ref_reg(list: tasmlist; FromSize, ToSize: TCgSize; const ref: TReference; reg: tregister); override; procedure a_load_reg_reg(list: tasmlist; FromSize, ToSize: TCgSize; reg1, reg2: tregister); override; @@ -73,7 +73,7 @@ type procedure a_loadfpu_ref_reg(list: tasmlist; fromsize, tosize: tcgsize; const ref: TReference; reg: tregister); override; procedure a_loadfpu_reg_ref(list: tasmlist; fromsize, tosize: tcgsize; reg: tregister; const ref: TReference); override; { comparison operations } - procedure a_cmp_const_reg_label(list: tasmlist; size: tcgsize; cmp_op: topcmp; a: aint; reg: tregister; l: tasmlabel); override; + procedure a_cmp_const_reg_label(list: tasmlist; size: tcgsize; cmp_op: topcmp; a: tcgint; reg: tregister; l: tasmlabel); override; procedure a_cmp_reg_reg_label(list: tasmlist; size: tcgsize; cmp_op: topcmp; reg1, reg2: tregister; l: tasmlabel); override; procedure a_jmp_always(List: tasmlist; l: TAsmLabel); override; procedure a_jmp_name(list: tasmlist; const s: string); override; @@ -82,9 +82,9 @@ type procedure g_overflowCheck_loc(List: tasmlist; const Loc: TLocation; def: TDef; ovloc: tlocation); override; procedure g_proc_entry(list: tasmlist; localsize: longint; nostackframe: boolean); override; procedure g_proc_exit(list: tasmlist; parasize: longint; nostackframe: boolean); override; - procedure g_concatcopy(list: tasmlist; const Source, dest: treference; len: aint); override; - procedure g_concatcopy_unaligned(list: tasmlist; const Source, dest: treference; len: aint); override; - procedure g_concatcopy_move(list: tasmlist; const Source, dest: treference; len: aint); + procedure g_concatcopy(list: tasmlist; const Source, dest: treference; len: tcgint); override; + procedure g_concatcopy_unaligned(list: tasmlist; const Source, dest: treference; len: tcgint); override; + procedure g_concatcopy_move(list: tasmlist; const Source, dest: treference; len: tcgint); procedure g_intf_wrapper(list: tasmlist; procdef: tprocdef; const labelname: string; ioffset: longint); override; end; @@ -474,7 +474,7 @@ begin end; -procedure TCgMPSel.handle_reg_const_reg(list: tasmlist; op: Tasmop; src: tregister; a: aint; dst: tregister); +procedure TCgMPSel.handle_reg_const_reg(list: tasmlist; op: Tasmop; src: tregister; a: tcgint; dst: tregister); var tmpreg: tregister; begin @@ -540,7 +540,7 @@ begin end; -procedure TCgMPSel.a_load_const_cgpara(list: tasmlist; size: tcgsize; a: aint; const paraloc: TCGPara); +procedure TCgMPSel.a_load_const_cgpara(list: tasmlist; size: tcgsize; a: tcgint; const paraloc: TCGPara); var Ref: TReference; begin @@ -680,7 +680,7 @@ end; {********************** load instructions ********************} -procedure TCgMPSel.a_load_const_reg(list: tasmlist; size: TCGSize; a: aint; reg: TRegister); +procedure TCgMPSel.a_load_const_reg(list: tasmlist; size: TCGSize; a: tcgint; reg: TRegister); begin if (a = 0) then list.concat(taicpu.op_reg_reg(A_MOVE, reg, NR_R0)) @@ -698,7 +698,7 @@ begin end; -procedure TCgMPSel.a_load_const_ref(list: tasmlist; size: tcgsize; a: aint; const ref: TReference); +procedure TCgMPSel.a_load_const_ref(list: tasmlist; size: tcgsize; a: tcgint; const ref: TReference); begin if a = 0 then a_load_reg_ref(list, size, size, NR_R0, ref) @@ -962,7 +962,7 @@ begin end; end; -procedure TCgMPSel.a_op_const_reg(list: tasmlist; Op: TOpCG; size: tcgsize; a: aint; reg: TRegister); +procedure TCgMPSel.a_op_const_reg(list: tasmlist; Op: TOpCG; size: tcgsize; a: tcgint; reg: TRegister); var power: longint; tmpreg1: tregister; @@ -1048,7 +1048,7 @@ begin end; -procedure TCgMPSel.a_op_const_reg_reg(list: tasmlist; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister); +procedure TCgMPSel.a_op_const_reg_reg(list: tasmlist; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister); var power: longint; tmpreg1: tregister; @@ -1103,7 +1103,7 @@ begin end; -procedure TCgMPSel.a_op_const_reg_reg_checkoverflow(list: tasmlist; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister; setflags: boolean; var ovloc: tlocation); +procedure TCgMPSel.a_op_const_reg_reg_checkoverflow(list: tasmlist; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister; setflags: boolean; var ovloc: tlocation); var tmpreg1: tregister; begin @@ -1220,7 +1220,7 @@ end; {*************** compare instructructions ****************} -procedure TCgMPSel.a_cmp_const_reg_label(list: tasmlist; size: tcgsize; cmp_op: topcmp; a: aint; reg: tregister; l: tasmlabel); +procedure TCgMPSel.a_cmp_const_reg_label(list: tasmlist; size: tcgsize; cmp_op: topcmp; a: tcgint; reg: tregister; l: tasmlabel); var tmpreg: tregister; begin @@ -1461,7 +1461,7 @@ end; { ************* concatcopy ************ } -procedure TCgMPSel.g_concatcopy_move(list: tasmlist; const Source, dest: treference; len: aint); +procedure TCgMPSel.g_concatcopy_move(list: tasmlist; const Source, dest: treference; len: tcgint); var paraloc1, paraloc2, paraloc3: TCGPara; begin @@ -1488,7 +1488,7 @@ begin end; -procedure TCgMPSel.g_concatcopy(list: tasmlist; const Source, dest: treference; len: aint); +procedure TCgMPSel.g_concatcopy(list: tasmlist; const Source, dest: treference; len: tcgint); var tmpreg1, hreg, countreg: TRegister; src, dst: TReference; @@ -1575,7 +1575,7 @@ begin end; -procedure TCgMPSel.g_concatcopy_unaligned(list: tasmlist; const Source, dest: treference; len: aint); +procedure TCgMPSel.g_concatcopy_unaligned(list: tasmlist; const Source, dest: treference; len: tcgint); var src, dst: TReference; tmpreg1, countreg: TRegister; diff --git a/compiler/powerpc/cgcpu.pas b/compiler/powerpc/cgcpu.pas index 555ece63ef..3ba63ba50b 100644 --- a/compiler/powerpc/cgcpu.pas +++ b/compiler/powerpc/cgcpu.pas @@ -40,16 +40,16 @@ unit cgcpu; procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override; procedure a_call_reg(list : TAsmList;reg: tregister); override; - procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; reg: TRegister); override; + procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; reg: TRegister); override; procedure a_op_reg_reg(list : TAsmList; Op: TOpCG; size: TCGSize; src, dst: TRegister); override; procedure a_op_const_reg_reg(list: TAsmList; op: TOpCg; - size: tcgsize; a: aint; src, dst: tregister); override; + size: tcgsize; a: tcgint; src, dst: tregister); override; procedure a_op_reg_reg_reg(list: TAsmList; op: TOpCg; size: tcgsize; src1, src2, dst: tregister); override; { move instructions } - procedure a_load_const_reg(list : TAsmList; size: tcgsize; a : aint;reg : tregister);override; + procedure a_load_const_reg(list : TAsmList; size: tcgsize; a : tcgint;reg : tregister);override; procedure a_load_ref_reg(list : TAsmList; fromsize, tosize : tcgsize;const Ref : treference;reg : tregister);override; procedure a_load_reg_reg(list : TAsmList; fromsize, tosize : tcgsize;reg1,reg2 : tregister);override; @@ -58,7 +58,7 @@ unit cgcpu; procedure a_load_subsetreg_subsetreg(list: TAsmlist; fromsubsetsize, tosubsetsize: tcgsize; const fromsreg, tosreg: tsubsetregister); override; { comparison operations } - procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel);override; procedure a_cmp_reg_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;reg1,reg2 : tregister;l : tasmlabel); override; @@ -73,7 +73,7 @@ unit cgcpu; procedure g_save_registers(list:TAsmList); override; procedure g_restore_registers(list:TAsmList); override; - procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : aint);override; + procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint);override; { find out whether a is of the form 11..00..11b or 00..11...00. If } { that's the case, we can use rlwinm to do an AND operation } @@ -86,7 +86,7 @@ unit cgcpu; (* NOT IN USE: *) procedure g_stackframe_entry_mac(list : TAsmList;localsize : longint); (* NOT IN USE: *) - procedure g_return_from_proc_mac(list : TAsmList;parasize : aint); + procedure g_return_from_proc_mac(list : TAsmList;parasize : tcgint); { clear out potential overflow bits from 8 or 16 bit operations } { the upper 24/16 bits of a register after an operation } @@ -230,7 +230,7 @@ const {********************** load instructions ********************} - procedure tcgppc.a_load_const_reg(list : TAsmList; size: TCGSize; a : aint; reg : TRegister); + procedure tcgppc.a_load_const_reg(list : TAsmList; size: TCGSize; a : tcgint; reg : TRegister); begin if not(size in [OS_8,OS_S8,OS_16,OS_S16,OS_32,OS_S32]) then @@ -386,7 +386,7 @@ const end; - procedure tcgppc.a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; reg: TRegister); + procedure tcgppc.a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; reg: TRegister); begin a_op_const_reg_reg(list,op,size,a,reg,reg); @@ -411,7 +411,7 @@ const procedure tcgppc.a_op_const_reg_reg(list: TAsmList; op: TOpCg; - size: tcgsize; a: aint; src, dst: tregister); + size: tcgsize; a: tcgint; src, dst: tregister); var l1,l2: longint; oplo, ophi: tasmop; @@ -584,14 +584,14 @@ const begin if (not (size in [OS_32, OS_S32])) then begin internalerror(2008091307); - end; + end; list.concat(taicpu.op_reg_reg_const_const_const(A_RLWINM, dst, src, a and 31, 0, 31)); end; OP_ROR: begin if (not (size in [OS_32, OS_S32])) then begin internalerror(2008091308); - end; + end; list.concat(taicpu.op_reg_reg_const_const_const(A_RLWINM, dst, src, (32 - a) and 31, 0, 31)); end else @@ -656,7 +656,7 @@ const {*************** compare instructructions ****************} - procedure tcgppc.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure tcgppc.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel); var @@ -1006,7 +1006,7 @@ const regcounter,firstregfpu,firstregint: TsuperRegister; href : treference; usesfpr,usesgpr,genret : boolean; - localsize: aint; + localsize: tcgint; begin { AltiVec context restore, not yet implemented !!! } @@ -1129,7 +1129,7 @@ const var regcounter,firstregfpu,firstreggpr: TSuperRegister; usesfpr,usesgpr: boolean; href : treference; - offset: aint; + offset: tcgint; regcounter2, firstfpureg: Tsuperregister; begin usesfpr:=false; @@ -1369,7 +1369,7 @@ const end; end; - procedure tcgppc.g_return_from_proc_mac(list : TAsmList;parasize : aint); + procedure tcgppc.g_return_from_proc_mac(list : TAsmList;parasize : tcgint); (* NOT IN USE *) var @@ -1426,7 +1426,7 @@ const maxmoveunit = 4; {$endif use8byteconcatcopy} - procedure tcgppc.g_concatcopy(list : TAsmList;const source,dest : treference;len : aint); + procedure tcgppc.g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint); var countreg: TRegister; @@ -1742,8 +1742,8 @@ const case op of OP_AND,OP_OR,OP_XOR: begin - cg.a_op_const_reg_reg(list,op,OS_32,aint(value),regsrc.reglo,regdst.reglo); - cg.a_op_const_reg_reg(list,op,OS_32,aint(value shr 32),regsrc.reghi, + cg.a_op_const_reg_reg(list,op,OS_32,tcgint(value),regsrc.reglo,regdst.reglo); + cg.a_op_const_reg_reg(list,op,OS_32,tcgint(value shr 32),regsrc.reghi, regdst.reghi); end; OP_ADD, OP_SUB: @@ -1771,7 +1771,7 @@ const else if ((value shr 32) = 0) then begin tmpreg := tcgppc(cg).rg[R_INTREGISTER].getregister(list,R_SUBWHOLE); - cg.a_load_const_reg(list,OS_32,aint(value),tmpreg); + cg.a_load_const_reg(list,OS_32,tcgint(value),tmpreg); list.concat(taicpu.op_reg_reg_reg(ops[issub,2], regdst.reglo,regsrc.reglo,tmpreg)); list.concat(taicpu.op_reg_reg(ops[issub,3], @@ -1788,7 +1788,7 @@ const else begin cg.a_load_reg_reg(list,OS_INT,OS_INT,regsrc.reglo,regdst.reglo); - cg.a_op_const_reg_reg(list,op,OS_32,aint(value shr 32),regsrc.reghi, + cg.a_op_const_reg_reg(list,op,OS_32,tcgint(value shr 32),regsrc.reghi, regdst.reghi); end; end; @@ -1803,5 +1803,5 @@ const cg := tcgppc.create; cg64 :=tcg64fppc.create; end; - + end. diff --git a/compiler/ppcgen/cgppc.pas b/compiler/ppcgen/cgppc.pas index ddd9c0589c..c03e9a8215 100644 --- a/compiler/ppcgen/cgppc.pas +++ b/compiler/ppcgen/cgppc.pas @@ -34,7 +34,7 @@ unit cgppc; type tcgppcgen = class(tcg) - procedure a_load_const_cgpara(list: TAsmList; size: tcgsize; a: aint; const paraloc : tcgpara); override; + procedure a_load_const_cgpara(list: TAsmList; size: tcgsize; a: tcgint; const paraloc : tcgpara); override; procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : tcgpara); override; procedure a_call_reg(list : TAsmList;reg: tregister); override; @@ -117,7 +117,7 @@ unit cgppc; if (assigned(ref.symbol)) then result := result + ref.symbol.name; end; - + function cgsize2string(const size : TCgSize) : string; const cgsize_strings : array[TCgSize] of string[8] = ( @@ -128,7 +128,7 @@ unit cgppc; begin result := cgsize_strings[size]; end; - + function cgop2string(const op : TOpCg) : String; const opcg_strings : array[TOpCg] of string[6] = ( @@ -139,7 +139,7 @@ unit cgppc; result := opcg_strings[op]; end; {$endif extdebug} - + function tcgppcgen.hasLargeOffset(const ref : TReference) : Boolean; begin @@ -151,13 +151,13 @@ unit cgppc; begin result:= (not (po_assembler in current_procinfo.procdef.procoptions) and - ((pi_do_call in current_procinfo.flags) or + ((pi_do_call in current_procinfo.flags) or (cs_profile in init_settings.moduleswitches))) or ([cs_lineinfo,cs_debuginfo] * current_settings.moduleswitches <> []); end; - procedure tcgppcgen.a_load_const_cgpara(list: TAsmList; size: tcgsize; a: aint; const + procedure tcgppcgen.a_load_const_cgpara(list: TAsmList; size: tcgsize; a: tcgint; const paraloc: tcgpara); var ref: treference; @@ -751,21 +751,21 @@ unit cgppc; reference_reset_symbol(ref,l,0,sizeof(pint)); ref.base := NR_R2; ref.refaddr := addr_pic; - + result := rg[R_INTREGISTER].getregister(list, R_SUBWHOLE); {$IFDEF EXTDEBUG} list.concat(tai_comment.create(strpnew('loading got reference for ' + symbol))); {$ENDIF EXTDEBUG} // cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,ref,result); - + {$ifdef cpu64bitaddr} list.concat(taicpu.op_reg_ref(A_LD, result, ref)); {$else cpu64bitaddr} list.concat(taicpu.op_reg_ref(A_LWZ, result, ref)); {$endif cpu64bitaddr} end; - - + + function tcgppcgen.fixref(list: TAsmList; var ref: treference): boolean; var tmpreg: tregister; @@ -813,7 +813,7 @@ unit cgppc; { if we have to create PIC, add the symbol to the TOC/GOT } if (target_info.system = system_powerpc64_linux) and - (cs_create_pic in current_settings.moduleswitches) and + (cs_create_pic in current_settings.moduleswitches) and (assigned(ref.symbol)) then begin tmpreg := load_got_symbol(list, ref.symbol.name); diff --git a/compiler/sparc/cgcpu.pas b/compiler/sparc/cgcpu.pas index a4bb9db949..c539beb41b 100644 --- a/compiler/sparc/cgcpu.pas +++ b/compiler/sparc/cgcpu.pas @@ -44,9 +44,9 @@ interface { sparc special, needed by cg64 } procedure make_simple_ref(list:TAsmList;var ref: treference); procedure handle_load_store(list:TAsmList;isstore:boolean;op: tasmop;reg:tregister;ref: treference); - procedure handle_reg_const_reg(list:TAsmList;op:Tasmop;src:tregister;a:aint;dst:tregister); + procedure handle_reg_const_reg(list:TAsmList;op:Tasmop;src:tregister;a:tcgint;dst:tregister); { parameter } - procedure a_load_const_cgpara(list:TAsmList;size:tcgsize;a:aint;const paraloc:TCGPara);override; + procedure a_load_const_cgpara(list:TAsmList;size:tcgsize;a:tcgint;const paraloc:TCGPara);override; procedure a_load_ref_cgpara(list:TAsmList;sz:tcgsize;const r:TReference;const paraloc:TCGPara);override; procedure a_loadaddr_ref_cgpara(list:TAsmList;const r:TReference;const paraloc:TCGPara);override; procedure a_loadfpu_reg_cgpara(list : TAsmList;size : tcgsize;const r : tregister;const paraloc : TCGPara);override; @@ -55,15 +55,15 @@ interface procedure a_call_reg(list:TAsmList;Reg:TRegister);override; { General purpose instructions } procedure maybeadjustresult(list: TAsmList; op: TOpCg; size: tcgsize; dst: tregister); - procedure a_op_const_reg(list:TAsmList;Op:TOpCG;size:tcgsize;a:aint;reg:TRegister);override; + procedure a_op_const_reg(list:TAsmList;Op:TOpCG;size:tcgsize;a:tcgint;reg:TRegister);override; procedure a_op_reg_reg(list:TAsmList;Op:TOpCG;size:TCGSize;src, dst:TRegister);override; - procedure a_op_const_reg_reg(list:TAsmList;op:TOpCg;size:tcgsize;a:aint;src, dst:tregister);override; + procedure a_op_const_reg_reg(list:TAsmList;op:TOpCg;size:tcgsize;a:tcgint;src, dst:tregister);override; procedure a_op_reg_reg_reg(list:TAsmList;op:TOpCg;size:tcgsize;src1, src2, dst:tregister);override; - procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation);override; + procedure a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation);override; procedure a_op_reg_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; src1, src2, dst: tregister;setflags : boolean;var ovloc : tlocation);override; { move instructions } - procedure a_load_const_reg(list:TAsmList;size:tcgsize;a:aint;reg:tregister);override; - procedure a_load_const_ref(list:TAsmList;size:tcgsize;a:aint;const ref:TReference);override; + procedure a_load_const_reg(list:TAsmList;size:tcgsize;a:tcgint;reg:tregister);override; + procedure a_load_const_ref(list:TAsmList;size:tcgsize;a:tcgint;const ref:TReference);override; procedure a_load_reg_ref(list:TAsmList;FromSize,ToSize:TCgSize;reg:TRegister;const ref:TReference);override; procedure a_load_ref_reg(list:TAsmList;FromSize,ToSize:TCgSize;const ref:TReference;reg:tregister);override; procedure a_load_reg_reg(list:TAsmList;FromSize,ToSize:TCgSize;reg1,reg2:tregister);override; @@ -73,7 +73,7 @@ interface procedure a_loadfpu_ref_reg(list:TAsmList;fromsize,tosize:tcgsize;const ref:TReference;reg:tregister);override; procedure a_loadfpu_reg_ref(list:TAsmList;fromsize,tosize:tcgsize;reg:tregister;const ref:TReference);override; { comparison operations } - procedure a_cmp_const_reg_label(list:TAsmList;size:tcgsize;cmp_op:topcmp;a:aint;reg:tregister;l:tasmlabel);override; + procedure a_cmp_const_reg_label(list:TAsmList;size:tcgsize;cmp_op:topcmp;a:tcgint;reg:tregister;l:tasmlabel);override; procedure a_cmp_reg_reg_label(list:TAsmList;size:tcgsize;cmp_op:topcmp;reg1,reg2:tregister;l:tasmlabel);override; procedure a_jmp_always(List:TAsmList;l:TAsmLabel);override; procedure a_jmp_name(list : TAsmList;const s : string);override; @@ -86,9 +86,9 @@ interface procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean);override; procedure g_restore_registers(list:TAsmList);override; procedure g_save_registers(list : TAsmList);override; - procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : aint);override; - procedure g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : aint);override; - procedure g_concatcopy_move(list : TAsmList;const source,dest : treference;len : aint); + procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint);override; + procedure g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : tcgint);override; + procedure g_concatcopy_move(list : TAsmList;const source,dest : treference;len : tcgint); procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override; private g1_used : boolean; @@ -108,7 +108,7 @@ interface procedure a_op64_const_reg_reg_checkoverflow(list: TAsmList;op:TOpCG;size : tcgsize;value : int64;regsrc,regdst : tregister64;setflags : boolean;var ovloc : tlocation);override; procedure a_op64_reg_reg_reg_checkoverflow(list: TAsmList;op:TOpCG;size : tcgsize;regsrc1,regsrc2,regdst : tregister64;setflags : boolean;var ovloc : tlocation);override; end; - + procedure create_codegen; const @@ -245,7 +245,7 @@ implementation end; - procedure tcgsparc.handle_reg_const_reg(list:TAsmList;op:Tasmop;src:tregister;a:aint;dst:tregister); + procedure tcgsparc.handle_reg_const_reg(list:TAsmList;op:Tasmop;src:tregister;a:tcgint;dst:tregister); var tmpreg : tregister; begin @@ -258,7 +258,7 @@ implementation begin tmpreg:=NR_G1; g1_used:=true; - end; + end; a_load_const_reg(list,OS_INT,a,tmpreg); list.concat(taicpu.op_reg_reg_reg(op,src,tmpreg,dst)); if tmpreg=NR_G1 then @@ -322,7 +322,7 @@ implementation end; - procedure TCgSparc.a_load_const_cgpara(list:TAsmList;size:tcgsize;a:aint;const paraloc:TCGPara); + procedure TCgSparc.a_load_const_cgpara(list:TAsmList;size:tcgsize;a:tcgint;const paraloc:TCGPara); var Ref:TReference; begin @@ -375,7 +375,7 @@ implementation begin tmpreg:=NR_G1; g1_used:=true; - end; + end; a_load_ref_reg(list,sz,sz,r,tmpreg); a_load_reg_ref(list,sz,sz,tmpreg,ref); if tmpreg=NR_G1 then @@ -487,7 +487,7 @@ implementation {********************** load instructions ********************} - procedure TCgSparc.a_load_const_reg(list : TAsmList;size : TCGSize;a : aint;reg : TRegister); + procedure TCgSparc.a_load_const_reg(list : TAsmList;size : TCGSize;a : tcgint;reg : TRegister); begin { we don't use the set instruction here because it could be evalutated to two instructions which would cause problems with the delay slot (FK) } @@ -506,7 +506,7 @@ implementation end; - procedure TCgSparc.a_load_const_ref(list : TAsmList;size : tcgsize;a : aint;const ref : TReference); + procedure TCgSparc.a_load_const_ref(list : TAsmList;size : tcgsize;a : tcgint;const ref : TReference); begin if a=0 then a_load_reg_ref(list,size,size,NR_G0,ref) @@ -795,7 +795,7 @@ implementation end; - procedure TCgSparc.a_op_const_reg(list:TAsmList;Op:TOpCG;size:tcgsize;a:aint;reg:TRegister); + procedure TCgSparc.a_op_const_reg(list:TAsmList;Op:TOpCG;size:tcgsize;a:tcgint;reg:TRegister); begin if Op in [OP_NEG,OP_NOT] then internalerror(200306011); @@ -833,7 +833,7 @@ implementation end; - procedure TCgSparc.a_op_const_reg_reg(list:TAsmList;op:TOpCg;size:tcgsize;a:aint;src, dst:tregister); + procedure TCgSparc.a_op_const_reg_reg(list:TAsmList;op:TOpCg;size:tcgsize;a:tcgint;src, dst:tregister); var power : longInt; begin @@ -870,7 +870,7 @@ implementation end; - procedure tcgsparc.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: aint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); + procedure tcgsparc.a_op_const_reg_reg_checkoverflow(list: TAsmList; op: TOpCg; size: tcgsize; a: tcgint; src, dst: tregister;setflags : boolean;var ovloc : tlocation); var power : longInt; tmpreg1,tmpreg2 : tregister; @@ -955,7 +955,7 @@ implementation {*************** compare instructructions ****************} - procedure TCgSparc.a_cmp_const_reg_label(list:TAsmList;size:tcgsize;cmp_op:topcmp;a:aint;reg:tregister;l:tasmlabel); + procedure TCgSparc.a_cmp_const_reg_label(list:TAsmList;size:tcgsize;cmp_op:topcmp;a:tcgint;reg:tregister;l:tasmlabel); begin if (a=0) then list.concat(taicpu.op_reg_reg_reg(A_SUBcc,reg,NR_G0,NR_G0)) @@ -1166,7 +1166,7 @@ implementation { ************* concatcopy ************ } - procedure tcgsparc.g_concatcopy_move(list : TAsmList;const source,dest : treference;len : aint); + procedure tcgsparc.g_concatcopy_move(list : TAsmList;const source,dest : treference;len : tcgint); var paraloc1,paraloc2,paraloc3 : TCGPara; begin @@ -1193,7 +1193,7 @@ implementation end; - procedure TCgSparc.g_concatcopy(list:TAsmList;const source,dest:treference;len:aint); + procedure TCgSparc.g_concatcopy(list:TAsmList;const source,dest:treference;len:tcgint); var tmpreg1, hreg, @@ -1286,7 +1286,7 @@ implementation end; - procedure tcgsparc.g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : aint); + procedure tcgsparc.g_concatcopy_unaligned(list : TAsmList;const source,dest : treference;len : tcgint); var src, dst: TReference; tmpreg1, @@ -1383,7 +1383,7 @@ implementation { mov 0(%rdi),%rax ; load vmt} reference_reset_base(href,NR_O0,0,sizeof(pint)); cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_G1); - g1_used:=true; + g1_used:=true; { jmp *vmtoffs(%eax) ; method offs } reference_reset_base(href,NR_G1,tobjectdef(procdef.struct).vmtmethodoffset(procdef.extnumber),sizeof(pint)); list.concat(taicpu.op_ref_reg(A_LD,href,NR_G1)); @@ -1524,8 +1524,8 @@ implementation internalerror(200306017); end; get_64bit_ops(op,op1,op2,false); - tcgsparc(cg).handle_reg_const_reg(list,op1,regdst.reglo,aint(lo(value)),regdst.reglo); - tcgsparc(cg).handle_reg_const_reg(list,op2,regdst.reghi,aint(hi(value)),regdst.reghi); + tcgsparc(cg).handle_reg_const_reg(list,op1,regdst.reglo,tcgint(lo(value)),regdst.reglo); + tcgsparc(cg).handle_reg_const_reg(list,op2,regdst.reghi,tcgint(hi(value)),regdst.reghi); end; @@ -1555,8 +1555,8 @@ implementation internalerror(200306017); end; get_64bit_ops(op,op1,op2,setflags); - tcgsparc(cg).handle_reg_const_reg(list,op1,regsrc.reglo,aint(lo(value)),regdst.reglo); - tcgsparc(cg).handle_reg_const_reg(list,op2,regsrc.reghi,aint(hi(value)),regdst.reghi); + tcgsparc(cg).handle_reg_const_reg(list,op1,regsrc.reglo,tcgint(lo(value)),regdst.reglo); + tcgsparc(cg).handle_reg_const_reg(list,op2,regsrc.reghi,tcgint(hi(value)),regdst.reghi); end; @@ -1580,5 +1580,5 @@ implementation cg:=TCgSparc.Create; cg64:=TCg64Sparc.Create; end; - + end. diff --git a/compiler/x86/cgx86.pas b/compiler/x86/cgx86.pas index d67099c3b4..7ce393e370 100644 --- a/compiler/x86/cgx86.pas +++ b/compiler/x86/cgx86.pas @@ -57,15 +57,15 @@ unit cgx86; procedure a_call_ref(list : TAsmList;ref : treference);override; procedure a_call_name_static(list : TAsmList;const s : string);override; - procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; reg: TRegister); override; - procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; const ref: TReference); override; + procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; reg: TRegister); override; + procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; const ref: TReference); override; procedure a_op_reg_reg(list : TAsmList; Op: TOpCG; size: TCGSize; src, dst: TRegister); override; procedure a_op_ref_reg(list : TAsmList; Op: TOpCG; size: TCGSize; const ref: TReference; reg: TRegister); override; procedure a_op_reg_ref(list : TAsmList; Op: TOpCG; size: TCGSize;reg: TRegister; const ref: TReference); override; { move instructions } - procedure a_load_const_reg(list : TAsmList; tosize: tcgsize; a : aint;reg : tregister);override; - procedure a_load_const_ref(list : TAsmList; tosize: tcgsize; a : aint;const ref : treference);override; + procedure a_load_const_reg(list : TAsmList; tosize: tcgsize; a : tcgint;reg : tregister);override; + procedure a_load_const_ref(list : TAsmList; tosize: tcgsize; a : tcgint;const ref : treference);override; procedure a_load_reg_ref(list : TAsmList;fromsize,tosize: tcgsize; reg : tregister;const ref : treference);override; procedure a_load_ref_reg(list : TAsmList;fromsize,tosize: tcgsize;const ref : treference;reg : tregister);override; procedure a_load_reg_reg(list : TAsmList;fromsize,tosize: tcgsize;reg1,reg2 : tregister);override; @@ -87,9 +87,9 @@ unit cgx86; procedure a_opmm_reg_reg(list: TAsmList; Op: TOpCG; size : tcgsize;src,dst: tregister;shuffle : pmmshuffle);override; { comparison operations } - procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel);override; - procedure a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;const ref : treference; + procedure a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;const ref : treference; l : tasmlabel);override; procedure a_cmp_reg_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;reg1,reg2 : tregister;l : tasmlabel); override; procedure a_cmp_ref_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;const ref: treference; reg : tregister; l : tasmlabel); override; @@ -102,7 +102,7 @@ unit cgx86; procedure g_flags2reg(list: TAsmList; size: TCgSize; const f: tresflags; reg: TRegister); override; procedure g_flags2ref(list: TAsmList; size: TCgSize; const f: tresflags; const ref: TReference); override; - procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : aint);override; + procedure g_concatcopy(list : TAsmList;const source,dest : treference;len : tcgint);override; { entry/exit code helpers } procedure g_profilecode(list : TAsmList);override; @@ -767,7 +767,7 @@ unit cgx86; {********************** load instructions ********************} - procedure tcgx86.a_load_const_reg(list : TAsmList; tosize: TCGSize; a : aint; reg : TRegister); + procedure tcgx86.a_load_const_reg(list : TAsmList; tosize: TCGSize; a : tcgint; reg : TRegister); begin check_register_size(tosize,reg); @@ -777,7 +777,7 @@ unit cgx86; end; - procedure tcgx86.a_load_const_ref(list : TAsmList; tosize: tcgsize; a : aint;const ref : treference); + procedure tcgx86.a_load_const_ref(list : TAsmList; tosize: tcgsize; a : tcgint;const ref : treference); var tmpref : treference; begin @@ -1315,7 +1315,7 @@ unit cgx86; end; - procedure tcgx86.a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; reg: TRegister); + procedure tcgx86.a_op_const_reg(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; reg: TRegister); var opcode : tasmop; @@ -1426,7 +1426,7 @@ unit cgx86; end; - procedure tcgx86.a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; const ref: TReference); + procedure tcgx86.a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: tcgint; const ref: TReference); var opcode: tasmop; power: longint; @@ -1642,7 +1642,7 @@ unit cgx86; {*************** compare instructructions ****************} - procedure tcgx86.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; + procedure tcgx86.a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;reg : tregister; l : tasmlabel); {$ifdef x86_64} @@ -1669,7 +1669,7 @@ unit cgx86; end; - procedure tcgx86.a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;const ref : treference; + procedure tcgx86.a_cmp_const_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : tcgint;const ref : treference; l : tasmlabel); var @@ -1789,7 +1789,7 @@ unit cgx86; { ************* concatcopy ************ } - procedure Tcgx86.g_concatcopy(list:TAsmList;const source,dest:Treference;len:aint); + procedure Tcgx86.g_concatcopy(list:TAsmList;const source,dest:Treference;len:tcgint); const {$ifdef cpu64bitalu} @@ -1806,7 +1806,7 @@ unit cgx86; var srcref,dstref:Treference; r,r0,r1,r2,r3:Tregister; - helpsize:aint; + helpsize:tcgint; copysize:byte; cgsize:Tcgsize; cm:copymode;