paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-11-10 18:19:39 +01:00
Code Issues Packages Projects Releases Wiki Activity

* record alignment splitted in fieldalignment and recordalignment,

Browse Source 
the latter is used when this record is inserted in another record.
This commit is contained in:
peter 2004-01-28 20:30:18 +00:00
parent 0b8ffc2fb2
commit 2d8d788211
5 changed files with 85 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
compiler/nobj.pas
View File

@ -1007,12 +1007,9 @@ implementation
{ allocate a pointer in the object memory } { allocate a pointer in the object memory }
with tobjectsymtable(_class.symtable) do with tobjectsymtable(_class.symtable) do
begin begin
if (dataalignment>=pointer_size) then datasize:=align(datasize,min(POINTER_SIZE,fieldalignment));
datasize:=align(datasize,dataalignment)
else
datasize:=align(datasize,pointer_size);
_class.implementedinterfaces.ioffsets(i)^:=datasize; _class.implementedinterfaces.ioffsets(i)^:=datasize;
datasize:=datasize+pointer_size; inc(datasize,POINTER_SIZE);
end; end;
{ write vtbl } { write vtbl }
gintfcreatevtbl(i,rawdata,rawcode); gintfcreatevtbl(i,rawdata,rawcode);
@ -1370,7 +1367,11 @@ initialization
end. end.
{ {
$Log$ $Log$
Revision 1.58 2004-01-21 14:22:00 florian Revision 1.59 2004-01-28 20:30:18 peter
* record alignment splitted in fieldalignment and recordalignment,
the latter is used when this record is inserted in another record.
Revision 1.58 2004/01/21 14:22:00 florian
+ reintroduce implemented + reintroduce implemented
Revision 1.57 2003/12/08 22:34:24 peter Revision 1.57 2003/12/08 22:34:24 peter

18
compiler/pdecvar.pas
View File

@ -1073,7 +1073,7 @@ implementation
Uniondef.owner:=symtablestack.defowner.owner; Uniondef.owner:=symtablestack.defowner.owner;
registerdef:=true; registerdef:=true;
startvarrecsize:=UnionSymtable.datasize; startvarrecsize:=UnionSymtable.datasize;
startvarrecalign:=UnionSymtable.dataalignment; startvarrecalign:=UnionSymtable.fieldalignment;
symtablestack:=UnionSymtable; symtablestack:=UnionSymtable;
repeat repeat
repeat repeat
@ -1096,10 +1096,10 @@ implementation
consume(_RKLAMMER); consume(_RKLAMMER);
{ calculates maximal variant size } { calculates maximal variant size }
maxsize:=max(maxsize,unionsymtable.datasize); maxsize:=max(maxsize,unionsymtable.datasize);
maxalignment:=max(maxalignment,unionsymtable.dataalignment); maxalignment:=max(maxalignment,unionsymtable.fieldalignment);
{ the items of the next variant are overlayed } { the items of the next variant are overlayed }
unionsymtable.datasize:=startvarrecsize; unionsymtable.datasize:=startvarrecsize;
unionsymtable.dataalignment:=startvarrecalign; unionsymtable.fieldalignment:=startvarrecalign;
if (token<>_END) and (token<>_RKLAMMER) then if (token<>_END) and (token<>_RKLAMMER) then
consume(_SEMICOLON) consume(_SEMICOLON)
else else
@ -1107,7 +1107,7 @@ implementation
until (token=_END) or (token=_RKLAMMER); until (token=_END) or (token=_RKLAMMER);
{ at last set the record size to that of the biggest variant } { at last set the record size to that of the biggest variant }
unionsymtable.datasize:=maxsize; unionsymtable.datasize:=maxsize;
unionsymtable.dataalignment:=maxalignment; unionsymtable.fieldalignment:=maxalignment;
uniontype.def:=uniondef; uniontype.def:=uniondef;
uniontype.sym:=nil; uniontype.sym:=nil;
UnionSym:=tvarsym.create('$case',vs_value,uniontype); UnionSym:=tvarsym.create('$case',vs_value,uniontype);
@ -1135,8 +1135,8 @@ implementation
usedalign:=used_align(maxalignment,minalignment,maxalignment); usedalign:=used_align(maxalignment,minalignment,maxalignment);
offset:=align(trecordsymtable(symtablestack).datasize,usedalign); offset:=align(trecordsymtable(symtablestack).datasize,usedalign);
trecordsymtable(symtablestack).datasize:=offset+unionsymtable.datasize; trecordsymtable(symtablestack).datasize:=offset+unionsymtable.datasize;
if maxalignment>trecordsymtable(symtablestack).dataalignment then if maxalignment>trecordsymtable(symtablestack).fieldalignment then
trecordsymtable(symtablestack).dataalignment:=maxalignment; trecordsymtable(symtablestack).fieldalignment:=maxalignment;
Unionsymtable.Insert_in(trecordsymtable(symtablestack),offset); Unionsymtable.Insert_in(trecordsymtable(symtablestack),offset);
Unionsym.owner:=nil; Unionsym.owner:=nil;
unionsym.free; unionsym.free;
@ -1152,7 +1152,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.59 2003-12-10 16:37:01 peter Revision 1.60 2004-01-28 20:30:18 peter
* record alignment splitted in fieldalignment and recordalignment,
the latter is used when this record is inserted in another record.
Revision 1.59 2003/12/10 16:37:01 peter
* global property support for fpc modes * global property support for fpc modes
Revision 1.58 2003/11/23 17:05:15 peter Revision 1.58 2003/11/23 17:05:15 peter

9
compiler/ptype.pas
View File

@ -244,7 +244,8 @@ implementation
typecanbeforward:=storetypecanbeforward; typecanbeforward:=storetypecanbeforward;
current_object_option:=old_object_option; current_object_option:=old_object_option;
{ may be scale record size to a size of n*4 ? } { may be scale record size to a size of n*4 ? }
trecordsymtable(symtablestack).datasize:=align(trecordsymtable(symtablestack).datasize,trecordsymtable(symtablestack).dataalignment); trecordsymtable(symtablestack).datasize:=align(trecordsymtable(symtablestack).datasize,
trecordsymtable(symtablestack).fieldalignment);
{ restore symtable stack } { restore symtable stack }
symtablestack:=symtable.next; symtablestack:=symtable.next;
end; end;
@ -643,7 +644,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.60 2003-10-21 18:16:13 peter Revision 1.61 2004-01-28 20:30:18 peter
* record alignment splitted in fieldalignment and recordalignment,
the latter is used when this record is inserted in another record.
Revision 1.60 2003/10/21 18:16:13 peter
* IncompatibleTypes() added that will include unit names when * IncompatibleTypes() added that will include unit names when
the typenames are the same the typenames are the same

60
compiler/symdef.pas
View File

@ -3047,9 +3047,9 @@ implementation
{ recordalign -1 means C record packing, that starts { recordalign -1 means C record packing, that starts
with an alignment of 1 } with an alignment of 1 }
if aktalignment.recordalignmax=-1 then if aktalignment.recordalignmax=-1 then
trecordsymtable(symtable).dataalignment:=1 trecordsymtable(symtable).fieldalignment:=1
else else
trecordsymtable(symtable).dataalignment:=aktalignment.recordalignmax; trecordsymtable(symtable).fieldalignment:=aktalignment.recordalignmax;
isunion:=false; isunion:=false;
end; end;
@ -3061,7 +3061,8 @@ implementation
savesize:=ppufile.getlongint; savesize:=ppufile.getlongint;
symtable:=trecordsymtable.create; symtable:=trecordsymtable.create;
trecordsymtable(symtable).datasize:=ppufile.getlongint; trecordsymtable(symtable).datasize:=ppufile.getlongint;
trecordsymtable(symtable).dataalignment:=ppufile.getbyte; trecordsymtable(symtable).fieldalignment:=ppufile.getbyte;
trecordsymtable(symtable).recordalignment:=ppufile.getbyte;
trecordsymtable(symtable).ppuload(ppufile); trecordsymtable(symtable).ppuload(ppufile);
symtable.defowner:=self; symtable.defowner:=self;
isunion:=false; isunion:=false;
@ -3120,7 +3121,8 @@ implementation
inherited ppuwritedef(ppufile); inherited ppuwritedef(ppufile);
ppufile.putlongint(savesize); ppufile.putlongint(savesize);
ppufile.putlongint(trecordsymtable(symtable).datasize); ppufile.putlongint(trecordsymtable(symtable).datasize);
ppufile.putbyte(trecordsymtable(symtable).dataalignment); ppufile.putbyte(trecordsymtable(symtable).fieldalignment);
ppufile.putbyte(trecordsymtable(symtable).recordalignment);
ppufile.writeentry(ibrecorddef); ppufile.writeentry(ibrecorddef);
trecordsymtable(symtable).ppuwrite(ppufile); trecordsymtable(symtable).ppuwrite(ppufile);
end; end;
@ -3133,36 +3135,8 @@ implementation
function trecorddef.alignment:longint; function trecorddef.alignment:longint;
var
l : longint;
hp : tvarsym;
begin begin
{ also check the first symbol for it's size, because a alignment:=trecordsymtable(symtable).recordalignment;
packed record has dataalignment of 1, but the first
sym could be a longint which should be aligned on 4 bytes,
this is compatible with C record packing (PFV) }
hp:=tvarsym(symtable.symindex.first);
if assigned(hp) then
begin
if hp.vartype.def.deftype in [recorddef,arraydef] then
l:=hp.vartype.def.alignment
else
l:=hp.vartype.def.size;
if l>trecordsymtable(symtable).dataalignment then
begin
if l>=4 then
alignment:=4
else
if l>=2 then
alignment:=2
else
alignment:=1;
end
else
alignment:=trecordsymtable(symtable).dataalignment;
end
else
alignment:=trecordsymtable(symtable).dataalignment;
end; end;
@ -4700,9 +4674,9 @@ implementation
{ recordalign -1 means C record packing, that starts { recordalign -1 means C record packing, that starts
with an alignment of 1 } with an alignment of 1 }
if aktalignment.recordalignmax=-1 then if aktalignment.recordalignmax=-1 then
tobjectsymtable(symtable).dataalignment:=1 tobjectsymtable(symtable).fieldalignment:=1
else else
tobjectsymtable(symtable).dataalignment:=aktalignment.recordalignmax; tobjectsymtable(symtable).fieldalignment:=aktalignment.recordalignmax;
lastvtableindex:=0; lastvtableindex:=0;
set_parent(c); set_parent(c);
objname:=stringdup(upper(n)); objname:=stringdup(upper(n));
@ -4763,7 +4737,8 @@ implementation
symtable:=tobjectsymtable.create(objrealname^); symtable:=tobjectsymtable.create(objrealname^);
tobjectsymtable(symtable).datasize:=ppufile.getlongint; tobjectsymtable(symtable).datasize:=ppufile.getlongint;
tobjectsymtable(symtable).dataalignment:=ppufile.getbyte; tobjectsymtable(symtable).fieldalignment:=ppufile.getbyte;
tobjectsymtable(symtable).recordalignment:=ppufile.getbyte;
tobjectsymtable(symtable).ppuload(ppufile); tobjectsymtable(symtable).ppuload(ppufile);
symtable.defowner:=self; symtable.defowner:=self;
@ -4832,7 +4807,8 @@ implementation
end; end;
ppufile.putlongint(tobjectsymtable(symtable).datasize); ppufile.putlongint(tobjectsymtable(symtable).datasize);
ppufile.putbyte(tobjectsymtable(symtable).dataalignment); ppufile.putbyte(tobjectsymtable(symtable).fieldalignment);
ppufile.putbyte(tobjectsymtable(symtable).recordalignment);
ppufile.writeentry(ibobjectdef); ppufile.writeentry(ibobjectdef);
tobjectsymtable(symtable).ppuwrite(ppufile); tobjectsymtable(symtable).ppuwrite(ppufile);
@ -4938,7 +4914,7 @@ implementation
else else
begin begin
tobjectsymtable(symtable).datasize:=align(tobjectsymtable(symtable).datasize, tobjectsymtable(symtable).datasize:=align(tobjectsymtable(symtable).datasize,
tobjectsymtable(symtable).dataalignment); tobjectsymtable(symtable).fieldalignment);
vmt_offset:=tobjectsymtable(symtable).datasize; vmt_offset:=tobjectsymtable(symtable).datasize;
inc(tobjectsymtable(symtable).datasize,POINTER_SIZE); inc(tobjectsymtable(symtable).datasize,POINTER_SIZE);
include(objectoptions,oo_has_vmt); include(objectoptions,oo_has_vmt);
@ -5045,7 +5021,7 @@ implementation
function tobjectdef.alignment:longint; function tobjectdef.alignment:longint;
begin begin
alignment:=tobjectsymtable(symtable).dataalignment; alignment:=tobjectsymtable(symtable).recordalignment;
end; end;
@ -6185,7 +6161,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.210 2004-01-27 10:29:32 daniel Revision 1.211 2004-01-28 20:30:18 peter
* record alignment splitted in fieldalignment and recordalignment,
the latter is used when this record is inserted in another record.
Revision 1.210 2004/01/27 10:29:32 daniel
* Fix string type stab generation. String constant still unsupported. * Fix string type stab generation. String constant still unsupported.
Revision 1.209 2004/01/26 19:54:42 daniel Revision 1.209 2004/01/26 19:54:42 daniel

69
compiler/symtable.pas
View File

@ -93,7 +93,8 @@ interface
tabstractrecordsymtable = class(tstoredsymtable) tabstractrecordsymtable = class(tstoredsymtable)
public public
datasize : longint; datasize : longint;
dataalignment : byte; recordalignment, { alignment required when inserting this record }
fieldalignment : byte; { alignment used when fields are inserted }
constructor create(const n:string); constructor create(const n:string);
procedure ppuload(ppufile:tcompilerppufile);override; procedure ppuload(ppufile:tcompilerppufile);override;
procedure ppuwrite(ppufile:tcompilerppufile);override; procedure ppuwrite(ppufile:tcompilerppufile);override;
@ -978,7 +979,7 @@ implementation
begin begin
inherited create(n); inherited create(n);
datasize:=0; datasize:=0;
dataalignment:=1; fieldalignment:=1;
end; end;
@ -1040,52 +1041,56 @@ implementation
procedure tabstractrecordsymtable.insertfield(sym : tvarsym;addsym:boolean); procedure tabstractrecordsymtable.insertfield(sym : tvarsym;addsym:boolean);
var var
l,varalign : longint; l,
varalignrecord,
varalignfield,
varalign : longint;
vardef : tdef; vardef : tdef;
begin begin
if addsym then if addsym then
insert(sym); insert(sym);
{ Calculate field offset }
l:=tvarsym(sym).getvaluesize;
vardef:=tvarsym(sym).vartype.def;
{ this symbol can't be loaded to a register } { this symbol can't be loaded to a register }
exclude(tvarsym(sym).varoptions,vo_regable); exclude(tvarsym(sym).varoptions,vo_regable);
exclude(tvarsym(sym).varoptions,vo_fpuregable); exclude(tvarsym(sym).varoptions,vo_fpuregable);
{ get the alignment size } { Calculate field offset }
l:=tvarsym(sym).getvaluesize;
vardef:=tvarsym(sym).vartype.def;
varalign:=vardef.alignment;
{ Calc the alignment size for C style records }
if (aktalignment.recordalignmax=-1) then if (aktalignment.recordalignmax=-1) then
begin begin
varalign:=vardef.alignment;
if (varalign>4) and if (varalign>4) and
((varalign mod 4)<>0) and ((varalign mod 4)<>0) and
(vardef.deftype=arraydef) then (vardef.deftype=arraydef) then
Message1(sym_w_wrong_C_pack,vardef.typename); Message1(sym_w_wrong_C_pack,vardef.typename);
if varalign=0 then if varalign=0 then
varalign:=l; varalign:=l;
if (dataalignment<aktalignment.maxCrecordalign) then if (fieldalignment<aktalignment.maxCrecordalign) then
begin begin
if (varalign>16) and (dataalignment<32) then if (varalign>16) and (fieldalignment<32) then
dataalignment:=32 fieldalignment:=32
else if (varalign>12) and (dataalignment<16) then else if (varalign>12) and (fieldalignment<16) then
dataalignment:=16 fieldalignment:=16
{ 12 is needed for long double } { 12 is needed for long double }
else if (varalign>8) and (dataalignment<12) then else if (varalign>8) and (fieldalignment<12) then
dataalignment:=12 fieldalignment:=12
else if (varalign>4) and (dataalignment<8) then else if (varalign>4) and (fieldalignment<8) then
dataalignment:=8 fieldalignment:=8
else if (varalign>2) and (dataalignment<4) then else if (varalign>2) and (fieldalignment<4) then
dataalignment:=4 fieldalignment:=4
else if (varalign>1) and (dataalignment<2) then else if (varalign>1) and (fieldalignment<2) then
dataalignment:=2; fieldalignment:=2;
end;
fieldalignment:=min(fieldalignment,aktalignment.maxCrecordalign);
end; end;
dataalignment:=min(dataalignment,aktalignment.maxCrecordalign);
end
else
varalign:=vardef.alignment;
if varalign=0 then if varalign=0 then
varalign:=size_2_align(l); varalign:=size_2_align(l);
varalign:=used_align(varalign,aktalignment.recordalignmin,dataalignment); varalignfield:=used_align(varalign,aktalignment.recordalignmin,fieldalignment);
tvarsym(sym).fieldoffset:=align(datasize,varalign); tvarsym(sym).fieldoffset:=align(datasize,varalignfield);
datasize:=tvarsym(sym).fieldoffset+l; datasize:=tvarsym(sym).fieldoffset+l;
{ Calc alignment needed for this record }
varalignrecord:=used_align(varalign,aktalignment.recordalignmin,aktalignment.recordalignmax);
recordalignment:=max(recordalignment,varalignrecord);
end; end;
@ -1112,7 +1117,7 @@ implementation
storesize,storealign : longint; storesize,storealign : longint;
begin begin
storesize:=tsymt.datasize; storesize:=tsymt.datasize;
storealign:=tsymt.dataalignment; storealign:=tsymt.fieldalignment;
tsymt.datasize:=offset; tsymt.datasize:=offset;
ps:=tvarsym(symindex.first); ps:=tvarsym(symindex.first);
while assigned(ps) do while assigned(ps) do
@ -1143,7 +1148,7 @@ implementation
pd:=npd; pd:=npd;
end; end;
tsymt.datasize:=storesize; tsymt.datasize:=storesize;
tsymt.dataalignment:=storealign; tsymt.fieldalignment:=storealign;
end; end;
@ -2297,7 +2302,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.126 2004-01-26 16:12:28 daniel Revision 1.127 2004-01-28 20:30:18 peter
* record alignment splitted in fieldalignment and recordalignment,
the latter is used when this record is inserted in another record.
Revision 1.126 2004/01/26 16:12:28 daniel
* reginfo now also only allocated during register allocation * reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto * third round of gdb cleanups: kick out most of concatstabto