paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-11-04 17:45:28 +01:00
Code Issues Packages Projects Releases Wiki Activity

* -Or fixes

Browse Source
This commit is contained in:
peter 2004-10-24 20:10:08 +00:00
parent fd759e521f
commit 30d25d1d2b
2 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
compiler/x86/cgx86.pas
View File

@ -483,6 +483,7 @@ unit cgx86;
var var
op: tasmop; op: tasmop;
s: topsize; s: topsize;
tmpsize : tcgsize;
tmpreg : tregister; tmpreg : tregister;
begin begin
check_register_size(fromsize,reg); check_register_size(fromsize,reg);
@ -499,10 +500,15 @@ unit cgx86;
which clears the upper 64 bit too, so it could be that s is S_L while the reg is which clears the upper 64 bit too, so it could be that s is S_L while the reg is
64 bit (FK) } 64 bit (FK) }
if s in [S_BL,S_WL,S_L] then if s in [S_BL,S_WL,S_L] then
begin
tmpreg:=makeregsize(list,tmpreg,OS_32); tmpreg:=makeregsize(list,tmpreg,OS_32);
tmpsize:=OS_32;
end
else
tmpsize:=tosize;
{$endif x86_64} {$endif x86_64}
list.concat(taicpu.op_reg_reg(op,s,reg,tmpreg)); list.concat(taicpu.op_reg_reg(op,s,reg,tmpreg));
a_load_reg_ref(list,tosize,tosize,tmpreg,ref); a_load_reg_ref(list,tmpsize,tosize,tmpreg,ref);
end; end;
else else
list.concat(taicpu.op_reg_ref(op,s,reg,ref)); list.concat(taicpu.op_reg_ref(op,s,reg,ref));
@ -1674,7 +1680,10 @@ unit cgx86;
end. end.
{ {
$Log$ $Log$
Revision 1.130 2004-10-24 11:44:28 peter Revision 1.131 2004-10-24 20:10:08 peter
* -Or fixes
Revision 1.130 2004/10/24 11:44:28 peter
* small regvar fixes * small regvar fixes
* loadref parameter removed from concatcopy,incrrefcount,etc * loadref parameter removed from concatcopy,incrrefcount,etc

77
compiler/x86/nx86set.pas
View File

@ -46,8 +46,8 @@ implementation
aasmbase,aasmtai,aasmcpu, aasmbase,aasmtai,aasmcpu,
cgbase,pass_2, cgbase,pass_2,
ncon, ncon,
cpubase,cpuinfo,procinfo, cpubase,
cga,cgutils,cgobj,ncgutil, cga,cgobj,ncgutil,
cgx86; cgx86;
{***************************************************************************** {*****************************************************************************
@ -85,15 +85,13 @@ implementation
genjumps, genjumps,
use_small, use_small,
ranges : boolean; ranges : boolean;
hr,hr2, hreg,hreg2,
pleftreg : tregister; pleftreg : tregister;
href : treference;
opsize : tcgsize; opsize : tcgsize;
setparts : array[1..8] of Tsetpart; setparts : array[1..8] of Tsetpart;
i,numparts : byte; i,numparts : byte;
adjustment : longint; adjustment : longint;
l,l2 : tasmlabel; l,l2 : tasmlabel;
r : Tregister;
{$ifdef CORRECT_SET_IN_FPC} {$ifdef CORRECT_SET_IN_FPC}
AM : tasmop; AM : tasmop;
{$endif CORRECT_SET_IN_FPC} {$endif CORRECT_SET_IN_FPC}
@ -244,7 +242,6 @@ implementation
{ "x in [y..z]" expression } { "x in [y..z]" expression }
adjustment := 0; adjustment := 0;
r:=NR_NO;
for i:=1 to numparts do for i:=1 to numparts do
if setparts[i].range then if setparts[i].range then
{ use fact that a <= x <= b <=> cardinal(x-a) <= cardinal(b-a) } { use fact that a <= x <= b <=> cardinal(x-a) <= cardinal(b-a) }
@ -254,26 +251,17 @@ implementation
begin begin
{ yes, is the lower bound <> 0? } { yes, is the lower bound <> 0? }
if (setparts[i].start <> 0) then if (setparts[i].start <> 0) then
{ we're going to substract from the left register, } begin
{ so in case of a LOC_CREGISTER first move the value }
{ to edi (not done before because now we can do the }
{ move and substract in one instruction with LEA) }
if (left.location.loc = LOC_CREGISTER) then if (left.location.loc = LOC_CREGISTER) then
begin begin
r:=cg.getintregister(exprasmlist,OS_32); hreg:=cg.getintregister(exprasmlist,OS_INT);
reference_reset_base(href,pleftreg,-setparts[i].start); cg.a_load_reg_reg(exprasmlist,opsize,OS_INT,pleftreg,hreg);
cg.a_loadaddr_ref_reg(exprasmlist,href,r); pleftreg:=hreg;
{ only now change pleftreg since previous value is } opsize:=OS_INT;
{ still used in previous instruction } end;
pleftreg := r;
opsize := OS_32;
end
else
begin
{ otherwise, the value is already in a register }
{ that can be modified }
cg.a_op_const_reg(exprasmlist,OP_SUB,opsize,setparts[i].start-adjustment,pleftreg); cg.a_op_const_reg(exprasmlist,OP_SUB,opsize,setparts[i].start-adjustment,pleftreg);
end; end;
{ new total value substracted from x: } { new total value substracted from x: }
{ adjustment + (setparts[i].start - adjustment) } { adjustment + (setparts[i].start - adjustment) }
adjustment := setparts[i].start; adjustment := setparts[i].start;
@ -347,16 +335,16 @@ implementation
LOC_REGISTER, LOC_REGISTER,
LOC_CREGISTER: LOC_CREGISTER:
begin begin
hr:=cg.makeregsize(exprasmlist,left.location.register,OS_32); hreg:=cg.makeregsize(exprasmlist,left.location.register,OS_32);
cg.a_load_reg_reg(exprasmlist,left.location.size,OS_32,left.location.register,hr); cg.a_load_reg_reg(exprasmlist,left.location.size,OS_32,left.location.register,hreg);
end; end;
else else
begin begin
{ the set element isn't never samller than a byte { the set element isn't never samller than a byte
and because it's a small set we need only 5 bits and because it's a small set we need only 5 bits
but 8 bits are easier to load } but 8 bits are easier to load }
hr:=cg.getintregister(exprasmlist,OS_32); hreg:=cg.getintregister(exprasmlist,OS_32);
cg.a_load_ref_reg(exprasmlist,OS_8,OS_32,left.location.reference,hr); cg.a_load_ref_reg(exprasmlist,OS_8,OS_32,left.location.reference,hreg);
end; end;
end; end;
@ -364,20 +352,20 @@ implementation
LOC_REGISTER, LOC_REGISTER,
LOC_CREGISTER : LOC_CREGISTER :
begin begin
emit_reg_reg(A_BT,S_L,hr,right.location.register); emit_reg_reg(A_BT,S_L,hreg,right.location.register);
end; end;
LOC_CONSTANT : LOC_CONSTANT :
begin begin
{ We have to load the value into a register because { We have to load the value into a register because
btl does not accept values only refs or regs (PFV) } btl does not accept values only refs or regs (PFV) }
hr2:=cg.getintregister(exprasmlist,OS_32); hreg2:=cg.getintregister(exprasmlist,OS_32);
cg.a_load_const_reg(exprasmlist,OS_32,right.location.value,hr2); cg.a_load_const_reg(exprasmlist,OS_32,right.location.value,hreg2);
emit_reg_reg(A_BT,S_L,hr,hr2); emit_reg_reg(A_BT,S_L,hreg,hreg2);
end; end;
LOC_CREFERENCE, LOC_CREFERENCE,
LOC_REFERENCE : LOC_REFERENCE :
begin begin
emit_reg_ref(A_BT,S_L,hr,right.location.reference); emit_reg_ref(A_BT,S_L,hreg,right.location.reference);
end; end;
else else
internalerror(2002032210); internalerror(2002032210);
@ -401,18 +389,18 @@ implementation
LOC_REGISTER, LOC_REGISTER,
LOC_CREGISTER: LOC_CREGISTER:
begin begin
hr:=cg.makeregsize(exprasmlist,left.location.register,OS_32); hreg:=cg.makeregsize(exprasmlist,left.location.register,OS_32);
cg.a_load_reg_reg(exprasmlist,left.location.size,OS_32,left.location.register,hr); cg.a_load_reg_reg(exprasmlist,left.location.size,OS_32,left.location.register,hreg);
cg.a_cmp_const_reg_label(exprasmlist,OS_32,OC_BE,31,hr,l); cg.a_cmp_const_reg_label(exprasmlist,OS_32,OC_BE,31,hreg,l);
{ reset carry flag } { reset carry flag }
exprasmlist.concat(taicpu.op_none(A_CLC,S_NO)); exprasmlist.concat(taicpu.op_none(A_CLC,S_NO));
cg.a_jmp_always(exprasmlist,l2); cg.a_jmp_always(exprasmlist,l2);
cg.a_label(exprasmlist,l); cg.a_label(exprasmlist,l);
{ We have to load the value into a register because { We have to load the value into a register because
btl does not accept values only refs or regs (PFV) } btl does not accept values only refs or regs (PFV) }
hr2:=cg.getintregister(exprasmlist,OS_32); hreg2:=cg.getintregister(exprasmlist,OS_32);
cg.a_load_const_reg(exprasmlist,OS_32,right.location.value,hr2); cg.a_load_const_reg(exprasmlist,OS_32,right.location.value,hreg2);
emit_reg_reg(A_BT,S_L,hr,hr2); emit_reg_reg(A_BT,S_L,hreg,hreg2);
end; end;
else else
begin begin
@ -433,13 +421,13 @@ implementation
exprasmlist.concat(taicpu.op_none(A_CLC,S_NO)); exprasmlist.concat(taicpu.op_none(A_CLC,S_NO));
cg.a_jmp_always(exprasmlist,l2); cg.a_jmp_always(exprasmlist,l2);
cg.a_label(exprasmlist,l); cg.a_label(exprasmlist,l);
hr:=cg.getintregister(exprasmlist,OS_32); hreg:=cg.getintregister(exprasmlist,OS_32);
cg.a_load_ref_reg(exprasmlist,OS_32,OS_32,left.location.reference,hr); cg.a_load_ref_reg(exprasmlist,OS_32,OS_32,left.location.reference,hreg);
{ We have to load the value into a register because { We have to load the value into a register because
btl does not accept values only refs or regs (PFV) } btl does not accept values only refs or regs (PFV) }
hr2:=cg.getintregister(exprasmlist,OS_32); hreg2:=cg.getintregister(exprasmlist,OS_32);
cg.a_load_const_reg(exprasmlist,OS_32,right.location.value,hr2); cg.a_load_const_reg(exprasmlist,OS_32,right.location.value,hreg2);
emit_reg_reg(A_BT,S_L,hr,hr2); emit_reg_reg(A_BT,S_L,hreg,hreg2);
end; end;
end; end;
cg.a_label(exprasmlist,l2); cg.a_label(exprasmlist,l2);
@ -475,7 +463,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.6 2004-10-01 17:32:16 peter Revision 1.7 2004-10-24 20:10:08 peter
* -Or fixes
Revision 1.6 2004/10/01 17:32:16 peter
* fix resizing of LOC_CREGISTER * fix resizing of LOC_CREGISTER
Revision 1.5 2004/09/25 14:23:55 peter Revision 1.5 2004/09/25 14:23:55 peter