From dec97dea7321816213b2eeaaa8db3d51cc313ff5 Mon Sep 17 00:00:00 2001 From: Jonas Maebe Date: Tue, 1 Aug 2006 20:42:29 +0000 Subject: [PATCH] * forgot to commit in previous revision git-svn-id: trunk@4325 - --- compiler/cgobj.pas | 154 ++++++++++++++++++++++++--------------------- 1 file changed, 84 insertions(+), 70 deletions(-) diff --git a/compiler/cgobj.pas b/compiler/cgobj.pas index 7cb416f0a5..de4a1b934f 100644 --- a/compiler/cgobj.pas +++ b/compiler/cgobj.pas @@ -68,6 +68,8 @@ unit cgobj; procedure init_register_allocators;virtual; {# Clean up the register allocators needed for the codegenerator.} procedure done_register_allocators;virtual; + {# Set the spill location of a register } + procedure set_spill_temp(reg: tregister; const ref: treference); {# Set whether live_start or live_end should be updated when allocating registers, needed when e.g. generating initcode after the rest of the code. } procedure set_regalloc_extend_backwards(b: boolean); @@ -212,16 +214,16 @@ unit cgobj; procedure a_load_ref_ref(list : TAsmList;fromsize,tosize : tcgsize;const sref : treference;const dref : treference);virtual; procedure a_load_loc_reg(list : TAsmList;tosize: tcgsize; const loc: tlocation; reg : tregister); procedure a_load_loc_ref(list : TAsmList;tosize: tcgsize; const loc: tlocation; const ref : treference); - procedure a_load_loc_subsetreg(list : TAsmList;subsetregsize,subsetsize: tcgsize; startbit: byte; const loc: tlocation; subsetreg : tregister); + procedure a_load_loc_subsetreg(list : TAsmList;subsetsize: tcgsize; const loc: tlocation; const sreg : tsubsetregister); procedure a_loadaddr_ref_reg(list : TAsmList;const ref : treference;r : tregister);virtual; abstract; - procedure a_load_subsetreg_reg(list : TAsmList; subsetregsize, subsetsize: tcgsize; startbit: byte; tosize: tcgsize; subsetreg, destreg: tregister); virtual; - procedure a_load_reg_subsetreg(list : TAsmList; fromsize: tcgsize; subsetregsize, subsetsize: tcgsize; startbit: byte; fromreg, subsetreg: tregister); virtual; - procedure a_load_subsetreg_subsetreg(list: TAsmlist; fromsubsetregsize, fromsubsetsize: tcgsize; fromstartbit: byte; tosubsetregsize, tosubsetsize: tcgsize; tostartbit: byte; fromsubsetreg, tosubsetreg: tregister); virtual; - procedure a_load_subsetreg_ref(list : TAsmList; subsetregsize, subsetsize: tcgsize; startbit: byte; tosize: tcgsize; subsetreg: tregister; const destref: treference); virtual; - procedure a_load_ref_subsetreg(list : TAsmList; fromsize, subsetregsize, subsetsize: tcgsize; startbit: byte; const fromref: treference; subsetreg: tregister); virtual; - procedure a_load_const_subsetreg(list: TAsmlist; subsetregsize, subsetsize: tcgsize; startbit: byte; a: aint; subsetreg: tregister); virtual; - procedure a_load_subsetreg_loc(list: TAsmlist; subsetregsize, subsetsize: tcgsize; startbit: byte; subsetreg: tregister; const loc: tlocation); virtual; + procedure a_load_subsetreg_reg(list : TAsmList; subsetsize, tosize: tcgsize; const sreg: tsubsetregister; destreg: tregister); virtual; + procedure a_load_reg_subsetreg(list : TAsmList; fromsize, subsetsize: tcgsize; fromreg: tregister; const sreg: tsubsetregister); virtual; + procedure a_load_subsetreg_subsetreg(list: TAsmlist; fromsubsetsize, tosubsetregsize : 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_subsetreg_loc(list: TAsmlist; subsetsize: tcgsize; const sreg: tsubsetregister; const loc: tlocation); virtual; { fpu move instructions } procedure a_loadfpu_reg_reg(list: TAsmList; size:tcgsize; reg1, reg2: tregister); virtual; abstract; @@ -253,12 +255,12 @@ unit cgobj; { 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, subsetregsize, subsetsize : TCGSize; startbit: byte; a : aint; subsetreg: TRegister); virtual; + procedure a_op_const_subsetreg(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : aint; const sreg: tsubsetregister); virtual; procedure a_op_const_loc(list : TAsmList; Op: TOpCG; a: Aint; 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; - procedure a_op_reg_subsetreg(list : TAsmList; Op : TOpCG; opsize, subsetregsize, subsetsize : TCGSize; startbit: byte; reg, subsetreg: TRegister); virtual; + procedure a_op_reg_subsetreg(list : TAsmList; Op : TOpCG; opsize, subsetsize : TCGSize; reg: TRegister; const sreg: tsubsetregister); virtual; procedure a_op_reg_loc(list : TAsmList; Op: TOpCG; reg: tregister; const loc: tlocation); procedure a_op_ref_loc(list : TAsmList; Op: TOpCG; const ref: TReference; const loc: tlocation); @@ -280,7 +282,7 @@ unit cgobj; 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; procedure a_cmp_reg_ref_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;reg : tregister; const ref: treference; l : tasmlabel); virtual; - procedure a_cmp_subsetreg_reg_label(list : TAsmList; subsetregsize, subsetsize : tcgsize; startbit : byte; cmpsize : tcgsize; cmp_op : topcmp; subsetreg, reg : tregister; l : tasmlabel); virtual; + procedure a_cmp_subsetreg_reg_label(list : TAsmList; subsetsize, cmpsize : tcgsize; cmp_op : topcmp; const sreg: tsubsetregister; reg : tregister; l : tasmlabel); virtual; procedure a_cmp_loc_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp; const loc: tlocation; reg : tregister; l : tasmlabel); procedure a_cmp_reg_loc_label(list : TAsmList;size : tcgsize;cmp_op : topcmp; reg: tregister; const loc: tlocation; l : tasmlabel); @@ -701,6 +703,18 @@ implementation end; + procedure tcg.set_spill_temp(reg: tregister; const ref: treference); + var + rt : tregistertype; + begin + rt:=getregtype(reg); + if assigned(rg[rt]) then + rg[rt].set_spill_temp(getsupreg(reg),ref) + else + internalerror(2006072702); + end; + + procedure tcg.set_regalloc_extend_backwards(b: boolean); var rt : tregistertype; @@ -879,91 +893,91 @@ implementation {$define overflowon} {$endif} - procedure tcg.a_load_subsetreg_reg(list : TAsmList; subsetregsize, subsetsize: tcgsize; startbit: byte; tosize: tcgsize; subsetreg, destreg: tregister); + procedure tcg.a_load_subsetreg_reg(list : TAsmList; subsetsize, tosize: tcgsize; const sreg: tsubsetregister; destreg: tregister); var bitmask: aint; tmpreg: tregister; stopbit: byte; begin - tmpreg:=getintregister(list,subsetregsize); - a_op_const_reg_reg(list,OP_SHR,subsetregsize,startbit,subsetreg,tmpreg); - stopbit := startbit+(tcgsize2size[subsetsize] * 8); + tmpreg:=getintregister(list,sreg.subsetregsize); + a_op_const_reg_reg(list,OP_SHR,sreg.subsetregsize,sreg.startbit,sreg.subsetreg,tmpreg); + stopbit := sreg.startbit + sreg.bitlen; // on x86(64), 1 shl 32(64) = 1 instead of 0 - if (stopbit - startbit <> AIntBits) then - bitmask := (1 shl (stopbit-startbit)) - 1 + if (stopbit - sreg.startbit <> AIntBits) then + bitmask := (1 shl (stopbit - sreg.startbit)) - 1 else bitmask := -1; - a_op_const_reg(list,OP_AND,subsetregsize,bitmask,tmpreg); + a_op_const_reg(list,OP_AND,sreg.subsetregsize,bitmask,tmpreg); tmpreg := makeregsize(list,tmpreg,subsetsize); a_load_reg_reg(list,tcgsize2unsigned[subsetsize],subsetsize,tmpreg,tmpreg); a_load_reg_reg(list,subsetsize,tosize,tmpreg,destreg); end; - procedure tcg.a_load_reg_subsetreg(list : TAsmList; fromsize: tcgsize; subsetregsize, subsetsize: tcgsize; startbit: byte; fromreg, subsetreg: tregister); + procedure tcg.a_load_reg_subsetreg(list : TAsmList; fromsize, subsetsize: tcgsize; fromreg: tregister; const sreg: tsubsetregister); var bitmask: aint; tmpreg: tregister; stopbit: byte; begin - stopbit := startbit+(tcgsize2size[subsetsize] * 8); + stopbit := sreg.startbit + sreg.bitlen; // on x86(64), 1 shl 32(64) = 1 instead of 0 if (stopbit <> AIntBits) then - bitmask := not(((1 shl stopbit)-1) xor ((1 shl startbit)-1)) + bitmask := not(((1 shl stopbit)-1) xor ((1 shl sreg.startbit)-1)) else - bitmask := not(-1 xor ((1 shl startbit)-1)); - tmpreg:=getintregister(list,subsetregsize); - a_load_reg_reg(list,fromsize,subsetregsize,fromreg,tmpreg); - a_op_const_reg(list,OP_SHL,subsetregsize,startbit,tmpreg); - a_op_const_reg(list,OP_AND,subsetregsize,not(bitmask),tmpreg); - a_op_const_reg(list,OP_AND,subsetregsize,bitmask,subsetreg); - a_op_reg_reg(list,OP_OR,subsetregsize,tmpreg,subsetreg); + bitmask := not(-1 xor ((1 shl sreg.startbit)-1)); + tmpreg:=getintregister(list,sreg.subsetregsize); + a_load_reg_reg(list,fromsize,sreg.subsetregsize,fromreg,tmpreg); + a_op_const_reg(list,OP_SHL,sreg.subsetregsize,sreg.startbit,tmpreg); + a_op_const_reg(list,OP_AND,sreg.subsetregsize,not(bitmask),tmpreg); + a_op_const_reg(list,OP_AND,sreg.subsetregsize,bitmask,sreg.subsetreg); + a_op_reg_reg(list,OP_OR,sreg.subsetregsize,tmpreg,sreg.subsetreg); end; - procedure tcg.a_load_subsetreg_subsetreg(list: TAsmlist; fromsubsetregsize, fromsubsetsize: tcgsize; fromstartbit: byte; tosubsetregsize, tosubsetsize: tcgsize; tostartbit: byte; fromsubsetreg, tosubsetreg: tregister); + procedure tcg.a_load_subsetreg_subsetreg(list: TAsmlist; fromsubsetsize, tosubsetregsize : tcgsize; const fromsreg, tosreg: tsubsetregister); var tmpreg: tregister; begin - tmpreg := getintregister(list,tosubsetsize); - a_load_subsetreg_reg(list,fromsubsetregsize,fromsubsetsize,fromstartbit,tosubsetsize,fromsubsetreg,tmpreg); - a_load_reg_subsetreg(list,tosubsetsize,tosubsetregsize,tosubsetsize,tostartbit,tmpreg,tosubsetreg); + tmpreg := getintregister(list,tosubsetregsize); + a_load_subsetreg_reg(list,fromsubsetsize,tosubsetregsize,fromsreg,tmpreg); + a_load_reg_subsetreg(list,tosubsetregsize,tosubsetregsize,tmpreg,tosreg); end; - procedure tcg.a_load_subsetreg_ref(list : TAsmList; subsetregsize, subsetsize: tcgsize; startbit: byte; tosize: tcgsize; subsetreg: tregister; const destref: treference); + procedure tcg.a_load_subsetreg_ref(list : TAsmList; subsetsize, tosize: tcgsize; const sreg: tsubsetregister; const destref: treference); var tmpreg: tregister; begin tmpreg := getintregister(list,tosize); - a_load_subsetreg_reg(list,subsetregsize,subsetsize,startbit,tosize,subsetreg,tmpreg); + a_load_subsetreg_reg(list,subsetsize,tosize,sreg,tmpreg); a_load_reg_ref(list,tosize,tosize,tmpreg,destref); end; - procedure tcg.a_load_ref_subsetreg(list : TAsmList; fromsize, subsetregsize, subsetsize: tcgsize; startbit: byte; const fromref: treference; subsetreg: tregister); + procedure tcg.a_load_ref_subsetreg(list : TAsmList; fromsize, subsetsize: tcgsize; const fromref: treference; const sreg: tsubsetregister); var tmpreg: tregister; begin tmpreg := getintregister(list,subsetsize); a_load_ref_reg(list,fromsize,subsetsize,fromref,tmpreg); - a_load_reg_subsetreg(list,subsetsize,subsetregsize,subsetsize,startbit,tmpreg,subsetreg); + a_load_reg_subsetreg(list,subsetsize,subsetsize,tmpreg,sreg); end; - procedure tcg.a_load_const_subsetreg(list: TAsmlist; subsetregsize, subsetsize: tcgsize; startbit: byte; a: aint; subsetreg: tregister); + procedure tcg.a_load_const_subsetreg(list: TAsmlist; subsetsize: tcgsize; a: aint; const sreg: tsubsetregister); var bitmask: aint; stopbit: byte; begin - stopbit := startbit+(tcgsize2size[subsetsize] * 8); + stopbit := sreg.startbit + sreg.bitlen; // on x86(64), 1 shl 32(64) = 1 instead of 0 if (stopbit <> AIntBits) then - bitmask := not(((1 shl stopbit)-1) xor ((1 shl startbit)-1)) + bitmask := not(((1 shl stopbit)-1) xor ((1 shl sreg.startbit)-1)) else - bitmask := (1 shl startbit) - 1; - a_op_const_reg(list,OP_AND,subsetregsize,bitmask,subsetreg); - a_op_const_reg(list,OP_OR,subsetregsize,(a shl startbit) and not(bitmask),subsetreg); + bitmask := (1 shl sreg.startbit) - 1; + a_op_const_reg(list,OP_AND,sreg.subsetregsize,bitmask,sreg.subsetreg); + a_op_const_reg(list,OP_OR,sreg.subsetregsize,(a shl sreg.startbit) and not(bitmask),sreg.subsetreg); end; @@ -1009,7 +1023,7 @@ implementation LOC_REGISTER,LOC_CREGISTER: a_load_const_reg(list,loc.size,a,loc.register); LOC_SUBSETREG,LOC_CSUBSETREG: - a_load_const_subsetreg(list,loc.subsetregsize,loc.size,loc.startbit,a,loc.subsetreg); + a_load_const_subsetreg(list,loc.size,a,loc.sreg); else internalerror(200203272); end; @@ -1024,7 +1038,7 @@ implementation LOC_REGISTER,LOC_CREGISTER: a_load_reg_reg(list,fromsize,loc.size,reg,loc.register); LOC_SUBSETREG,LOC_CSUBSETREG: - a_load_reg_subsetreg(list,fromsize,loc.subsetregsize,loc.size,loc.startbit,reg,loc.subsetreg); + a_load_reg_subsetreg(list,fromsize,loc.size,reg,loc.sreg); else internalerror(200203271); end; @@ -1041,7 +1055,7 @@ implementation LOC_CONSTANT: a_load_const_reg(list,tosize,loc.value,reg); LOC_SUBSETREG,LOC_CSUBSETREG: - a_load_subsetreg_reg(list,loc.subsetregsize,loc.size,loc.startbit,tosize,loc.subsetreg,reg); + a_load_subsetreg_reg(list,loc.size,tosize,loc.sreg,reg); else internalerror(200109092); end; @@ -1058,39 +1072,39 @@ implementation LOC_CONSTANT: a_load_const_ref(list,tosize,loc.value,ref); LOC_SUBSETREG,LOC_CSUBSETREG: - a_load_subsetreg_ref(list,loc.subsetregsize,loc.size,loc.startbit,tosize,loc.subsetreg,ref); + a_load_subsetreg_ref(list,loc.size,tosize,loc.sreg,ref); else internalerror(200109302); end; end; - procedure tcg.a_load_loc_subsetreg(list : TAsmList;subsetregsize,subsetsize: tcgsize; startbit: byte; const loc: tlocation; subsetreg : tregister); + procedure tcg.a_load_loc_subsetreg(list : TAsmList; subsetsize: tcgsize; const loc: tlocation; const sreg : tsubsetregister); begin case loc.loc of LOC_REFERENCE,LOC_CREFERENCE: - a_load_ref_subsetreg(list,loc.size,subsetregsize,subsetsize,startbit,loc.reference,subsetreg); + a_load_ref_subsetreg(list,loc.size,subsetsize,loc.reference,sreg); LOC_REGISTER,LOC_CREGISTER: - a_load_reg_subsetreg(list,loc.size,subsetregsize,subsetsize,startbit,loc.register,subsetreg); + a_load_reg_subsetreg(list,loc.size,subsetsize,loc.register,sreg); LOC_CONSTANT: - a_load_const_subsetreg(list,subsetregsize,subsetsize,startbit,loc.value,subsetreg); + a_load_const_subsetreg(list,subsetsize,loc.value,sreg); LOC_SUBSETREG,LOC_CSUBSETREG: - a_load_subsetreg_subsetreg(list,loc.subsetregsize,loc.size,loc.startbit,subsetregsize,subsetsize,startbit,loc.subsetreg,subsetreg); + a_load_subsetreg_subsetreg(list,loc.size,subsetsize,loc.sreg,sreg); else internalerror(2006052310); end; end; - procedure tcg.a_load_subsetreg_loc(list: TAsmlist; subsetregsize, subsetsize: tcgsize; startbit: byte; subsetreg: tregister; const loc: tlocation); + procedure tcg.a_load_subsetreg_loc(list: TAsmlist; subsetsize: tcgsize; const sreg: tsubsetregister; const loc: tlocation); begin case loc.loc of LOC_REFERENCE,LOC_CREFERENCE: - a_load_subsetreg_ref(list,subsetregsize,subsetsize,startbit,loc.size,subsetreg,loc.reference); + a_load_subsetreg_ref(list,subsetsize,loc.size,sreg,loc.reference); LOC_REGISTER,LOC_CREGISTER: - a_load_subsetreg_reg(list,subsetregsize,subsetsize,startbit,loc.size,subsetreg,loc.register); + a_load_subsetreg_reg(list,subsetsize,loc.size,sreg,loc.register); LOC_SUBSETREG,LOC_CSUBSETREG: - a_load_subsetreg_subsetreg(list,subsetregsize,subsetsize,startbit,loc.subsetregsize,loc.size,loc.startbit,subsetreg,loc.subsetreg); + a_load_subsetreg_subsetreg(list,subsetsize,loc.size,sreg,loc.sreg); else internalerror(2006051510); end; @@ -1252,14 +1266,14 @@ implementation end; - procedure tcg.a_op_const_subsetreg(list : TAsmList; Op : TOpCG; size, subsetregsize, subsetsize : TCGSize; startbit: byte; a : aint; subsetreg: TRegister); + procedure tcg.a_op_const_subsetreg(list : TAsmList; Op : TOpCG; size, subsetsize : TCGSize; a : aint; const sreg: tsubsetregister); var tmpreg: tregister; begin tmpreg := cg.getintregister(list, size); - a_load_subsetreg_reg(list,subsetregsize,subsetsize,startbit,size,subsetreg,tmpreg); + a_load_subsetreg_reg(list,subsetsize,size,sreg,tmpreg); a_op_const_reg(list,op,size,a,tmpreg); - a_load_reg_subsetreg(list,size,subsetregsize,subsetsize,startbit,tmpreg,subsetreg); + a_load_reg_subsetreg(list,size,subsetsize,tmpreg,sreg); end; @@ -1271,7 +1285,7 @@ implementation LOC_REFERENCE, LOC_CREFERENCE: a_op_const_ref(list,op,loc.size,a,loc.reference); LOC_SUBSETREG, LOC_CSUBSETREG: - a_op_const_subsetreg(list,op,loc.size,loc.subsetregsize,loc.size,loc.startbit,a,loc.subsetreg); + a_op_const_subsetreg(list,op,loc.size,loc.size,a,loc.sreg); else internalerror(200109061); end; @@ -1312,14 +1326,14 @@ implementation end; - procedure tcg.a_op_reg_subsetreg(list : TAsmList; Op : TOpCG; opsize, subsetregsize, subsetsize : TCGSize; startbit: byte; reg, subsetreg: TRegister); + procedure tcg.a_op_reg_subsetreg(list : TAsmList; Op : TOpCG; opsize, subsetsize : TCGSize; reg: TRegister; const sreg: tsubsetregister); var tmpreg: tregister; begin tmpreg := cg.getintregister(list, opsize); - a_load_subsetreg_reg(list,subsetregsize,subsetsize,startbit,opsize,subsetreg,tmpreg); + a_load_subsetreg_reg(list,subsetsize,opsize,sreg,tmpreg); a_op_reg_reg(list,op,opsize,reg,tmpreg); - a_load_reg_subsetreg(list,opsize,subsetregsize,subsetsize,startbit,tmpreg,subsetreg); + a_load_reg_subsetreg(list,opsize,subsetsize,tmpreg,sreg); end; @@ -1332,7 +1346,7 @@ implementation LOC_REFERENCE, LOC_CREFERENCE: a_op_reg_ref(list,op,loc.size,reg,loc.reference); LOC_SUBSETREG, LOC_CSUBSETREG: - a_op_reg_subsetreg(list,op,loc.size,loc.subsetregsize,loc.size,loc.startbit,reg,loc.subsetreg); + a_op_reg_subsetreg(list,op,loc.size,loc.size,reg,loc.sreg); else internalerror(200109061); end; @@ -1357,9 +1371,9 @@ implementation LOC_SUBSETREG, LOC_CSUBSETREG: begin tmpreg:=getintregister(list,loc.size); - a_load_subsetreg_reg(list,loc.subsetregsize,loc.size,loc.startbit,loc.size,loc.subsetreg,tmpreg); + a_load_subsetreg_reg(list,loc.size,loc.size,loc.sreg,tmpreg); a_op_ref_reg(list,op,loc.size,ref,tmpreg); - a_load_reg_subsetreg(list,loc.size,loc.subsetregsize,loc.size,loc.startbit,tmpreg,loc.subsetreg); + a_load_reg_subsetreg(list,loc.size,loc.size,tmpreg,loc.sreg); end; else internalerror(200109061); @@ -1437,7 +1451,7 @@ implementation LOC_SUBSETREG, LOC_CSUBSETREG: begin tmpreg:=getintregister(list,size); - a_load_subsetreg_reg(list,loc.subsetregsize,loc.size,loc.startbit,size,loc.subsetreg,tmpreg); + a_load_subsetreg_reg(list,loc.size,size,loc.sreg,tmpreg); a_cmp_const_reg_label(list,size,cmp_op,a,tmpreg,l); end else @@ -1485,19 +1499,19 @@ implementation a_cmp_const_reg_label(list,size,cmp_op,loc.value,reg,l); LOC_SUBSETREG, LOC_CSUBSETREG: - a_cmp_subsetreg_reg_label(list,loc.subsetregsize,loc.size,loc.startbit,size,cmp_op,loc.subsetreg,reg,l); + a_cmp_subsetreg_reg_label(list,loc.size,size,cmp_op,loc.sreg,reg,l); else internalerror(200203231); end; end; - procedure tcg.a_cmp_subsetreg_reg_label(list : TAsmList; subsetregsize, subsetsize : tcgsize; startbit : byte; cmpsize : tcgsize; cmp_op : topcmp; subsetreg, reg : tregister; l : tasmlabel); + procedure tcg.a_cmp_subsetreg_reg_label(list : TAsmList; subsetsize : tcgsize; cmpsize : tcgsize; cmp_op : topcmp; const sreg: tsubsetregister; reg : tregister; l : tasmlabel); var tmpreg: tregister; begin tmpreg:=getintregister(list, cmpsize); - a_load_subsetreg_reg(list,subsetregsize,subsetsize,startbit,cmpsize,subsetreg,tmpreg); + a_load_subsetreg_reg(list,subsetsize,cmpsize,sreg,tmpreg); a_cmp_reg_reg_label(list,cmpsize,cmp_op,tmpreg,reg,l); end; @@ -1520,7 +1534,7 @@ implementation begin tmpreg:=getintregister(list, size); a_load_ref_reg(list,size,size,loc.reference,tmpreg); - a_cmp_subsetreg_reg_label(list,loc.subsetregsize,loc.size,loc.startbit,size,swap_opcmp(cmp_op),loc.subsetreg,tmpreg,l); + a_cmp_subsetreg_reg_label(list,loc.size,size,swap_opcmp(cmp_op),loc.sreg,tmpreg,l); end; else internalerror(200109061);