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

- removed maxcrecordalign parameter/field from recordsymtables, as this value

Browse Source 
cannot be modified in the settings (so we can directly use the one from
    current_settings)

git-svn-id: trunk@42447 -
This commit is contained in:
Jonas Maebe 2019-07-14 19:24:32 +00:00
parent c932dfaf70
commit d8903ce6b3
19 changed files with 117 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
compiler/aasmcnst.pas
View File

@ -393,7 +393,7 @@ type
maxcrecordalign: specify maximum C record alignment (no equivalent in maxcrecordalign: specify maximum C record alignment (no equivalent in
source code) source code)
} }
function begin_anonymous_record(const optionalname: string; packrecords, recordalign, recordalignmin, maxcrecordalign: shortint): trecorddef; virtual; function begin_anonymous_record(const optionalname: string; packrecords, recordalign, recordalignmin: shortint): trecorddef; virtual;
function end_anonymous_record: trecorddef; virtual; function end_anonymous_record: trecorddef; virtual;
{ add a placeholder element at the current position that later can be { add a placeholder element at the current position that later can be
@ -1399,7 +1399,7 @@ implementation
result.ofs:=0; result.ofs:=0;
{ pack the data, so that we don't add unnecessary null bytes after the { pack the data, so that we don't add unnecessary null bytes after the
constant string } constant string }
begin_anonymous_record('$'+get_dynstring_rec_name(stringtype,false,len),1,sizeof(TConstPtrUInt),1,1); begin_anonymous_record('$'+get_dynstring_rec_name(stringtype,false,len),1,sizeof(TConstPtrUInt),1);
string_symofs:=get_string_symofs(stringtype,false); string_symofs:=get_string_symofs(stringtype,false);
{ encoding } { encoding }
emit_tai(tai_const.create_16bit(encoding),u16inttype); emit_tai(tai_const.create_16bit(encoding),u16inttype);
@ -1611,7 +1611,7 @@ implementation
if (typ<>st_widestring) or if (typ<>st_widestring) or
not winlike then not winlike then
begin begin
result:=crecorddef.create_global_internal('$'+name,1,1,1); result:=crecorddef.create_global_internal('$'+name,1,1);
{ encoding } { encoding }
result.add_field_by_def('',u16inttype); result.add_field_by_def('',u16inttype);
{ element size } { element size }
@ -1637,8 +1637,7 @@ implementation
else else
begin begin
result:=crecorddef.create_global_internal('$'+name,4, result:=crecorddef.create_global_internal('$'+name,4,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ length in bytes } { length in bytes }
result.add_field_by_def('',s32inttype); result.add_field_by_def('',s32inttype);
streledef:=cwidechartype; streledef:=cwidechartype;
@ -1689,8 +1688,7 @@ implementation
result.lab:=startlab; result.lab:=startlab;
datatcb.begin_anonymous_record('$'+get_dynstring_rec_name(st_widestring,true,strlength), datatcb.begin_anonymous_record('$'+get_dynstring_rec_name(st_widestring,true,strlength),
4,4, 4,4,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
datatcb.emit_tai(Tai_const.Create_32bit(strlength*cwidechartype.size),s32inttype); datatcb.emit_tai(Tai_const.Create_32bit(strlength*cwidechartype.size),s32inttype);
{ can we optimise by placing the string constant label at the { can we optimise by placing the string constant label at the
required offset? } required offset? }
@ -1749,7 +1747,7 @@ implementation
result.ofs:=0; result.ofs:=0;
{ pack the data, so that we don't add unnecessary null bytes after the { pack the data, so that we don't add unnecessary null bytes after the
constant string } constant string }
begin_anonymous_record('',1,sizeof(TConstPtrUInt),1,1); begin_anonymous_record('',1,sizeof(TConstPtrUInt),1);
dynarray_symofs:=get_dynarray_symofs; dynarray_symofs:=get_dynarray_symofs;
{ what to do if ptrsinttype <> sizesinttype??? } { what to do if ptrsinttype <> sizesinttype??? }
emit_tai(tai_const.create_sizeint(-1),ptrsinttype); emit_tai(tai_const.create_sizeint(-1),ptrsinttype);
@ -1928,7 +1926,7 @@ implementation
end; end;
function ttai_typedconstbuilder.begin_anonymous_record(const optionalname: string; packrecords, recordalign, recordalignmin, maxcrecordalign: shortint): trecorddef; function ttai_typedconstbuilder.begin_anonymous_record(const optionalname: string; packrecords, recordalign, recordalignmin: shortint): trecorddef;
var var
anonrecorddef: trecorddef; anonrecorddef: trecorddef;
typesym: ttypesym; typesym: ttypesym;
@ -1949,7 +1947,7 @@ implementation
end; end;
end; end;
{ create skeleton def } { create skeleton def }
anonrecorddef:=crecorddef.create_global_internal(optionalname,packrecords,recordalignmin,maxcrecordalign); anonrecorddef:=crecorddef.create_global_internal(optionalname,packrecords,recordalignmin);
trecordsymtable(anonrecorddef.symtable).recordalignment:=recordalign; trecordsymtable(anonrecorddef.symtable).recordalignment:=recordalign;
{ generic aggregate housekeeping } { generic aggregate housekeeping }
begin_aggregate_internal(anonrecorddef,true); begin_aggregate_internal(anonrecorddef,true);

3
compiler/cresstr.pas
View File

@ -197,8 +197,7 @@ uses
tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_vectorized_dead_strip_end,tcalo_data_force_indirect,tcalo_is_public_asm]); tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_vectorized_dead_strip_end,tcalo_data_force_indirect,tcalo_is_public_asm]);
tcb.begin_anonymous_record(internaltypeprefixName[itp_emptyrec], tcb.begin_anonymous_record(internaltypeprefixName[itp_emptyrec],
default_settings.packrecords,sizeof(pint), default_settings.packrecords,sizeof(pint),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
current_asmdata.AsmLists[al_resourcestrings].concatList( current_asmdata.AsmLists[al_resourcestrings].concatList(
tcb.get_final_asmlist_vectorized_dead_strip( tcb.get_final_asmlist_vectorized_dead_strip(
tcb.end_anonymous_record,'RESSTR','',current_module.localsymtable,sizeof(pint) tcb.end_anonymous_record,'RESSTR','',current_module.localsymtable,sizeof(pint)

9
compiler/llvm/llvmdef.pas
View File

@ -68,7 +68,7 @@ interface
record consisting of 4 longints must be returned as a record consisting of record consisting of 4 longints must be returned as a record consisting of
two int64's on x86-64. This function is used to create (and reuse) two int64's on x86-64. This function is used to create (and reuse)
temporary recorddefs for such purposes.} temporary recorddefs for such purposes.}
function llvmgettemprecorddef(const fieldtypes: array of tdef; packrecords, recordalignmin, maxcrecordalign: shortint): trecorddef; function llvmgettemprecorddef(const fieldtypes: array of tdef; packrecords, recordalignmin: shortint): trecorddef;
{ get the llvm type corresponding to a parameter, e.g. a record containing { get the llvm type corresponding to a parameter, e.g. a record containing
two integer int64 for an arbitrary record split over two individual int64 two integer int64 for an arbitrary record split over two individual int64
@ -862,7 +862,7 @@ implementation
end; end;
function llvmgettemprecorddef(const fieldtypes: array of tdef; packrecords, recordalignmin, maxcrecordalign: shortint): trecorddef; function llvmgettemprecorddef(const fieldtypes: array of tdef; packrecords, recordalignmin: shortint): trecorddef;
var var
i: longint; i: longint;
res: PHashSetItem; res: PHashSetItem;
@ -920,7 +920,7 @@ implementation
if not assigned(res^.Data) then if not assigned(res^.Data) then
begin begin
res^.Data:=crecorddef.create_global_internal(typename,packrecords, res^.Data:=crecorddef.create_global_internal(typename,packrecords,
recordalignmin,maxcrecordalign); recordalignmin);
for i:=low(fieldtypes) to high(fieldtypes) do for i:=low(fieldtypes) to high(fieldtypes) do
trecorddef(res^.Data).add_field_by_def('F'+tostr(i),fieldtypes[i]); trecorddef(res^.Data).add_field_by_def('F'+tostr(i),fieldtypes[i]);
end; end;
@ -1023,8 +1023,7 @@ implementation
retloc:=retloc^.next; retloc:=retloc^.next;
until not assigned(retloc); until not assigned(retloc);
result:=llvmgettemprecorddef(slice(retdeflist,i),C_alignment, result:=llvmgettemprecorddef(slice(retdeflist,i),C_alignment,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
include(result.defoptions,df_llvm_no_struct_packing); include(result.defoptions,df_llvm_no_struct_packing);
end; end;

3
compiler/llvm/llvmpi.pas
View File

@ -148,8 +148,7 @@ implementation
exactly two fields in this struct) } exactly two fields in this struct) }
landingpaddef:=llvmgettemprecorddef([voidpointertype,u32inttype], landingpaddef:=llvmgettemprecorddef([voidpointertype,u32inttype],
1, 1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
reg:=hlcg.getregisterfordef(list,landingpaddef); reg:=hlcg.getregisterfordef(list,landingpaddef);
landingpad:=taillvm.landingpad(reg,landingpaddef,{clause}nil); landingpad:=taillvm.landingpad(reg,landingpaddef,{clause}nil);
list.concat(landingpad); list.concat(landingpad);

5
compiler/llvm/nllvmtcon.pas
View File

@ -385,13 +385,12 @@ implementation
arraydef: arraydef:
{ in an array, all elements come right after each other -> { in an array, all elements come right after each other ->
replace with a packed record } replace with a packed record }
newdef:=crecorddef.create_global_internal('',1,1,1); newdef:=crecorddef.create_global_internal('',1,1);
recorddef, recorddef,
objectdef: objectdef:
newdef:=crecorddef.create_global_internal('', newdef:=crecorddef.create_global_internal('',
tabstractrecordsymtable(tabstractrecorddef(info.def).symtable).recordalignment, tabstractrecordsymtable(tabstractrecorddef(info.def).symtable).recordalignment,
tabstractrecordsymtable(tabstractrecorddef(info.def).symtable).recordalignmin, tabstractrecordsymtable(tabstractrecorddef(info.def).symtable).recordalignmin);
tabstractrecordsymtable(tabstractrecorddef(info.def).symtable).maxCrecordalign);
else else
internalerror(2015122401); internalerror(2015122401);
end; end;

3
compiler/llvm/nllvmutil.pas
View File

@ -177,8 +177,7 @@ implementation
fields[1]:=pd.getcopyas(procvardef,pc_address_only,''); fields[1]:=pd.getcopyas(procvardef,pc_address_only,'');
fields[2]:=voidpointertype; fields[2]:=voidpointertype;
itemdef:=llvmgettemprecorddef(fields,C_alignment, itemdef:=llvmgettemprecorddef(fields,C_alignment,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
include(itemdef.defoptions,df_llvm_no_struct_packing); include(itemdef.defoptions,df_llvm_no_struct_packing);
tcb:=ctai_typedconstbuilder.create([tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_new_section]);
tllvmtai_typedconstbuilder(tcb).appendingdef:=true; tllvmtai_typedconstbuilder(tcb).appendingdef:=true;

4
compiler/ncal.pas
View File

@ -486,13 +486,13 @@ implementation
end; end;
{ create a temp to store parameter values } { create a temp to store parameter values }
vardispatchparadef:=crecorddef.create_global_internal('',voidpointertype.size,voidpointertype.size,current_settings.alignment.maxCrecordalign); vardispatchparadef:=crecorddef.create_global_internal('',voidpointertype.size,voidpointertype.size);
{ the size will be set once the vardistpatchparadef record has been completed } { the size will be set once the vardistpatchparadef record has been completed }
params:=ctempcreatenode.create(vardispatchparadef,0,tt_persistent,false); params:=ctempcreatenode.create(vardispatchparadef,0,tt_persistent,false);
addstatement(statements,params); addstatement(statements,params);
tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]);
tcb.begin_anonymous_record('',1,sizeof(pint),1,1); tcb.begin_anonymous_record('',1,sizeof(pint),1);
if not variantdispatch then { generate a tdispdesc record } if not variantdispatch then { generate a tdispdesc record }
begin begin

126
compiler/ncgrtti.pas
View File

@ -205,8 +205,7 @@ implementation
para : tparavarsym; para : tparavarsym;
begin begin
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
totalcount:=0; totalcount:=0;
rtticount:=0; rtticount:=0;
@ -241,8 +240,7 @@ implementation
def.init_paraloc_info(callerside); def.init_paraloc_info(callerside);
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_rtti_reference(tcb,def.returndef,fullrtti); write_rtti_reference(tcb,def.returndef,fullrtti);
write_callconv(tcb,def); write_callconv(tcb,def);
@ -256,8 +254,7 @@ implementation
para:=tparavarsym(def.paras[k]); para:=tparavarsym(def.paras[k]);
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if is_open_array(para.vardef) or is_array_of_const(para.vardef) then if is_open_array(para.vardef) or is_array_of_const(para.vardef) then
write_rtti_reference(tcb,tarraydef(para.vardef).elementdef,fullrtti) write_rtti_reference(tcb,tarraydef(para.vardef).elementdef,fullrtti)
@ -297,8 +294,7 @@ implementation
{ TTypeInfo, always packed and doesn't need alignment } { TTypeInfo, always packed and doesn't need alignment }
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_header]+tostr(length(name)),1,1, internaltypeprefixName[itp_rtti_header]+tostr(length(name)),1,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if def.typ=arraydef then if def.typ=arraydef then
InternalError(201012211); InternalError(201012211);
tcb.emit_tai(Tai_const.Create_8bit(typekind),u8inttype); tcb.emit_tai(Tai_const.Create_8bit(typekind),u8inttype);
@ -400,14 +396,12 @@ implementation
loctcb:=ctai_typedconstbuilder.create([tcalo_is_lab,tcalo_make_dead_strippable,tcalo_apply_constalign]); loctcb:=ctai_typedconstbuilder.create([tcalo_is_lab,tcalo_make_dead_strippable,tcalo_apply_constalign]);
loctcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), loctcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
loctcb.emit_ord_const(length(locs),u8inttype); loctcb.emit_ord_const(length(locs),u8inttype);
for i:=low(locs) to high(locs) do for i:=low(locs) to high(locs) do
begin begin
loctcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), loctcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
loctcb.emit_ord_const(locs[i].loctype,u8inttype); loctcb.emit_ord_const(locs[i].loctype,u8inttype);
loctcb.emit_ord_const(locs[i].regsub,u8inttype); loctcb.emit_ord_const(locs[i].regsub,u8inttype);
loctcb.emit_ord_const(locs[i].regindex,u16inttype); loctcb.emit_ord_const(locs[i].regindex,u16inttype);
@ -519,8 +513,7 @@ implementation
tcb.start_internal_data_builder(current_asmdata.AsmLists[al_rtti],sec_rodata,'',datatcb,tbllbl); tcb.start_internal_data_builder(current_asmdata.AsmLists[al_rtti],sec_rodata,'',datatcb,tbllbl);
datatcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), datatcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
datatcb.emit_ord_const(list.count,u32inttype); datatcb.emit_ord_const(list.count,u32inttype);
entrydef:=get_recorddef(itp_init_mop_offset_entry,[voidcodepointertype,sizeuinttype],defaultpacking); entrydef:=get_recorddef(itp_init_mop_offset_entry,[voidcodepointertype,sizeuinttype],defaultpacking);
@ -865,8 +858,7 @@ implementation
begin begin
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.emit_ord_const(published_properties_count(st),u16inttype); tcb.emit_ord_const(published_properties_count(st),u16inttype);
for i:=0 to st.SymList.Count-1 do for i:=0 to st.SymList.Count-1 do
begin begin
@ -886,8 +878,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
propdefname, propdefname,
1,min(reqalign,SizeOf(PInt)), 1,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if ppo_indexed in tpropertysym(sym).propoptions then if ppo_indexed in tpropertysym(sym).propoptions then
proctypesinfo:=$40 proctypesinfo:=$40
else else
@ -950,8 +941,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_ansistr], internaltypeprefixName[itp_rtti_ansistr],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
tcb.emit_ord_const(def.encoding,u16inttype); tcb.emit_ord_const(def.encoding,u16inttype);
tcb.end_anonymous_record; tcb.end_anonymous_record;
@ -997,13 +987,11 @@ implementation
and o2s arrays for llvm (otherwise we have to write out the entire and o2s arrays for llvm (otherwise we have to write out the entire
type definition every time we access an element from this record) } type definition every time we access an element from this record) }
tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_size_start_rec]+def.unique_id_str,defaultpacking,reqalign, tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_size_start_rec]+def.unique_id_str,defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
tcb.next_field_name:='typ_union_rec'; tcb.next_field_name:='typ_union_rec';
tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_size_start_rec2]+def.unique_id_str,defaultpacking,reqalign, tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_size_start_rec2]+def.unique_id_str,defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
case longint(def.size) of case longint(def.size) of
1 : 1 :
tcb.emit_ord_const(otUByte,u8inttype); tcb.emit_ord_const(otUByte,u8inttype);
@ -1021,16 +1009,14 @@ implementation
We need to adhere to this, otherwise things will break. } We need to adhere to this, otherwise things will break. }
tcb.next_field_name:='min_max_rec'; tcb.next_field_name:='min_max_rec';
tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_min_max_rec]+def.unique_id_str,defaultpacking,reqalign, tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_min_max_rec]+def.unique_id_str,defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.emit_ord_const(def.min,s32inttype); tcb.emit_ord_const(def.min,s32inttype);
tcb.emit_ord_const(def.max,s32inttype); tcb.emit_ord_const(def.max,s32inttype);
tcb.next_field_name:='basetype_array_rec'; tcb.next_field_name:='basetype_array_rec';
{ all strings must appear right after each other -> from now on { all strings must appear right after each other -> from now on
packrecords 1 (but the start must still be aligned) } packrecords 1 (but the start must still be aligned) }
tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_basetype_array_rec]+def.unique_id_str,1,reqalign, tcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_enum_basetype_array_rec]+def.unique_id_str,1,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ write base type } { write base type }
write_rtti_reference(tcb,def.basedef,rt); write_rtti_reference(tcb,def.basedef,rt);
for i:=0 to def.symtable.SymList.Count-1 do for i:=0 to def.symtable.SymList.Count-1 do
@ -1101,15 +1087,13 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_ord_outer]+elesize, internaltypeprefixName[itp_rtti_ord_outer]+elesize,
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
tcb.emit_ord_const(byte(trans[def.ordtype]),u8inttype); tcb.emit_ord_const(byte(trans[def.ordtype]),u8inttype);
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_ord_inner]+elesize, internaltypeprefixName[itp_rtti_ord_inner]+elesize,
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{Convert to longint to smuggle values in high(longint)+1..high(cardinal) into asmlist.} {Convert to longint to smuggle values in high(longint)+1..high(cardinal) into asmlist.}
case deftrans of case deftrans of
otUQWord: otUQWord:
@ -1166,8 +1150,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_1byte], internaltypeprefixName[itp_1byte],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
tcb.emit_ord_const(ftCurr,u8inttype); tcb.emit_ord_const(ftCurr,u8inttype);
tcb.end_anonymous_record; tcb.end_anonymous_record;
@ -1188,8 +1171,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_1byte], internaltypeprefixName[itp_1byte],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
tcb.emit_ord_const(translate[def.floattype],u8inttype); tcb.emit_ord_const(translate[def.floattype],u8inttype);
tcb.end_anonymous_record; tcb.end_anonymous_record;
@ -1202,14 +1184,12 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_set_outer], internaltypeprefixName[itp_rtti_set_outer],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_set_middle], internaltypeprefixName[itp_rtti_set_middle],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
case def.size of case def.size of
1: 1:
tcb.emit_ord_const(otUByte,u8inttype); tcb.emit_ord_const(otUByte,u8inttype);
@ -1223,8 +1203,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_set_inner], internaltypeprefixName[itp_rtti_set_inner],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.emit_ord_const(def.size,sizesinttype); tcb.emit_ord_const(def.size,sizesinttype);
write_rtti_reference(tcb,def.elementdef,rt); write_rtti_reference(tcb,def.elementdef,rt);
tcb.end_anonymous_record; tcb.end_anonymous_record;
@ -1264,8 +1243,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_normal_array]+tostr(dimcount), internaltypeprefixName[itp_rtti_normal_array]+tostr(dimcount),
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
{ total size = elecount * elesize of the first arraydef } { total size = elecount * elesize of the first arraydef }
tcb.emit_tai(Tai_const.Create_sizeint(def.elecount*def.elesize),sizeuinttype); tcb.emit_tai(Tai_const.Create_sizeint(def.elecount*def.elesize),sizeuinttype);
@ -1296,8 +1274,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_dyn_array], internaltypeprefixName[itp_rtti_dyn_array],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
{ size of elements } { size of elements }
tcb.emit_tai(Tai_const.Create_sizeint(def.elesize),sizeuinttype); tcb.emit_tai(Tai_const.Create_sizeint(def.elesize),sizeuinttype);
@ -1322,8 +1299,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_ref], internaltypeprefixName[itp_rtti_ref],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
write_rtti_reference(tcb,def.pointeddef,rt); write_rtti_reference(tcb,def.pointeddef,rt);
tcb.end_anonymous_record; tcb.end_anonymous_record;
@ -1335,8 +1311,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_ref], internaltypeprefixName[itp_rtti_ref],
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
write_rtti_reference(tcb,def.pointeddef,rt); write_rtti_reference(tcb,def.pointeddef,rt);
tcb.end_anonymous_record; tcb.end_anonymous_record;
@ -1360,8 +1335,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
rttilab.Name, rttilab.Name,
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin
targetinfos[target_info.system]^.alignment.maxCrecordalign
); );
{ use "succ" to omit first enum item "mop_none" } { use "succ" to omit first enum item "mop_none" }
@ -1394,8 +1368,7 @@ implementation
only be aligned to 4 even on 64 bit target (while the rtti code only be aligned to 4 even on 64 bit target (while the rtti code
in typinfo expects alignments to sizeof(pointer)) } in typinfo expects alignments to sizeof(pointer)) }
tcb.begin_anonymous_record('',defaultpacking,reqalign, tcb.begin_anonymous_record('',defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
@ -1451,8 +1424,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_proc_param]+tostr(length(parasym.realname)), internaltypeprefixName[itp_rtti_proc_param]+tostr(length(parasym.realname)),
defaultpacking,min(reqalign,SizeOf(PInt)), defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ write flags for current parameter } { write flags for current parameter }
write_param_flag(tcb,parasym); write_param_flag(tcb,parasym);
{ write param type } { write param type }
@ -1476,8 +1448,7 @@ implementation
{ write method id and name } { write method id and name }
write_header(tcb,def,tkMethod); write_header(tcb,def,tkMethod);
tcb.begin_anonymous_record('',defaultpacking,reqalign, tcb.begin_anonymous_record('',defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
@ -1520,8 +1491,7 @@ implementation
begin begin
write_header(tcb,def,tkProcvar); write_header(tcb,def,tkProcvar);
tcb.begin_anonymous_record('',defaultpacking,reqalign, tcb.begin_anonymous_record('',defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
@ -1632,8 +1602,7 @@ implementation
collect_propnamelist(propnamelist,def); collect_propnamelist(propnamelist,def);
tcb.begin_anonymous_record('',defaultpacking,reqalign, tcb.begin_anonymous_record('',defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ write parent typeinfo } { write parent typeinfo }
write_rtti_reference(tcb,def.childof,fullrtti); write_rtti_reference(tcb,def.childof,fullrtti);
@ -1659,8 +1628,7 @@ implementation
tcb.emit_shortstring_const(current_module.realmodulename^); tcb.emit_shortstring_const(current_module.realmodulename^);
tcb.begin_anonymous_record('',defaultpacking,reqalign, tcb.begin_anonymous_record('',defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ write iidstr } { write iidstr }
if def.objecttype=odt_interfacecorba then if def.objecttype=odt_interfacecorba then
@ -1704,8 +1672,7 @@ implementation
tcb.emit_shortstring_const(def.objrealname^); tcb.emit_shortstring_const(def.objrealname^);
tcb.begin_anonymous_record('',defaultpacking,reqalign, tcb.begin_anonymous_record('',defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
write_common_rtti_data(tcb,def,rt); write_common_rtti_data(tcb,def,rt);
@ -1798,8 +1765,7 @@ implementation
argtcb:=ctai_typedconstbuilder.create([tcalo_is_lab,tcalo_make_dead_strippable,tcalo_apply_constalign]); argtcb:=ctai_typedconstbuilder.create([tcalo_is_lab,tcalo_make_dead_strippable,tcalo_apply_constalign]);
argtcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)), argtcb.begin_anonymous_record('',defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
arglen:=0; arglen:=0;
for i:=0 to High(attr.paras) do for i:=0 to High(attr.paras) do
@ -1860,14 +1826,12 @@ implementation
tbltcb.begin_anonymous_record( tbltcb.begin_anonymous_record(
internaltypeprefixName[itp_rtti_attr_list]+tostr(count), internaltypeprefixName[itp_rtti_attr_list]+tostr(count),
defaultpacking,min(reqalign,SizeOf(PInt)), defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tbltcb.emit_ord_const(count,u16inttype); tbltcb.emit_ord_const(count,u16inttype);
for i:=0 to count-1 do for i:=0 to count-1 do
begin begin
tbltcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_attr_entry],defaultpacking,min(reqalign,SizeOf(PInt)), tbltcb.begin_anonymous_record(internaltypeprefixName[itp_rtti_attr_entry],defaultpacking,min(reqalign,SizeOf(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
attr:=trtti_attribute(attr_list.rtti_attributes[i]); attr:=trtti_attribute(attr_list.rtti_attributes[i]);
write_rtti_reference(tbltcb,ttypesym(attr.typesym).typedef,fullrtti); write_rtti_reference(tbltcb,ttypesym(attr.typesym).typedef,fullrtti);
@ -1979,14 +1943,12 @@ implementation
tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_data_force_indirect]); tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_data_force_indirect]);
{ use TConstPtrUInt packrecords to ensure good alignment } { use TConstPtrUInt packrecords to ensure good alignment }
tcb.begin_anonymous_record('',defaultpacking,reqalign, tcb.begin_anonymous_record('',defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ now emit the data: first the mode } { now emit the data: first the mode }
tcb.emit_tai(Tai_const.create_32bit(longint(mode)),u32inttype); tcb.emit_tai(Tai_const.create_32bit(longint(mode)),u32inttype);
{ align } { align }
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if mode=lookup then if mode=lookup then
begin begin
o:=tenumsym(syms[0]).value; {Start with min value.} o:=tenumsym(syms[0]).value; {Start with min value.}
@ -2013,8 +1975,7 @@ implementation
begin begin
tcb.emit_ord_const(sym_count,u32inttype); tcb.emit_ord_const(sym_count,u32inttype);
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
for i:=0 to sym_count-1 do for i:=0 to sym_count-1 do
begin begin
tcb.emit_ord_const(tenumsym(syms[i]).value,s32inttype); tcb.emit_ord_const(tenumsym(syms[i]).value,s32inttype);
@ -2058,13 +2019,11 @@ implementation
tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_data_force_indirect]); tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_data_force_indirect]);
{ begin of Tstring_to_ord } { begin of Tstring_to_ord }
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.emit_ord_const(syms.count,s32inttype); tcb.emit_ord_const(syms.count,s32inttype);
{ begin of "data" array in Tstring_to_ord } { begin of "data" array in Tstring_to_ord }
tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)), tcb.begin_anonymous_record('',defaultpacking,min(reqalign,sizeof(PInt)),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
for i:=0 to syms.count-1 do for i:=0 to syms.count-1 do
begin begin
tcb.emit_ord_const(tenumsym(syms[i]).value,s32inttype); tcb.emit_ord_const(tenumsym(syms[i]).value,s32inttype);
@ -2249,8 +2208,7 @@ implementation
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_rttidef]+tstoreddef(def).rtti_mangledname(rt), internaltypeprefixName[itp_rttidef]+tstoreddef(def).rtti_mangledname(rt),
defaultpacking,reqalign, defaultpacking,reqalign,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin
targetinfos[target_info.system]^.alignment.maxCrecordalign
); );
write_rtti_data(tcb,def,rt); write_rtti_data(tcb,def,rt);
rttidef:=tcb.end_anonymous_record; rttidef:=tcb.end_anonymous_record;

15
compiler/ncgvmt.pas
View File

@ -614,8 +614,7 @@ implementation
tcb.start_internal_data_builder(current_asmdata.AsmLists[al_const],sec_rodata,_class.vmt_mangledname,datatcb,classtable); tcb.start_internal_data_builder(current_asmdata.AsmLists[al_const],sec_rodata,_class.vmt_mangledname,datatcb,classtable);
datatcb.begin_anonymous_record('$fpc_intern_classtable_'+tostr(classtablelist.Count-1), datatcb.begin_anonymous_record('$fpc_intern_classtable_'+tostr(classtablelist.Count-1),
packrecords,1, packrecords,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
datatcb.emit_tai(Tai_const.Create_16bit(classtablelist.count),u16inttype); datatcb.emit_tai(Tai_const.Create_16bit(classtablelist.count),u16inttype);
for i:=0 to classtablelist.Count-1 do for i:=0 to classtablelist.Count-1 do
begin begin
@ -649,8 +648,7 @@ implementation
plus there would be very little chance that it could actually be plus there would be very little chance that it could actually be
reused } reused }
datatcb.begin_anonymous_record('',packrecords,1, datatcb.begin_anonymous_record('',packrecords,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
datatcb.emit_tai(Tai_const.Create_16bit(fieldcount),u16inttype); datatcb.emit_tai(Tai_const.Create_16bit(fieldcount),u16inttype);
datatcb.emit_tai(Tai_const.Create_sym(classtable),cpointerdef.getreusable(classtabledef)); datatcb.emit_tai(Tai_const.Create_sym(classtable),cpointerdef.getreusable(classtabledef));
for i:=0 to _class.symtable.SymList.Count-1 do for i:=0 to _class.symtable.SymList.Count-1 do
@ -672,8 +670,7 @@ implementation
end; end;
} }
datatcb.begin_anonymous_record('$fpc_intern_fieldinfo_'+tostr(length(tfieldvarsym(sym).realname)),packrecords,1, datatcb.begin_anonymous_record('$fpc_intern_fieldinfo_'+tostr(length(tfieldvarsym(sym).realname)),packrecords,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
datatcb.emit_tai(Tai_const.Create_sizeint(tfieldvarsym(sym).fieldoffset),sizeuinttype); datatcb.emit_tai(Tai_const.Create_sizeint(tfieldvarsym(sym).fieldoffset),sizeuinttype);
classindex:=classtablelist.IndexOf(tfieldvarsym(sym).vardef); classindex:=classtablelist.IndexOf(tfieldvarsym(sym).vardef);
if classindex=-1 then if classindex=-1 then
@ -728,8 +725,7 @@ implementation
begin begin
tcb.start_internal_data_builder(current_asmdata.AsmLists[al_const],sec_rodata,'',datatcb,fintfvtablelabels[intfindex]); tcb.start_internal_data_builder(current_asmdata.AsmLists[al_const],sec_rodata,'',datatcb,fintfvtablelabels[intfindex]);
datatcb.begin_anonymous_record('',0,1, datatcb.begin_anonymous_record('',0,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if assigned(AImplIntf.procdefs) then if assigned(AImplIntf.procdefs) then
begin begin
for i:=0 to AImplIntf.procdefs.count-1 do for i:=0 to AImplIntf.procdefs.count-1 do
@ -847,8 +843,7 @@ implementation
tcb.start_internal_data_builder(current_asmdata.AsmLists[al_const],sec_rodata,_class.vmt_mangledname,datatcb,lab); tcb.start_internal_data_builder(current_asmdata.AsmLists[al_const],sec_rodata,_class.vmt_mangledname,datatcb,lab);
datatcb.begin_anonymous_record('',default_settings.packrecords,1, datatcb.begin_anonymous_record('',default_settings.packrecords,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
datatcb.emit_tai(Tai_const.Create_sizeint(_class.ImplementedInterfaces.count),sizeuinttype); datatcb.emit_tai(Tai_const.Create_sizeint(_class.ImplementedInterfaces.count),sizeuinttype);
interfaceentrydef:=search_system_type('TINTERFACEENTRY').typedef; interfaceentrydef:=search_system_type('TINTERFACEENTRY').typedef;
interfaceentrytypedef:=search_system_type('TINTERFACEENTRYTYPE').typedef; interfaceentrytypedef:=search_system_type('TINTERFACEENTRYTYPE').typedef;

18
compiler/ngenutil.pas
View File

@ -1082,8 +1082,7 @@ implementation
begin begin
unitinits:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]); unitinits:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]);
unitinits.begin_anonymous_record('',default_settings.packrecords,sizeof(pint), unitinits.begin_anonymous_record('',default_settings.packrecords,sizeof(pint),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ tablecount } { tablecount }
unitinits.emit_ord_const(entries.count,aluuinttype); unitinits.emit_ord_const(entries.count,aluuinttype);
@ -1167,8 +1166,7 @@ implementation
count:=0; count:=0;
tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]);
tcb.begin_anonymous_record('',1,sizeof(pint), tcb.begin_anonymous_record('',1,sizeof(pint),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin
targetinfos[target_info.system]^.alignment.maxCrecordalign
); );
placeholder:=tcb.emit_placeholder(u32inttype); placeholder:=tcb.emit_placeholder(u32inttype);
@ -1244,8 +1242,7 @@ implementation
exit; exit;
tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]);
tabledef:=tcb.begin_anonymous_record('',1,sizeof(pint), tabledef:=tcb.begin_anonymous_record('',1,sizeof(pint),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if assigned(current_module.globalsymtable) then if assigned(current_module.globalsymtable) then
current_module.globalsymtable.SymList.ForEachCall(@AddToThreadvarList,tcb); current_module.globalsymtable.SymList.ForEachCall(@AddToThreadvarList,tcb);
current_module.localsymtable.SymList.ForEachCall(@AddToThreadvarList,tcb); current_module.localsymtable.SymList.ForEachCall(@AddToThreadvarList,tcb);
@ -1279,8 +1276,7 @@ implementation
begin begin
tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]);
tcb.begin_anonymous_record('',default_settings.packrecords,sizeof(pint), tcb.begin_anonymous_record('',default_settings.packrecords,sizeof(pint),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin
targetinfos[target_info.system]^.alignment.maxCrecordalign
); );
{ placeholder for the count } { placeholder for the count }
countplaceholder:=tcb.emit_placeholder(sizesinttype); countplaceholder:=tcb.emit_placeholder(sizesinttype);
@ -1334,8 +1330,7 @@ implementation
s:=make_mangledname(prefix,current_module.localsymtable,''); s:=make_mangledname(prefix,current_module.localsymtable,'');
tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_make_dead_strippable,tcalo_new_section]);
tcb.begin_anonymous_record('',default_settings.packrecords,sizeof(pint), tcb.begin_anonymous_record('',default_settings.packrecords,sizeof(pint),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign );
repeat repeat
{ optimize away unused local/static symbols } { optimize away unused local/static symbols }
if (item.sym.refs>0) or (item.sym.owner.symtabletype=globalsymtable) then if (item.sym.refs>0) or (item.sym.owner.symtabletype=globalsymtable) then
@ -1399,8 +1394,7 @@ implementation
count:=0; count:=0;
hp:=tmodule(loaded_units.first); hp:=tmodule(loaded_units.first);
tcb.begin_anonymous_record('',default_settings.packrecords,sizeof(pint), tcb.begin_anonymous_record('',default_settings.packrecords,sizeof(pint),
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
countplaceholder:=tcb.emit_placeholder(sizesinttype); countplaceholder:=tcb.emit_placeholder(sizesinttype);
while assigned(hp) do while assigned(hp) do
begin begin

3
compiler/nobj.pas
View File

@ -833,8 +833,7 @@ implementation
vmtdef:=crecorddef.create_global_internal( vmtdef:=crecorddef.create_global_internal(
vmtdefname, vmtdefname,
0, 0,
target_info.alignment.recordalignmin, target_info.alignment.recordalignmin);
target_info.alignment.maxCrecordalign);
{$ifdef llvm} {$ifdef llvm}
{ in case of a class declared in the implementation section of unit { in case of a class declared in the implementation section of unit
whose method is called from an inline routine -- LLVM needs to be able whose method is called from an inline routine -- LLVM needs to be able

45
compiler/objcgutl.pas
View File

@ -330,8 +330,7 @@ procedure tobjcrttiwriter.gen_objc_methods(list: tasmlist; objccls: tobjectdef;
tcb:=ctai_typedconstbuilder.create(SectFlags[target_info.system in systems_objc_nfabi]); tcb:=ctai_typedconstbuilder.create(SectFlags[target_info.system in systems_objc_nfabi]);
tcb.begin_anonymous_record(internaltypeprefixName[itp_objc_method_list]+tostr(mcnt), tcb.begin_anonymous_record(internaltypeprefixName[itp_objc_method_list]+tostr(mcnt),
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if (abi=oa_fragile) then if (abi=oa_fragile) then
{ not used, always zero } { not used, always zero }
@ -470,8 +469,7 @@ procedure tobjcrttiwriter.gen_objc_protocol_list(list: tasmlist; protolist: tfpo
tcb:=ctai_typedconstbuilder.create([tcalo_is_lab,tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_is_lab,tcalo_new_section]);
tcb.begin_anonymous_record(internaltypeprefixName[itp_objc_proto_list]+tostr(protolist.Count), tcb.begin_anonymous_record(internaltypeprefixName[itp_objc_proto_list]+tostr(protolist.Count),
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ protocol lists are stored in .objc_cat_cls_meth section } { protocol lists are stored in .objc_cat_cls_meth section }
current_asmdata.getlabel(protolistsym, alt_data); current_asmdata.getlabel(protolistsym, alt_data);
@ -526,8 +524,7 @@ begin
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itp_objc_cat_methods]+tostr(items.count), internaltypeprefixName[itp_objc_cat_methods]+tostr(items.count),
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
if (abi=oa_nonfragile) then if (abi=oa_nonfragile) then
begin begin
{ size of each entry -- always 32 bit value } { size of each entry -- always 32 bit value }
@ -709,8 +706,7 @@ function tobjcrttiwriter_fragile.gen_objc_protocol_ext(list: TAsmList; optinstsy
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itb_objc_fr_protocol_ext], internaltypeprefixName[itb_objc_fr_protocol_ext],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ size of this structure } { size of this structure }
tcb.emit_ord_const(16,u32inttype); tcb.emit_ord_const(16,u32inttype);
{ optional instance methods } { optional instance methods }
@ -757,8 +753,7 @@ procedure tobjcrttiwriter_fragile.gen_objc_protocol(list:TAsmList; protocol: tob
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itb_objc_fr_protocol], internaltypeprefixName[itb_objc_fr_protocol],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ protocol's isa - points to information about optional methods/properties } { protocol's isa - points to information about optional methods/properties }
ConcatSymOrNil(tcb,protoext,voidpointertype); ConcatSymOrNil(tcb,protoext,voidpointertype);
@ -828,8 +823,7 @@ procedure tobjcrttiwriter_fragile.gen_objc_category_sections(list:TAsmList; objc
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itb_objc_fr_category], internaltypeprefixName[itb_objc_fr_category],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.queue_init(voidpointertype); tcb.queue_init(voidpointertype);
tcb.queue_emit_asmsym(catstrsym,catstrdef); tcb.queue_emit_asmsym(catstrsym,catstrdef);
@ -945,8 +939,7 @@ procedure tobjcrttiwriter_fragile.gen_objc_classes_sections(list:TAsmList; objcl
tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]); tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]);
tcb.begin_anonymous_record(internaltypeprefixName[itb_objc_fr_meta_class], tcb.begin_anonymous_record(internaltypeprefixName[itb_objc_fr_meta_class],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.queue_init(voidpointertype); tcb.queue_init(voidpointertype);
tcb.queue_emit_asmsym(metaisaStrSym,metaisaStrDef); tcb.queue_emit_asmsym(metaisaStrSym,metaisaStrDef);
@ -1001,8 +994,7 @@ procedure tobjcrttiwriter_fragile.gen_objc_classes_sections(list:TAsmList; objcl
tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]); tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]);
tcb.begin_anonymous_record(internaltypeprefixName[itb_objc_fr_class], tcb.begin_anonymous_record(internaltypeprefixName[itb_objc_fr_class],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ for class declaration: the isa points to the meta-class declaration } { for class declaration: the isa points to the meta-class declaration }
tcb.emit_tai(Tai_const.Create_sym(metasym),cpointerdef.getreusable(metaDef)); tcb.emit_tai(Tai_const.Create_sym(metasym),cpointerdef.getreusable(metaDef));
@ -1070,8 +1062,7 @@ procedure tobjcrttiwriter_fragile.gen_objc_info_sections(list: tasmlist);
tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]); tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]);
tcb.begin_anonymous_record('', tcb.begin_anonymous_record('',
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ ??? (always 0 in Clang) } { ??? (always 0 in Clang) }
tcb.emit_tai(tai_const.Create_nil_dataptr,voidpointertype); tcb.emit_tai(tai_const.Create_nil_dataptr,voidpointertype);
{ ??? (From Clang: always 0, pointer to some selector) } { ??? (From Clang: always 0, pointer to some selector) }
@ -1102,8 +1093,7 @@ procedure tobjcrttiwriter_fragile.gen_objc_info_sections(list: tasmlist);
tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]); tcb:=ctai_typedconstbuilder.create([tcalo_new_section,tcalo_no_dead_strip]);
tcb.begin_anonymous_record('', tcb.begin_anonymous_record('',
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ version number = 7 (always, both for gcc and clang) } { version number = 7 (always, both for gcc and clang) }
tcb.emit_ord_const(7,ptruinttype); tcb.emit_ord_const(7,ptruinttype);
{ sizeof(objc_module): 4 pointer-size entities } { sizeof(objc_module): 4 pointer-size entities }
@ -1267,8 +1257,7 @@ procedure tobjcrttiwriter_nonfragile.gen_objc_ivars(list: tasmlist; objccls: tob
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itb_objc_nf_ivars]+tostr(vcnt), internaltypeprefixName[itb_objc_nf_ivars]+tostr(vcnt),
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
{ size of each entry -- always 32 bit value } { size of each entry -- always 32 bit value }
ivtype:=search_named_unit_globaltype('OBJC','OBJC_IVAR',true).typedef; ivtype:=search_named_unit_globaltype('OBJC','OBJC_IVAR',true).typedef;
@ -1436,8 +1425,7 @@ procedure tobjcrttiwriter_nonfragile.gen_objc_category_sections(list:TAsmList; o
tcb:=ctai_typedconstbuilder.create([tcalo_new_section]); tcb:=ctai_typedconstbuilder.create([tcalo_new_section]);
tcb.begin_anonymous_record(internaltypeprefixName[itb_objc_nf_category], tcb.begin_anonymous_record(internaltypeprefixName[itb_objc_nf_category],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.queue_init(voidpointertype); tcb.queue_init(voidpointertype);
tcb.queue_emit_asmsym(catstrsym,catstrdef); tcb.queue_emit_asmsym(catstrsym,catstrdef);
tcb.emit_tai(Tai_const.Create_sym(clssym),voidpointertype); tcb.emit_tai(Tai_const.Create_sym(clssym),voidpointertype);
@ -1642,8 +1630,7 @@ procedure tobjcrttiwriter_nonfragile.gen_objc_class_ro_part(list: tasmlist; objc
tcb.begin_anonymous_record( tcb.begin_anonymous_record(
internaltypeprefixName[itb_objc_nf_class_ro_part], internaltypeprefixName[itb_objc_nf_class_ro_part],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
tcb.emit_ord_const(flags,u32inttype); tcb.emit_ord_const(flags,u32inttype);
tcb.emit_ord_const(start,u32inttype); tcb.emit_ord_const(start,u32inttype);
@ -1717,15 +1704,13 @@ procedure tobjcrttiwriter_nonfragile.gen_objc_classes_sections(list:TAsmList; ob
classdef:=isatcb.begin_anonymous_record( classdef:=isatcb.begin_anonymous_record(
internaltypeprefixName[itb_objc_nf_class], internaltypeprefixName[itb_objc_nf_class],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
metatcb:=ctai_typedconstbuilder.create([tcalo_new_section]); metatcb:=ctai_typedconstbuilder.create([tcalo_new_section]);
metadef:=metatcb.begin_anonymous_record( metadef:=metatcb.begin_anonymous_record(
internaltypeprefixName[itb_objc_nf_meta_class], internaltypeprefixName[itb_objc_nf_meta_class],
C_alignment,1, C_alignment,1,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
clssym:=current_asmdata.DefineAsmSymbol(objclss.rtti_mangledname(objcclassrtti),vis,AT_DATA,classdef); clssym:=current_asmdata.DefineAsmSymbol(objclss.rtti_mangledname(objcclassrtti),vis,AT_DATA,classdef);
metasym:=current_asmdata.DefineAsmSymbol(objclss.rtti_mangledname(objcmetartti),vis,AT_DATA,metadef); metasym:=current_asmdata.DefineAsmSymbol(objclss.rtti_mangledname(objcmetartti),vis,AT_DATA,metadef);

2
compiler/pdecvar.pas
View File

@ -1900,7 +1900,7 @@ implementation
Message(type_e_ordinal_expr_expected); Message(type_e_ordinal_expr_expected);
consume(_OF); consume(_OF);
UnionSymtable:=trecordsymtable.create('',current_settings.packrecords,current_settings.alignment.recordalignmin,current_settings.alignment.maxCrecordalign); UnionSymtable:=trecordsymtable.create('',current_settings.packrecords,current_settings.alignment.recordalignmin);
UnionDef:=crecorddef.create('',unionsymtable); UnionDef:=crecorddef.create('',unionsymtable);
uniondef.isunion:=true; uniondef.isunion:=true;

2
compiler/pgenutil.pas
View File

@ -1266,7 +1266,7 @@ uses
Message(parser_e_illegal_expression) Message(parser_e_illegal_expression)
else else
begin begin
srsymtable:=trecordsymtable.create(defname,0,1,1); srsymtable:=trecordsymtable.create(defname,0,1);
basedef:=crecorddef.create(defname,srsymtable); basedef:=crecorddef.create(defname,srsymtable);
include(constraintdata.flags,gcf_record); include(constraintdata.flags,gcf_record);
allowconstructor:=false; allowconstructor:=false;

2
compiler/pparautl.pas
View File

@ -1088,7 +1088,7 @@ implementation
accessed from within nested routines (start with extra dollar to prevent accessed from within nested routines (start with extra dollar to prevent
the JVM from thinking this is a nested class in the unit) } the JVM from thinking this is a nested class in the unit) }
nestedvarsst:=trecordsymtable.create('$'+current_module.realmodulename^+'$$_fpc_nestedvars$'+pd.unique_id_str, nestedvarsst:=trecordsymtable.create('$'+current_module.realmodulename^+'$$_fpc_nestedvars$'+pd.unique_id_str,
current_settings.alignment.localalignmax,current_settings.alignment.localalignmin,current_settings.alignment.maxCrecordalign); current_settings.alignment.localalignmax,current_settings.alignment.localalignmin);
nestedvarsdef:=crecorddef.create(nestedvarsst.name^,nestedvarsst); nestedvarsdef:=crecorddef.create(nestedvarsst.name^,nestedvarsst);
{$ifdef jvm} {$ifdef jvm}
maybe_guarantee_record_typesym(nestedvarsdef,nestedvarsdef.owner); maybe_guarantee_record_typesym(nestedvarsdef,nestedvarsdef.owner);

6
compiler/psystem.pas
View File

@ -583,7 +583,7 @@ implementation
if not(target_info.system in systems_managed_vm) then if not(target_info.system in systems_managed_vm) then
begin begin
{ Add a type for virtual method tables } { Add a type for virtual method tables }
hrecst:=trecordsymtable.create('',current_settings.packrecords,current_settings.alignment.recordalignmin,current_settings.alignment.maxCrecordalign); hrecst:=trecordsymtable.create('',current_settings.packrecords,current_settings.alignment.recordalignmin);
vmttype:=crecorddef.create('',hrecst); vmttype:=crecorddef.create('',hrecst);
pvmttype:=cpointerdef.create(vmttype); pvmttype:=cpointerdef.create(vmttype);
{ can't use addtype for pvmt because the rtti of the pointed { can't use addtype for pvmt because the rtti of the pointed
@ -608,13 +608,13 @@ implementation
addtype('$vtblarray',vmtarraytype); addtype('$vtblarray',vmtarraytype);
end; end;
{ Add a type for methodpointers } { Add a type for methodpointers }
hrecst:=trecordsymtable.create('',1,current_settings.alignment.recordalignmin,current_settings.alignment.maxCrecordalign); hrecst:=trecordsymtable.create('',1,current_settings.alignment.recordalignmin);
addfield(hrecst,cfieldvarsym.create('$proc',vs_value,voidcodepointertype,[],true)); addfield(hrecst,cfieldvarsym.create('$proc',vs_value,voidcodepointertype,[],true));
addfield(hrecst,cfieldvarsym.create('$self',vs_value,voidpointertype,[],true)); addfield(hrecst,cfieldvarsym.create('$self',vs_value,voidpointertype,[],true));
methodpointertype:=crecorddef.create('',hrecst); methodpointertype:=crecorddef.create('',hrecst);
addtype('$methodpointer',methodpointertype); addtype('$methodpointer',methodpointertype);
{ Add a type for nested proc pointers } { Add a type for nested proc pointers }
hrecst:=trecordsymtable.create('',1,current_settings.alignment.recordalignmin,current_settings.alignment.maxCrecordalign); hrecst:=trecordsymtable.create('',1,current_settings.alignment.recordalignmin);
addfield(hrecst,cfieldvarsym.create('$proc',vs_value,voidcodepointertype,[],true)); addfield(hrecst,cfieldvarsym.create('$proc',vs_value,voidcodepointertype,[],true));
addfield(hrecst,cfieldvarsym.create('$parentfp',vs_value,parentfpvoidpointertype,[],true)); addfield(hrecst,cfieldvarsym.create('$parentfp',vs_value,parentfpvoidpointertype,[],true));
nestedprocpointertype:=crecorddef.create('',hrecst); nestedprocpointertype:=crecorddef.create('',hrecst);

4
compiler/ptype.pas
View File

@ -988,7 +988,7 @@ implementation
if (n<>'') or if (n<>'') or
not(target_info.system in systems_jvm) then not(target_info.system in systems_jvm) then
begin begin
recst:=trecordsymtable.create(n,current_settings.packrecords,current_settings.alignment.recordalignmin,current_settings.alignment.maxCrecordalign); recst:=trecordsymtable.create(n,current_settings.packrecords,current_settings.alignment.recordalignmin);
{ can't use recst.realname^ instead of n, because recst.realname is { can't use recst.realname^ instead of n, because recst.realname is
nil in case of an empty name } nil in case of an empty name }
current_structdef:=crecorddef.create(n,recst); current_structdef:=crecorddef.create(n,recst);
@ -998,7 +998,7 @@ implementation
{ for the JVM target records always need a name, because they are { for the JVM target records always need a name, because they are
represented by a class } represented by a class }
recst:=trecordsymtable.create(current_module.realmodulename^+'__fpc_intern_recname_'+tostr(current_module.deflist.count), recst:=trecordsymtable.create(current_module.realmodulename^+'__fpc_intern_recname_'+tostr(current_module.deflist.count),
current_settings.packrecords,current_settings.alignment.recordalignmin,current_settings.alignment.maxCrecordalign); current_settings.packrecords,current_settings.alignment.recordalignmin);
current_structdef:=crecorddef.create(recst.name^,recst); current_structdef:=crecorddef.create(recst.name^,recst);
end; end;
result:=current_structdef; result:=current_structdef;

21
compiler/symdef.pas
View File

@ -374,7 +374,7 @@ interface
variantrecdesc : pvariantrecdesc; variantrecdesc : pvariantrecdesc;
isunion : boolean; isunion : boolean;
constructor create(const n:string; p:TSymtable);virtual; constructor create(const n:string; p:TSymtable);virtual;
constructor create_global_internal(n: string; packrecords, recordalignmin, maxCrecordalign: shortint); virtual; constructor create_global_internal(n: string; packrecords, recordalignmin: shortint); virtual;
function add_field_by_def(const optionalname: TIDString; def: tdef): tsym; function add_field_by_def(const optionalname: TIDString; def: tdef): tsym;
procedure add_fields_from_deflist(fieldtypes: tfplist); procedure add_fields_from_deflist(fieldtypes: tfplist);
constructor ppuload(ppufile:tcompilerppufile); constructor ppuload(ppufile:tcompilerppufile);
@ -1387,8 +1387,7 @@ implementation
{ set recordalinmin to sizeof(pint), so the second field gets put at { set recordalinmin to sizeof(pint), so the second field gets put at
offset = sizeof(pint) as expected } offset = sizeof(pint) as expected }
result:=crecorddef.create_global_internal( result:=crecorddef.create_global_internal(
name,sizeof(pint),sizeof(pint), name,sizeof(pint),sizeof(pint));
init_settings.alignment.maxCrecordalign);
{$ifdef cpu16bitaddr} {$ifdef cpu16bitaddr}
index_field:=result.add_field_by_def('',u16inttype); index_field:=result.add_field_by_def('',u16inttype);
{$else cpu16bitaddr} {$else cpu16bitaddr}
@ -1424,8 +1423,7 @@ implementation
for i:=low(fields) to high(fields) do for i:=low(fields) to high(fields) do
fieldlist.add(fields[i]); fieldlist.add(fields[i]);
result:=crecorddef.create_global_internal(internaltypeprefixName[prefix],packrecords, result:=crecorddef.create_global_internal(internaltypeprefixName[prefix],packrecords,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
result.add_fields_from_deflist(fieldlist); result.add_fields_from_deflist(fieldlist);
fieldlist.free; fieldlist.free;
end; end;
@ -1456,8 +1454,7 @@ implementation
exit; exit;
end; end;
recdef:=crecorddef.create_global_internal(name,packrecords, recdef:=crecorddef.create_global_internal(name,packrecords,
targetinfos[target_info.system]^.alignment.recordalignmin, targetinfos[target_info.system]^.alignment.recordalignmin);
targetinfos[target_info.system]^.alignment.maxCrecordalign);
fields:=tfplist.create; fields:=tfplist.create;
fields.add(countdef); fields.add(countdef);
if count>0 then if count>0 then
@ -4783,7 +4780,7 @@ implementation
end; end;
constructor trecorddef.create_global_internal(n: string; packrecords, recordalignmin, maxCrecordalign: shortint); constructor trecorddef.create_global_internal(n: string; packrecords, recordalignmin: shortint);
var var
oldsymtablestack: tsymtablestack; oldsymtablestack: tsymtablestack;
ts: ttypesym; ts: ttypesym;
@ -4798,7 +4795,7 @@ implementation
that can have side-effects (e.g., it removes helpers) } that can have side-effects (e.g., it removes helpers) }
symtablestack:=nil; symtablestack:=nil;
symtable:=trecordsymtable.create(n,packrecords,recordalignmin,maxCrecordalign); symtable:=trecordsymtable.create(n,packrecords,recordalignmin);
symtable.defowner:=self; symtable.defowner:=self;
isunion:=false; isunion:=false;
inherited create(n,recorddef,true); inherited create(n,recorddef,true);
@ -4892,7 +4889,7 @@ implementation
end end
else else
begin begin
symtable:=trecordsymtable.create(objrealname^,0,0,0); symtable:=trecordsymtable.create(objrealname^,0,0);
trecordsymtable(symtable).fieldalignment:=shortint(ppufile.getbyte); trecordsymtable(symtable).fieldalignment:=shortint(ppufile.getbyte);
trecordsymtable(symtable).recordalignment:=shortint(ppufile.getbyte); trecordsymtable(symtable).recordalignment:=shortint(ppufile.getbyte);
trecordsymtable(symtable).padalignment:=shortint(ppufile.getbyte); trecordsymtable(symtable).padalignment:=shortint(ppufile.getbyte);
@ -7082,7 +7079,7 @@ implementation
if objecttype=odt_helper then if objecttype=odt_helper then
owner.includeoption(sto_has_helper); owner.includeoption(sto_has_helper);
symtable:=tObjectSymtable.create(self,n,current_settings.packrecords, symtable:=tObjectSymtable.create(self,n,current_settings.packrecords,
current_settings.alignment.recordalignmin,current_settings.alignment.maxCrecordalign); current_settings.alignment.recordalignmin);
{ create space for vmt !! } { create space for vmt !! }
vmtentries:=TFPList.Create; vmtentries:=TFPList.Create;
set_parent(c); set_parent(c);
@ -7112,7 +7109,7 @@ implementation
{ only used for external Objective-C classes/protocols } { only used for external Objective-C classes/protocols }
if (objextname^='') then if (objextname^='') then
stringdispose(objextname); stringdispose(objextname);
symtable:=tObjectSymtable.create(self,objrealname^,0,0,0); symtable:=tObjectSymtable.create(self,objrealname^,0,0);
tObjectSymtable(symtable).datasize:=ppufile.getasizeint; tObjectSymtable(symtable).datasize:=ppufile.getasizeint;
tObjectSymtable(symtable).paddingsize:=ppufile.getword; tObjectSymtable(symtable).paddingsize:=ppufile.getword;
tObjectSymtable(symtable).fieldalignment:=shortint(ppufile.getbyte); tObjectSymtable(symtable).fieldalignment:=shortint(ppufile.getbyte);

26
compiler/symtable.pas
View File

@ -108,10 +108,9 @@ interface
recordalignment, { alignment desired when inserting this record } recordalignment, { alignment desired when inserting this record }
fieldalignment, { alignment current alignment used when fields are inserted } fieldalignment, { alignment current alignment used when fields are inserted }
padalignment : shortint; { size to a multiple of which the symtable has to be rounded up } padalignment : shortint; { size to a multiple of which the symtable has to be rounded up }
recordalignmin, { local equivalents of global settings, so that records can } recordalignmin: shortint; { local equivalentsof global settings, so that records can be created with custom settings internally }
maxCrecordalign: shortint; { be created with custom settings internally }
has_fields_with_mop : tmanagementoperators; { whether any of the fields has the need for a management operator (or one of the field's fields) } has_fields_with_mop : tmanagementoperators; { whether any of the fields has the need for a management operator (or one of the field's fields) }
constructor create(const n:string;usealign,recordminalign,recordmaxCalign:shortint); constructor create(const n:string;usealign,recordminalign:shortint);
destructor destroy;override; destructor destroy;override;
procedure ppuload(ppufile:tcompilerppufile);override; procedure ppuload(ppufile:tcompilerppufile);override;
procedure ppuwrite(ppufile:tcompilerppufile);override; procedure ppuwrite(ppufile:tcompilerppufile);override;
@ -161,14 +160,14 @@ interface
{ object/classes. In XE5 and newer is possible to use class operator } { object/classes. In XE5 and newer is possible to use class operator }
{ for classes (like for Delphi .NET before) only for Delphi NEXTGEN } { for classes (like for Delphi .NET before) only for Delphi NEXTGEN }
managementoperators : tmanagementoperators; managementoperators : tmanagementoperators;
constructor create(const n:string;usealign,recordminalign,recordmaxCalign:shortint); constructor create(const n:string;usealign,recordminalign:shortint);
procedure insertunionst(unionst : trecordsymtable;offset : asizeint); procedure insertunionst(unionst : trecordsymtable;offset : asizeint);
procedure includemanagementoperator(mop:tmanagementoperator); procedure includemanagementoperator(mop:tmanagementoperator);
end; end;
tObjectSymtable = class(tabstractrecordsymtable) tObjectSymtable = class(tabstractrecordsymtable)
public public
constructor create(adefowner:tdef;const n:string;usealign,recordminalign,recordmaxCalign:shortint); constructor create(adefowner:tdef;const n:string;usealign,recordminalign:shortint);
function checkduplicate(var hashedid:THashedIDString;sym:TSymEntry):boolean;override; function checkduplicate(var hashedid:THashedIDString;sym:TSymEntry):boolean;override;
end; end;
@ -1170,7 +1169,7 @@ implementation
end; end;
{$endif llvm} {$endif llvm}
constructor tabstractrecordsymtable.create(const n:string;usealign,recordminalign,recordmaxCalign:shortint); constructor tabstractrecordsymtable.create(const n:string;usealign,recordminalign:shortint);
begin begin
inherited create(n); inherited create(n);
_datasize:=0; _datasize:=0;
@ -1178,7 +1177,6 @@ implementation
recordalignment:=1; recordalignment:=1;
usefieldalignment:=usealign; usefieldalignment:=usealign;
recordalignmin:=recordminalign; recordalignmin:=recordminalign;
maxCrecordalign:=recordmaxCalign;
padalignment:=1; padalignment:=1;
{ recordalign C_alignment means C record packing, that starts { recordalign C_alignment means C record packing, that starts
with an alignment of 1 } with an alignment of 1 }
@ -1310,7 +1308,7 @@ implementation
begin begin
case usefieldalignment of case usefieldalignment of
C_alignment: C_alignment:
varalignrecord:=used_align(varalign,recordalignmin,maxCrecordalign); varalignrecord:=used_align(varalign,recordalignmin,current_settings.alignment.maxCrecordalign);
mac68k_alignment: mac68k_alignment:
varalignrecord:=2; varalignrecord:=2;
else else
@ -1788,7 +1786,7 @@ implementation
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 (globalfieldalignment<maxCrecordalign) then if (globalfieldalignment<current_settings.alignment.maxCrecordalign) then
begin begin
if (varalign>16) and (globalfieldalignment<32) then if (varalign>16) and (globalfieldalignment<32) then
globalfieldalignment:=32 globalfieldalignment:=32
@ -1804,7 +1802,7 @@ implementation
else if (varalign>1) and (globalfieldalignment<2) then else if (varalign>1) and (globalfieldalignment<2) then
globalfieldalignment:=2; globalfieldalignment:=2;
end; end;
globalfieldalignment:=min(globalfieldalignment,maxCrecordalign); globalfieldalignment:=min(globalfieldalignment,current_settings.alignment.maxCrecordalign);
end; end;
mac68k_alignment: mac68k_alignment:
begin begin
@ -1836,9 +1834,9 @@ implementation
TRecordSymtable TRecordSymtable
****************************************************************************} ****************************************************************************}
constructor trecordsymtable.create(const n:string;usealign,recordminalign,recordmaxCalign:shortint); constructor trecordsymtable.create(const n:string;usealign,recordminalign:shortint);
begin begin
inherited create(n,usealign,recordminalign,recordmaxCalign); inherited create(n,usealign,recordminalign);
symtabletype:=recordsymtable; symtabletype:=recordsymtable;
end; end;
@ -1963,9 +1961,9 @@ implementation
TObjectSymtable TObjectSymtable
****************************************************************************} ****************************************************************************}
constructor tObjectSymtable.create(adefowner:tdef;const n:string;usealign,recordminalign,recordmaxCalign:shortint); constructor tObjectSymtable.create(adefowner:tdef;const n:string;usealign,recordminalign:shortint);
begin begin
inherited create(n,usealign,recordminalign,recordmaxCalign); inherited create(n,usealign,recordminalign);
symtabletype:=ObjectSymtable; symtabletype:=ObjectSymtable;
defowner:=adefowner; defowner:=adefowner;
end; end;