paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-08-10 14:26:00 +02:00
Code Issues Packages Projects Releases Wiki Activity

* reginfo now also only allocated during register allocation

Browse Source 
* third round of gdb cleanups: kick out most of concatstabto
This commit is contained in:
daniel 2004-01-26 16:12:27 +00:00
parent bf36516f33
commit 97e87aaebc
18 changed files with 873 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
compiler/aasmtai.pas
View File

@ -37,7 +37,7 @@ interface
globtype,globals,systems, globtype,globals,systems,
cpuinfo,cpubase, cpuinfo,cpubase,
cgbase, cgbase,
symppu,symtype, symtype,
aasmbase; aasmbase;
type type
@ -1971,7 +1971,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.66 2004-01-24 18:12:40 florian Revision 1.67 2004-01-26 16:12:27 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.66 2004/01/24 18:12:40 florian
* fixed several arm floating point issues * fixed several arm floating point issues
Revision 1.65 2004/01/23 15:12:49 florian Revision 1.65 2004/01/23 15:12:49 florian

8
compiler/fppu.pas
View File

@ -38,7 +38,7 @@ interface
uses uses
cutils,cclasses, cutils,cclasses,
globtype,globals,finput,fmodule, globtype,globals,finput,fmodule,
symbase,symppu,ppu; symbase,ppu,symtype;
type type
tppumodule = class(tmodule) tppumodule = class(tmodule)
@ -1514,7 +1514,11 @@ uses
end. end.
{ {
$Log$ $Log$
Revision 1.50 2004-01-22 17:23:56 peter Revision 1.51 2004-01-26 16:12:27 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.50 2004/01/22 17:23:56 peter
* also check in the same dir as the unit we are loading from, this * also check in the same dir as the unit we are loading from, this
makes UNITPATH working better makes UNITPATH working better

8
compiler/nbas.pas
View File

@ -30,7 +30,7 @@ interface
cpubase,cgbase, cpubase,cgbase,
aasmbase,aasmtai,aasmcpu, aasmbase,aasmtai,aasmcpu,
node,tgobj, node,tgobj,
symtype,symppu; symtype;
type type
tnothingnode = class(tnode) tnothingnode = class(tnode)
@ -983,7 +983,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.74 2003-12-10 20:31:40 jonas Revision 1.75 2004-01-26 16:12:27 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.74 2003/12/10 20:31:40 jonas
* override tblocknode.destroy so all statements are freed sequentially * override tblocknode.destroy so all statements are freed sequentially
instead of recusively. instead of recusively.

8
compiler/ncal.pas
View File

@ -34,7 +34,7 @@ interface
{$ifdef state_tracking} {$ifdef state_tracking}
nstate, nstate,
{$endif state_tracking} {$endif state_tracking}
symbase,symtype,symppu,symsym,symdef,symtable; symbase,symtype,symsym,symdef,symtable;
type type
pcandidate = ^tcandidate; pcandidate = ^tcandidate;
@ -2711,7 +2711,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.220 2004-01-15 15:16:18 daniel Revision 1.221 2004-01-26 16:12:27 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.220 2004/01/15 15:16:18 daniel
* Some minor stuff * Some minor stuff
* Managed to eliminate speed effects of string compression * Managed to eliminate speed effects of string compression

8
compiler/ncnv.pas
View File

@ -28,7 +28,7 @@ interface
uses uses
node, node,
symtype,symppu, symtype,
defutil,defcmp, defutil,defcmp,
nld nld
{$ifdef Delphi} {$ifdef Delphi}
@ -2405,7 +2405,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.134 2003-12-26 00:32:21 florian Revision 1.135 2004-01-26 16:12:27 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.134 2003/12/26 00:32:21 florian
+ fpu<->mm register conversion + fpu<->mm register conversion
Revision 1.133 2003/12/22 23:11:15 peter Revision 1.133 2003/12/22 23:11:15 peter

8
compiler/ncon.pas
View File

@ -30,7 +30,7 @@ interface
globtype,widestr, globtype,widestr,
node, node,
aasmbase,aasmtai,cpuinfo,globals, aasmbase,aasmtai,cpuinfo,globals,
symconst,symppu,symtype,symdef,symsym; symconst,symtype,symdef,symsym;
type type
trealconstnode = class(tnode) trealconstnode = class(tnode)
@ -950,7 +950,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.57 2004-01-12 16:35:40 peter Revision 1.58 2004-01-26 16:12:27 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.57 2004/01/12 16:35:40 peter
* range check error * range check error
Revision 1.56 2003/10/23 14:44:07 peter Revision 1.56 2003/10/23 14:44:07 peter

8
compiler/nflw.pas
View File

@ -30,7 +30,7 @@ interface
uses uses
node,cpubase, node,cpubase,
aasmbase,aasmtai,aasmcpu,symnot, aasmbase,aasmtai,aasmcpu,symnot,
symppu,symtype,symbase,symdef,symsym; symtype,symbase,symdef,symsym;
type type
{ flags used by loop nodes } { flags used by loop nodes }
@ -1475,7 +1475,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.91 2003-12-28 22:51:18 florian Revision 1.92 2004-01-26 16:12:27 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.91 2003/12/28 22:51:18 florian
+ except handling related nodes now include pi_do_call if necessary + except handling related nodes now include pi_do_call if necessary
Revision 1.90 2003/12/08 19:29:21 peter Revision 1.90 2003/12/08 19:29:21 peter

10
compiler/ninl.pas
View File

@ -27,7 +27,7 @@ unit ninl;
interface interface
uses uses
node,htypechk,cpuinfo,symppu; node,htypechk,cpuinfo,symtype;
{$i compinnr.inc} {$i compinnr.inc}
@ -72,7 +72,7 @@ implementation
uses uses
verbose,globals,systems, verbose,globals,systems,
globtype, cutils, globtype, cutils,
symbase,symconst,symtype,symdef,symsym,symtable,paramgr,defutil,defcmp, symbase,symconst,symdef,symsym,symtable,paramgr,defutil,defcmp,
pass_1, pass_1,
ncal,ncon,ncnv,nadd,nld,nbas,nflw,nmem,nmat, ncal,ncon,ncnv,nadd,nld,nbas,nflw,nmem,nmat,
cgbase,procinfo cgbase,procinfo
@ -2366,7 +2366,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.126 2003-12-31 20:47:02 jonas Revision 1.127 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.126 2003/12/31 20:47:02 jonas
* properly fixed assigned() mess (by handling it separately in ncginl) * properly fixed assigned() mess (by handling it separately in ncginl)
-> all assigned()-related tests in the test suite work again -> all assigned()-related tests in the test suite work again

8
compiler/nld.pas
View File

@ -31,7 +31,7 @@ interface
{$ifdef state_tracking} {$ifdef state_tracking}
nstate, nstate,
{$endif} {$endif}
symconst,symppu,symbase,symtype,symsym,symdef; symconst,symbase,symtype,symsym,symdef;
type type
tloadnode = class(tunarynode) tloadnode = class(tunarynode)
@ -1246,7 +1246,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.119 2003-12-01 18:44:15 peter Revision 1.120 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.119 2003/12/01 18:44:15 peter
* fixed some crashes * fixed some crashes
* fixed varargs and register calling probs * fixed varargs and register calling probs

8
compiler/nmem.pas
View File

@ -28,7 +28,7 @@ interface
uses uses
node, node,
symtype,symppu,symdef,symsym,symtable, symdef,symsym,symtable,symtype,
cpubase; cpubase;
type type
@ -967,7 +967,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.76 2003-12-12 15:42:53 peter Revision 1.77 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.76 2003/12/12 15:42:53 peter
* don't give warnings for shortstring vecnodes * don't give warnings for shortstring vecnodes
Revision 1.75 2003/12/08 22:35:06 peter Revision 1.75 2003/12/08 22:35:06 peter

8
compiler/node.pas
View File

@ -31,7 +31,7 @@ interface
globtype,globals, globtype,globals,
cpubase,cgbase, cpubase,cgbase,
aasmbase, aasmbase,
symtype,symppu; symtype;
type type
pconstset = ^tconstset; pconstset = ^tconstset;
@ -1087,7 +1087,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.79 2003-12-26 00:32:22 florian Revision 1.80 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.79 2003/12/26 00:32:22 florian
+ fpu<->mm register conversion + fpu<->mm register conversion
Revision 1.78 2003/12/01 18:44:15 peter Revision 1.78 2003/12/01 18:44:15 peter

9
compiler/nset.pas
View File

@ -28,8 +28,7 @@ interface
uses uses
node,globals, node,globals,
aasmbase,aasmtai, aasmbase,aasmtai,symtype;
symppu;
type type
pcaserecord = ^tcaserecord; pcaserecord = ^tcaserecord;
@ -695,7 +694,11 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.50 2003-11-10 19:10:57 peter Revision 1.51 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.50 2003/11/10 19:10:57 peter
* check for enumdef.maxval<255 instead of enumdef.savesize * check for enumdef.maxval<255 instead of enumdef.savesize
Revision 1.49 2003/10/23 14:44:07 peter Revision 1.49 2003/10/23 14:44:07 peter

43
compiler/rgobj.pas
View File

@ -240,6 +240,8 @@ unit rgobj;
{$ifdef EXTDEBUG} {$ifdef EXTDEBUG}
procedure writegraph(loopidx:longint); procedure writegraph(loopidx:longint);
{$endif EXTDEBUG} {$endif EXTDEBUG}
{# Disposes of the reginfo array.}
procedure dispose_reginfo;
{# Prepare the register colouring.} {# Prepare the register colouring.}
procedure prepare_colouring; procedure prepare_colouring;
{# Clean up after register colouring.} {# Clean up after register colouring.}
@ -374,15 +376,15 @@ implementation
used_in_proc:=[]; used_in_proc:=[];
live_registers.init; live_registers.init;
{ Get reginfo for CPU registers } { Get reginfo for CPU registers }
reginfo:=allocmem(first_imaginary*sizeof(treginfo));
maxreginfo:=first_imaginary; maxreginfo:=first_imaginary;
maxreginfoinc:=16; maxreginfoinc:=16;
worklist_moves:=Tlinkedlist.create;
reginfo:=allocmem(first_imaginary*sizeof(treginfo));
for i:=0 to first_imaginary-1 do for i:=0 to first_imaginary-1 do
begin begin
reginfo[i].degree:=high(tsuperregister); reginfo[i].degree:=high(tsuperregister);
reginfo[i].alias:=RS_INVALID; reginfo[i].alias:=RS_INVALID;
end; end;
worklist_moves:=Tlinkedlist.create;
{ Usable registers } { Usable registers }
fillchar(usable_registers,sizeof(usable_registers),0); fillchar(usable_registers,sizeof(usable_registers),0);
for i:=low(Ausable) to high(Ausable) do for i:=low(Ausable) to high(Ausable) do
@ -399,8 +401,6 @@ implementation
destructor trgobj.destroy; destructor trgobj.destroy;
var i:Tsuperregister;
begin begin
spillednodes.done; spillednodes.done;
simplifyworklist.done; simplifyworklist.done;
@ -408,17 +408,28 @@ implementation
spillworklist.done; spillworklist.done;
coalescednodes.done; coalescednodes.done;
selectstack.done; selectstack.done;
for i:=0 to maxreg-1 do
begin
if reginfo[i].adjlist<>nil then
dispose(reginfo[i].adjlist,done);
if reginfo[i].movelist<>nil then
dispose(reginfo[i].movelist);
end;
freemem(reginfo);
worklist_moves.free; worklist_moves.free;
dispose_reginfo;
end; end;
procedure Trgobj.dispose_reginfo;
var i:Tsuperregister;
begin
if reginfo<>nil then
begin
for i:=0 to maxreg-1 do
begin
if reginfo[i].adjlist<>nil then
dispose(reginfo[i].adjlist,done);
if reginfo[i].movelist<>nil then
dispose(reginfo[i].movelist);
end;
freemem(reginfo);
reginfo:=nil;
end;
end;
function trgobj.getnewreg(subreg:tsubregister):tsuperregister; function trgobj.getnewreg(subreg:tsubregister):tsuperregister;
var var
@ -503,6 +514,7 @@ implementation
var var
spillingcounter:byte; spillingcounter:byte;
endspill:boolean; endspill:boolean;
i:Tsuperregister;
begin begin
{ Insert regalloc info for imaginary registers } { Insert regalloc info for imaginary registers }
insert_regalloc_info(list,headertai); insert_regalloc_info(list,headertai);
@ -528,6 +540,7 @@ implementation
until endspill; until endspill;
ibitmap.free; ibitmap.free;
translate_registers(list); translate_registers(list);
dispose_reginfo;
end; end;
@ -1817,9 +1830,9 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.113 2004-01-25 23:21:02 daniel Revision 1.114 2004-01-26 16:12:28 daniel
* Keep interference bitmap only allocated during register allocation. * reginfo now also only allocated during register allocation
Saves 2 mb of memory. * third round of gdb cleanups: kick out most of concatstabto
Revision 1.112 2004/01/12 16:37:59 peter Revision 1.112 2004/01/12 16:37:59 peter
* moved spilling code from taicpu to rg * moved spilling code from taicpu to rg

8
compiler/symdef.pas
View File

@ -33,7 +33,7 @@ interface
{ symtable } { symtable }
symconst,symbase,symtype, symconst,symbase,symtype,
{ ppu } { ppu }
symppu,ppu, ppu,
{ node } { node }
node, node,
{ aasm } { aasm }
@ -6191,7 +6191,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.206 2004-01-25 20:23:28 daniel Revision 1.207 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.206 2004/01/25 20:23:28 daniel
* More gdb cleanup: make record & object stab generation linear instead * More gdb cleanup: make record & object stab generation linear instead
of quadratic. of quadratic.

464
compiler/symsym.pas
View File

@ -33,7 +33,7 @@ interface
{ symtable } { symtable }
symconst,symbase,symtype,symdef,defcmp, symconst,symbase,symtype,symdef,defcmp,
{ ppu } { ppu }
ppu,symppu, ppu,
cclasses,symnot, cclasses,symnot,
{ aasm } { aasm }
aasmbase,aasmtai, aasmbase,aasmtai,
@ -50,30 +50,20 @@ interface
protected protected
_mangledname : pstring; _mangledname : pstring;
public public
refs : longint;
lastref,
defref,
lastwritten : tref;
refcount : longint;
{$ifdef GDB} {$ifdef GDB}
isstabwritten : boolean; isstabwritten : boolean;
{$endif GDB} {$endif GDB}
constructor create(const n : string); constructor create(const n : string);
constructor loadsym(ppufile:tcompilerppufile); constructor loadsym(ppufile:tcompilerppufile);
destructor destroy;override; destructor destroy;override;
procedure ppuwrite(ppufile:tcompilerppufile);virtual;abstract;
procedure writesym(ppufile:tcompilerppufile);
procedure buildderef;override; procedure buildderef;override;
procedure deref;override; procedure deref;override;
{$ifdef GDB} {$ifdef GDB}
function get_var_value(const s:string):string; function get_var_value(const s:string):string;
function stabstr_evaluate(const s:string;vars:array of string):Pchar; function stabstr_evaluate(const s:string;vars:array of string):Pchar;
function stabstring : pchar;virtual; function stabstring : pchar;virtual;
procedure concatstabto(asmlist : taasmoutput);virtual; procedure concatstabto(asmlist : taasmoutput);
{$endif GDB} {$endif GDB}
procedure load_references(ppufile:tcompilerppufile;locals:boolean);virtual;
function write_references(ppufile:tcompilerppufile;locals:boolean):boolean;virtual;
function is_visible_for_object(currobjdef:tobjectdef):boolean;
function mangledname : string; function mangledname : string;
procedure generate_mangledname;virtual;abstract; procedure generate_mangledname;virtual;abstract;
end; end;
@ -97,11 +87,11 @@ interface
destructor destroy;override; destructor destroy;override;
procedure ppuwrite(ppufile:tcompilerppufile);override; procedure ppuwrite(ppufile:tcompilerppufile);override;
{$ifdef GDB} {$ifdef GDB}
procedure concatstabto(asmlist : taasmoutput);override; function stabstring:Pchar;override;
{$endif GDB} {$endif GDB}
end; end;
terrorsym = class(tstoredsym) terrorsym = class(Tsym)
constructor create; constructor create;
end; end;
@ -151,7 +141,6 @@ interface
function write_references(ppufile:tcompilerppufile;locals:boolean):boolean;override; function write_references(ppufile:tcompilerppufile;locals:boolean):boolean;override;
{$ifdef GDB} {$ifdef GDB}
function stabstring : pchar;override; function stabstring : pchar;override;
procedure concatstabto(asmlist : taasmoutput);override;
{$endif GDB} {$endif GDB}
end; end;
@ -170,7 +159,6 @@ interface
function write_references(ppufile:tcompilerppufile;locals:boolean):boolean;override; function write_references(ppufile:tcompilerppufile;locals:boolean):boolean;override;
{$ifdef GDB} {$ifdef GDB}
function stabstring : pchar;override; function stabstring : pchar;override;
procedure concatstabto(asmlist : taasmoutput);override;
{$endif GDB} {$endif GDB}
end; end;
@ -202,7 +190,6 @@ interface
procedure unregister_notification(id:cardinal); procedure unregister_notification(id:cardinal);
{$ifdef GDB} {$ifdef GDB}
function stabstring : pchar;override; function stabstring : pchar;override;
procedure concatstabto(asmlist : taasmoutput);override;
{$endif GDB} {$endif GDB}
private private
procedure setvartype(const newtype: ttype); procedure setvartype(const newtype: ttype);
@ -233,7 +220,6 @@ interface
procedure dooverride(overriden:tpropertysym); procedure dooverride(overriden:tpropertysym);
{$ifdef GDB} {$ifdef GDB}
function stabstring : pchar;override; function stabstring : pchar;override;
procedure concatstabto(asmlist : taasmoutput);override;
{$endif GDB} {$endif GDB}
end; end;
@ -251,7 +237,7 @@ interface
function mangledname : string; function mangledname : string;
procedure ppuwrite(ppufile:tcompilerppufile);override; procedure ppuwrite(ppufile:tcompilerppufile);override;
{$ifdef GDB} {$ifdef GDB}
procedure concatstabto(asmlist : taasmoutput);override; function stabstring : pchar;override;
{$endif GDB} {$endif GDB}
end; end;
@ -298,7 +284,6 @@ interface
procedure ppuwrite(ppufile:tcompilerppufile);override; procedure ppuwrite(ppufile:tcompilerppufile);override;
{$ifdef GDB} {$ifdef GDB}
function stabstring : pchar;override; function stabstring : pchar;override;
procedure concatstabto(asmlist : taasmoutput);override;
{$endif GDB} {$endif GDB}
end; end;
@ -314,7 +299,7 @@ interface
procedure deref;override; procedure deref;override;
procedure order; procedure order;
{$ifdef GDB} {$ifdef GDB}
procedure concatstabto(asmlist : taasmoutput);override; function stabstring:Pchar;
{$endif GDB} {$endif GDB}
end; end;
@ -325,7 +310,7 @@ interface
destructor destroy;override; destructor destroy;override;
procedure ppuwrite(ppufile:tcompilerppufile);override; procedure ppuwrite(ppufile:tcompilerppufile);override;
{$ifdef GDB} {$ifdef GDB}
procedure concatstabto(asmlist : taasmoutput);override; function stabstring:Pchar;
{$endif GDB} {$endif GDB}
end; end;
@ -408,15 +393,6 @@ implementation
isstabwritten := false; isstabwritten := false;
{$endif GDB} {$endif GDB}
fileinfo:=akttokenpos; fileinfo:=akttokenpos;
defref:=nil;
refs:=0;
lastwritten:=nil;
refcount:=0;
if (cs_browser in aktmoduleswitches) and make_ref then
begin
defref:=tref.create(defref,@akttokenpos);
inc(refcount);
end;
lastref:=defref; lastref:=defref;
_mangledname:=nil; _mangledname:=nil;
end; end;
@ -427,25 +403,13 @@ implementation
s : string; s : string;
nr : word; nr : word;
begin begin
nr:=ppufile.getword; inherited loadsym(ppufile);
s:=ppufile.getstring;
inherited create(s);
{ force the correct indexnr. must be after create! }
indexnr:=nr;
ppufile.getposinfo(fileinfo);
ppufile.getsmallset(symoptions);
lastref:=nil;
defref:=nil;
refs:=0;
lastwritten:=nil;
refcount:=0;
_mangledname:=nil; _mangledname:=nil;
{$ifdef GDB} {$ifdef GDB}
isstabwritten := false; isstabwritten := false;
{$endif GDB} {$endif GDB}
end; end;
procedure tstoredsym.buildderef; procedure tstoredsym.buildderef;
begin begin
end; end;
@ -456,76 +420,6 @@ implementation
end; end;
procedure tstoredsym.load_references(ppufile:tcompilerppufile;locals:boolean);
var
pos : tfileposinfo;
move_last : boolean;
begin
move_last:=lastwritten=lastref;
while (not ppufile.endofentry) do
begin
ppufile.getposinfo(pos);
inc(refcount);
lastref:=tref.create(lastref,@pos);
lastref.is_written:=true;
if refcount=1 then
defref:=lastref;
end;
if move_last then
lastwritten:=lastref;
end;
{ big problem here :
wrong refs were written because of
interface parsing of other units PM
moduleindex must be checked !! }
function tstoredsym.write_references(ppufile:tcompilerppufile;locals:boolean):boolean;
var
d : tderef;
ref : tref;
symref_written,move_last : boolean;
begin
write_references:=false;
if lastwritten=lastref then
exit;
{ should we update lastref }
move_last:=true;
symref_written:=false;
{ write symbol refs }
d.reset;
if assigned(lastwritten) then
ref:=lastwritten
else
ref:=defref;
while assigned(ref) do
begin
if ref.moduleindex=current_module.unit_index then
begin
{ write address to this symbol }
if not symref_written then
begin
d.build(self);
ppufile.putderef(d);
symref_written:=true;
end;
ppufile.putposinfo(ref.posinfo);
ref.is_written:=true;
if move_last then
lastwritten:=ref;
end
else if not ref.is_written then
move_last:=false
else if move_last then
lastwritten:=ref;
ref:=ref.nextref;
end;
if symref_written then
ppufile.writeentry(ibsymref);
write_references:=symref_written;
end;
destructor tstoredsym.destroy; destructor tstoredsym.destroy;
begin begin
if assigned(_mangledname) then if assigned(_mangledname) then
@ -552,15 +446,6 @@ implementation
inherited destroy; inherited destroy;
end; end;
procedure tstoredsym.writesym(ppufile:tcompilerppufile);
begin
ppufile.putword(indexnr);
ppufile.putstring(_realname^);
ppufile.putposinfo(fileinfo);
ppufile.putsmallset(symoptions);
end;
{$ifdef GDB} {$ifdef GDB}
function Tstoredsym.get_var_value(const s:string):string; function Tstoredsym.get_var_value(const s:string):string;
@ -609,45 +494,12 @@ implementation
begin begin
stab_str := stabstring; stab_str := stabstring;
if assigned(stab_str) then if assigned(stab_str) then
asmList.concat(Tai_stabs.Create(stab_str)); asmlist.concat(Tai_stabs.create(stab_str));
isstabwritten:=true; isstabwritten:=true;
end; end;
end; end;
{$endif GDB} {$endif GDB}
function tstoredsym.is_visible_for_object(currobjdef:tobjectdef):boolean;
begin
is_visible_for_object:=false;
{ private symbols are allowed when we are in the same
module as they are defined }
if (sp_private in symoptions) and
assigned(owner.defowner) and
(owner.defowner.owner.symtabletype in [globalsymtable,staticsymtable]) and
(owner.defowner.owner.unitid<>0) then
exit;
{ protected symbols are vissible in the module that defines them and
also visible to related objects }
if (sp_protected in symoptions) and
(
(
assigned(owner.defowner) and
(owner.defowner.owner.symtabletype in [globalsymtable,staticsymtable]) and
(owner.defowner.owner.unitid<>0)
) and
not(
assigned(currobjdef) and
currobjdef.is_related(tobjectdef(owner.defowner))
)
) then
exit;
is_visible_for_object:=true;
end;
function tstoredsym.mangledname : string; function tstoredsym.mangledname : string;
begin begin
if not assigned(_mangledname) then if not assigned(_mangledname) then
@ -759,10 +611,11 @@ implementation
end; end;
{$ifdef GDB} {$ifdef GDB}
procedure tunitsym.concatstabto(asmlist : taasmoutput); function Tunitsym.stabstring:Pchar;
begin
{Nothing to write to stabs !} begin
end; stabstring:=nil;
end;
{$endif GDB} {$endif GDB}
{**************************************************************************** {****************************************************************************
@ -1362,13 +1215,7 @@ implementation
function tprocsym.stabstring : pchar; function tprocsym.stabstring : pchar;
begin begin
internalerror(200111171); internalerror(200111171);
stabstring:=nil;
end; end;
procedure tprocsym.concatstabto(asmlist : taasmoutput);
begin
internalerror(200111172);
end;
{$endif GDB} {$endif GDB}
@ -1526,11 +1373,6 @@ implementation
{ !!!! don't know how to handle } { !!!! don't know how to handle }
stabstring:=nil; stabstring:=nil;
end; end;
procedure tpropertysym.concatstabto(asmlist : taasmoutput);
begin
{ !!!! don't know how to handle }
end;
{$endif GDB} {$endif GDB}
@ -1648,10 +1490,11 @@ implementation
{$ifdef GDB} {$ifdef GDB}
procedure tabsolutesym.concatstabto(asmlist : taasmoutput); function Tabsolutesym.stabstring:Pchar;
begin
{ I don't know how to handle this !! } begin
end; stabstring:=nil;
end;
{$endif GDB} {$endif GDB}
@ -1849,124 +1692,117 @@ implementation
end; end;
{$ifdef GDB} {$ifdef GDB}
function tvarsym.stabstring : pchar; function Tvarsym.stabstring:Pchar;
var
st : string;
threadvaroffset : string;
regidx : tregisterindex;
begin
stabstring:=nil;
st:=tstoreddef(vartype.def).numberstring;
if (vo_is_thread_var in varoptions) then
threadvaroffset:='+'+tostr(pointer_size)
else
threadvaroffset:='';
case owner.symtabletype of var st:string;
objectsymtable : threadvaroffset:string;
if (sp_static in symoptions) then regidx:Tregisterindex;
begin c:char;
if (cs_gdb_gsym in aktglobalswitches) then
st:='G'+st
else
st:='S'+st;
stabstring:=stabstr_evaluate('"${ownername}__${name}:$1",${N_LCSYM},0,${line},${mangledname}$2',[st,threadvaroffset]);
end;
globalsymtable :
begin
{ Here we used S instead of
because with G GDB doesn't look at the address field
but searches the same name or with a leading underscore
but these names don't exist in pascal !}
if (cs_gdb_gsym in aktglobalswitches) then
st:='G'+st
else
st:='S'+st;
stabstring:=stabstr_evaluate('"${name}:$1",${N_LCSYM},0,${line},${mangledname}$2',[st,threadvaroffset]);
end;
staticsymtable :
stabstring:=stabstr_evaluate('"${name}:S$1",${N_LCSYM},0,${line},${mangledname}$2',[st,threadvaroffset]);
parasymtable,
localsymtable :
begin
{ There is no space allocated for not referenced locals }
if (owner.symtabletype=localsymtable) and (refs=0) then
exit;
if (vo_is_C_var in varoptions) then begin
begin if (vo_is_self in varoptions) then
stabstring:=stabstr_evaluate('"${name}:S$1",${N_LCSYM},0,${line},${mangledname}',[st]); begin
exit; if localloc.loc<>LOC_REFERENCE then
end; internalerror(2003091815);
if (owner.symtabletype=parasymtable) then if (po_classmethod in current_procinfo.procdef.procoptions) or
begin (po_staticmethod in current_procinfo.procdef.procoptions) then
if paramanager.push_addr_param(varspez,vartype.def,tprocdef(owner.defowner).proccalloption) and stabstring:=stabstr_evaluate('"pvmt:p$1",${N_TSYM},0,0,$2',
not(vo_has_local_copy in varoptions) then [Tstoreddef(pvmttype.def).numberstring,tostr(localloc.reference.offset)])
st := 'v'+st { should be 'i' but 'i' doesn't work } else
else begin
st := 'p'+st; if not(is_class(current_procinfo.procdef._class)) then
end; c:='v'
case localloc.loc of else
LOC_REGISTER, LOC_FPUREGISTER : c:='p';
begin stabstring:=stabstr_evaluate('"$$t:$1",${N_TSYM},0,0,$2',
regidx:=findreg_by_number(localloc.register); [c+current_procinfo.procdef._class.numberstring,tostr(localloc.reference.offset)]);
{ "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "eip", "ps", "cs", "ss", "ds", "es", "fs", "gs", } end;
{ this is the register order for GDB} end
stabstring:=stabstr_evaluate('"${name}:r$1",${N_RSYM},0,${line},$2',[st,tostr(regstabs_table[regidx])]); else
end; (*
LOC_REFERENCE : if (localloc.loc=LOC_REGISTER) then
{ offset to ebp => will not work if the framepointer is esp begin
so some optimizing will make things harder to debug } regidx:=findreg_by_number(localloc.register);
stabstring:=stabstr_evaluate('"${name}:$1",${N_TSYM},0,${line},$2',[st,tostr(localloc.reference.offset)]) { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "eip", "ps", "cs", "ss", "ds", "es", "fs", "gs", }
else { this is the register order for GDB}
internalerror(2003091814); stabstring:=stabstr_evaluate('"${name}:r$1",${N_RSYM},0,${line},$2',
end; [Tstoreddef(vartype.def).numberstring,tostr(regstabs_table[regidx])]);
end; end
else else
stabstring := inherited stabstring; *)
end; begin
end; stabstring:=nil;
st:=tstoreddef(vartype.def).numberstring;
if (vo_is_thread_var in varoptions) then
threadvaroffset:='+'+tostr(pointer_size)
else
threadvaroffset:='';
case owner.symtabletype of
objectsymtable:
if (sp_static in symoptions) then
begin
if (cs_gdb_gsym in aktglobalswitches) then
st:='G'+st
else
st:='S'+st;
stabstring:=stabstr_evaluate('"${ownername}__${name}:$1",${N_LCSYM},0,${line},${mangledname}$2',
[st,threadvaroffset]);
end;
globalsymtable:
begin
{ Here we used S instead of
because with G GDB doesn't look at the address field
but searches the same name or with a leading underscore
but these names don't exist in pascal !}
if (cs_gdb_gsym in aktglobalswitches) then
st:='G'+st
else
st:='S'+st;
stabstring:=stabstr_evaluate('"${name}:$1",${N_LCSYM},0,${line},${mangledname}$2',[st,threadvaroffset]);
end;
staticsymtable :
stabstring:=stabstr_evaluate('"${name}:S$1",${N_LCSYM},0,${line},${mangledname}$2',[st,threadvaroffset]);
parasymtable,localsymtable:
begin
{ There is no space allocated for not referenced locals }
if (owner.symtabletype=localsymtable) and (refs=0) then
exit;
procedure tvarsym.concatstabto(asmlist : taasmoutput); if (vo_is_C_var in varoptions) then
var begin
regidx : tregisterindex; stabstring:=stabstr_evaluate('"${name}:S$1",${N_LCSYM},0,${line},${mangledname}',[st]);
stab_str : pchar; exit;
c : char; end;
begin if (owner.symtabletype=parasymtable) then
if (owner.symtabletype=parasymtable) and begin
(copy(name,1,6)='hidden') then if paramanager.push_addr_param(varspez,vartype.def,tprocdef(owner.defowner).proccalloption) and
exit; not(vo_has_local_copy in varoptions) then
if (vo_is_self in varoptions) then st := 'v'+st { should be 'i' but 'i' doesn't work }
begin else
if localloc.loc<>LOC_REFERENCE then st := 'p'+st;
internalerror(2003091815); end;
if (po_classmethod in current_procinfo.procdef.procoptions) or case localloc.loc of
(po_staticmethod in current_procinfo.procdef.procoptions) then LOC_REGISTER, LOC_FPUREGISTER :
asmlist.concat(Tai_stabs.create(stabstr_evaluate('"pvmt:p$1",${N_TSYM},0,0,$2', begin
[Tstoreddef(pvmttype.def).numberstring,tostr(localloc.reference.offset)]))) regidx:=findreg_by_number(localloc.register);
else { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "eip", "ps", "cs", "ss", "ds", "es", "fs", "gs", }
begin { this is the register order for GDB}
if not(is_class(current_procinfo.procdef._class)) then stabstring:=stabstr_evaluate('"${name}:r$1",${N_RSYM},0,${line},$2',[st,tostr(regstabs_table[regidx])]);
c:='v' end;
else LOC_REFERENCE :
c:='p'; { offset to ebp => will not work if the framepointer is esp
asmlist.concat(Tai_stabs.create(stabstr_evaluate('"$$t:$1",${N_TSYM},0,0,$2', so some optimizing will make things harder to debug }
[c+current_procinfo.procdef._class.numberstring,tostr(localloc.reference.offset)]))); stabstring:=stabstr_evaluate('"${name}:$1",${N_TSYM},0,${line},$2',[st,tostr(localloc.reference.offset)])
end; else
end internalerror(2003091814);
else end;
if (localloc.loc=LOC_REGISTER) then end;
begin else
regidx:=findreg_by_number(localloc.register); stabstring := inherited stabstring;
{ "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "eip", "ps", "cs", "ss", "ds", "es", "fs", "gs", } end;
{ this is the register order for GDB} end;
asmlist.concat(Tai_stabs.create(stabstr_evaluate('"${name}:r$1",${N_RSYM},0,${line},$2', end;
[Tstoreddef(vartype.def).numberstring,tostr(regstabs_table[regidx])])));
end
else
inherited concatstabto(asmlist);
end;
{$endif GDB} {$endif GDB}
procedure tvarsym.setvartype(const newtype: ttype); procedure tvarsym.setvartype(const newtype: ttype);
@ -2337,12 +2173,6 @@ implementation
end; end;
stabstring:=stabstr_evaluate('"${name}:c=$1",${N_FUNCTION},0,${line},0',[st]); stabstring:=stabstr_evaluate('"${name}:c=$1",${N_FUNCTION},0,${line},0',[st]);
end; end;
procedure tconstsym.concatstabto(asmlist : taasmoutput);
begin
if consttyp <> conststring then
inherited concatstabto(asmlist);
end;
{$endif GDB} {$endif GDB}
@ -2428,9 +2258,10 @@ implementation
{$ifdef GDB} {$ifdef GDB}
procedure tenumsym.concatstabto(asmlist : taasmoutput); function Tenumsym.stabstring:Pchar;
begin begin
{enum elements have no stab !} {enum elements have no stab !}
end; end;
{$EndIf GDB} {$EndIf GDB}
@ -2534,22 +2365,17 @@ implementation
var stabchar:string[2]; var stabchar:string[2];
begin begin
if restype.def.deftype in tagtypes then if restype.def=nil then
stabchar:='Tt' stabstring:=nil
else else
stabchar:='t'; begin
stabstring:=stabstr_evaluate('"${name}:$1$2",${N_LSYM},0,${line},0',[stabchar,tstoreddef(restype.def).numberstring]); if restype.def.deftype in tagtypes then
stabchar:='Tt'
else
stabchar:='t';
stabstring:=stabstr_evaluate('"${name}:$1$2",${N_LSYM},0,${line},0',[stabchar,tstoreddef(restype.def).numberstring]);
end;
end; end;
procedure ttypesym.concatstabto(asmlist : taasmoutput);
begin
{not stabs for forward defs }
if assigned(restype.def) then
if (restype.def.typesym = self) then
tstoreddef(restype.def).concatstabto(asmlist)
else
inherited concatstabto(asmlist);
end;
{$endif GDB} {$endif GDB}
@ -2584,9 +2410,11 @@ implementation
end; end;
{$ifdef GDB} {$ifdef GDB}
procedure tsyssym.concatstabto(asmlist : taasmoutput); function Tsyssym.stabstring:Pchar;
begin
end; begin
stabstring:=nil
end;
{$endif GDB} {$endif GDB}
@ -2719,7 +2547,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.144 2004-01-25 11:33:48 daniel Revision 1.145 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.144 2004/01/25 11:33:48 daniel
* 2nd round of gdb cleanup * 2nd round of gdb cleanup
Revision 1.143 2004/01/16 18:08:39 daniel Revision 1.143 2004/01/16 18:08:39 daniel

45
compiler/symtable.pas
View File

@ -33,7 +33,7 @@ interface
{ symtable } { symtable }
symconst,symbase,symtype,symdef,symsym, symconst,symbase,symtype,symdef,symsym,
{ ppu } { ppu }
ppu,symppu, ppu,
{ assembler } { assembler }
aasmtai aasmtai
; ;
@ -399,18 +399,18 @@ implementation
procedure tstoredsymtable.writesyms(ppufile:tcompilerppufile); procedure tstoredsymtable.writesyms(ppufile:tcompilerppufile);
var var
pd : tstoredsym; pd : Tsym;
begin begin
{ each definition get a number, write then the amount of syms and the { each definition get a number, write then the amount of syms and the
datasize to the ibsymdef entry } datasize to the ibsymdef entry }
ppufile.putlongint(symindex.count); ppufile.putlongint(symindex.count);
ppufile.writeentry(ibstartsyms); ppufile.writeentry(ibstartsyms);
{ foreach is used to write all symbols } { foreach is used to write all symbols }
pd:=tstoredsym(symindex.first); pd:=Tsym(symindex.first);
while assigned(pd) do while assigned(pd) do
begin begin
pd.ppuwrite(ppufile); pd.ppuwrite(ppufile);
pd:=tstoredsym(pd.indexnext); pd:=Tsym(pd.indexnext);
end; end;
{ end of symbols } { end of symbols }
ppufile.writeentry(ibendsyms); ppufile.writeentry(ibendsyms);
@ -421,7 +421,7 @@ implementation
var var
b : byte; b : byte;
d : tderef; d : tderef;
sym : tstoredsym; sym : Tsym;
prdef : tstoreddef; prdef : tstoreddef;
begin begin
b:=ppufile.readentry; b:=ppufile.readentry;
@ -433,7 +433,7 @@ implementation
ibsymref : ibsymref :
begin begin
ppufile.getderef(d); ppufile.getderef(d);
sym:=tstoredsym(d.resolve); sym:=Tsym(d.resolve);
if assigned(sym) then if assigned(sym) then
sym.load_references(ppufile,locals); sym.load_references(ppufile,locals);
end; end;
@ -459,15 +459,15 @@ implementation
procedure tstoredsymtable.write_references(ppufile:tcompilerppufile;locals:boolean); procedure tstoredsymtable.write_references(ppufile:tcompilerppufile;locals:boolean);
var var
pd : tstoredsym; pd : Tsym;
begin begin
ppufile.writeentry(ibbeginsymtablebrowser); ppufile.writeentry(ibbeginsymtablebrowser);
{ write all symbols } { write all symbols }
pd:=tstoredsym(symindex.first); pd:=Tsym(symindex.first);
while assigned(pd) do while assigned(pd) do
begin begin
pd.write_references(ppufile,locals); pd.write_references(ppufile,locals);
pd:=tstoredsym(pd.indexnext); pd:=Tsym(pd.indexnext);
end; end;
ppufile.writeentry(ibendsymtablebrowser); ppufile.writeentry(ibendsymtablebrowser);
end; end;
@ -610,10 +610,10 @@ implementation
function tstoredsymtable.speedsearch(const s : stringid;speedvalue : cardinal) : tsymentry; function tstoredsymtable.speedsearch(const s : stringid;speedvalue : cardinal) : tsymentry;
var var
hp : tstoredsym; hp : Tsym;
newref : tref; newref : tref;
begin begin
hp:=tstoredsym(inherited speedsearch(s,speedvalue)); hp:=Tsym(inherited speedsearch(s,speedvalue));
if assigned(hp) then if assigned(hp) then
begin begin
{ reject non static members in static procedures } { reject non static members in static procedures }
@ -636,8 +636,7 @@ implementation
as TCHILDCLASS.Create did not generate appropriate as TCHILDCLASS.Create did not generate appropriate
stabs debug info if TCHILDCLASS wasn't used anywhere else PM } stabs debug info if TCHILDCLASS wasn't used anywhere else PM }
if (cs_debuginfo in aktmoduleswitches) and if (cs_debuginfo in aktmoduleswitches) and
(hp.typ=typesym) and (hp.typ=typesym) and make_ref then
make_ref then
begin begin
if assigned(ttypesym(hp).restype.def) then if assigned(ttypesym(hp).restype.def) then
tstoreddef(ttypesym(hp).restype.def).numberstring tstoreddef(ttypesym(hp).restype.def).numberstring
@ -765,12 +764,12 @@ implementation
(copy(p.name,1,3)='def') then (copy(p.name,1,3)='def') then
exit; exit;
{ do not claim for inherited private fields !! } { do not claim for inherited private fields !! }
if (tstoredsym(p).refs=0) and (tsym(p).owner.symtabletype=objectsymtable) then if (Tsym(p).refs=0) and (tsym(p).owner.symtabletype=objectsymtable) then
MessagePos2(tsym(p).fileinfo,sym_n_private_method_not_used,tsym(p).owner.realname^,tsym(p).realname) MessagePos2(tsym(p).fileinfo,sym_n_private_method_not_used,tsym(p).owner.realname^,tsym(p).realname)
{ units references are problematic } { units references are problematic }
else else
begin begin
if (tstoredsym(p).refs=0) and if (Tsym(p).refs=0) and
not(tsym(p).typ in [enumsym,unitsym]) and not(tsym(p).typ in [enumsym,unitsym]) and
not(is_funcret_sym(tsym(p))) and not(is_funcret_sym(tsym(p))) and
( (
@ -1174,7 +1173,7 @@ implementation
{ but private ids can be reused } { but private ids can be reused }
hsym:=search_class_member(tobjectdef(defowner),sym.name); hsym:=search_class_member(tobjectdef(defowner),sym.name);
if assigned(hsym) and if assigned(hsym) and
tstoredsym(hsym).is_visible_for_object(tobjectdef(defowner)) then Tsym(hsym).is_visible_for_object(tobjectdef(defowner)) then
begin begin
DuplicateSym(hsym); DuplicateSym(hsym);
exit; exit;
@ -1313,7 +1312,7 @@ implementation
hsym:=search_class_member(tobjectdef(next.defowner),sym.name); hsym:=search_class_member(tobjectdef(next.defowner),sym.name);
{ private ids can be reused } { private ids can be reused }
if assigned(hsym) and if assigned(hsym) and
tstoredsym(hsym).is_visible_for_object(tobjectdef(next.defowner)) then Tsym(hsym).is_visible_for_object(tobjectdef(next.defowner)) then
begin begin
{ delphi allows to reuse the names in a class, but not { delphi allows to reuse the names in a class, but not
in object (tp7 compatible) } in object (tp7 compatible) }
@ -1801,7 +1800,7 @@ implementation
srsym:=tsym(srsymtable.speedsearch(s,speedvalue)); srsym:=tsym(srsymtable.speedsearch(s,speedvalue));
if assigned(srsym) and if assigned(srsym) and
(not assigned(current_procinfo) or (not assigned(current_procinfo) or
tstoredsym(srsym).is_visible_for_object(current_procinfo.procdef._class)) then Tsym(srsym).is_visible_for_object(current_procinfo.procdef._class)) then
begin begin
searchsym:=true; searchsym:=true;
exit; exit;
@ -1832,7 +1831,7 @@ implementation
srsym:=tsym(srsymtable.speedsearch(s,speedvalue)); srsym:=tsym(srsymtable.speedsearch(s,speedvalue));
if assigned(srsym) and if assigned(srsym) and
(not assigned(current_procinfo) or (not assigned(current_procinfo) or
tstoredsym(srsym).is_visible_for_object(current_procinfo.procdef._class)) then Tsym(srsym).is_visible_for_object(current_procinfo.procdef._class)) then
begin begin
result:=true; result:=true;
exit; exit;
@ -1899,7 +1898,7 @@ implementation
begin begin
sym:=tsym(classh.symtable.speedsearch(s,speedvalue)); sym:=tsym(classh.symtable.speedsearch(s,speedvalue));
if assigned(sym) and if assigned(sym) and
tstoredsym(sym).is_visible_for_object(topclassh) then Tsym(sym).is_visible_for_object(topclassh) then
break; break;
classh:=classh.childof; classh:=classh.childof;
end; end;
@ -2298,7 +2297,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.125 2004-01-15 15:16:18 daniel Revision 1.126 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.125 2004/01/15 15:16:18 daniel
* Some minor stuff * Some minor stuff
* Managed to eliminate speed effects of string compression * Managed to eliminate speed effects of string compression

591
compiler/symtype.pas
View File

@ -36,7 +36,7 @@ interface
{ symtable } { symtable }
symconst,symbase, symconst,symbase,
{ aasm } { aasm }
aasmbase aasmbase,ppu,cpuinfo
; ;
type type
@ -45,6 +45,8 @@ interface
************************************************} ************************************************}
tsym = class; tsym = class;
Tcompilerppufile=class;
{************************************************ {************************************************
TRef TRef
@ -92,17 +94,39 @@ interface
{ this object is the base for all symbol objects } { this object is the base for all symbol objects }
tsym = class(tsymentry) tsym = class(tsymentry)
protected
{$ifdef GDB}
{ isstabwritten : boolean;}
{$endif GDB}
public
_realname : pstring; _realname : pstring;
fileinfo : tfileposinfo; fileinfo : tfileposinfo;
symoptions : tsymoptions; symoptions : tsymoptions;
refs : longint;
lastref,
defref,
lastwritten : tref;
refcount : longint;
{$ifdef GDB}
{ function get_var_value(const s:string):string;
function stabstr_evaluate(const s:string;vars:array of string):Pchar;
function stabstring : pchar;virtual;
procedure concatstabto(asmlist : taasmoutput);virtual;}
{$endif GDB}
constructor create(const n : string); constructor create(const n : string);
constructor loadsym(ppufile:tcompilerppufile);
destructor destroy;override; destructor destroy;override;
procedure ppuwrite(ppufile:tcompilerppufile);virtual;abstract;
procedure writesym(ppufile:tcompilerppufile);
function realname:string; function realname:string;
procedure buildderef;virtual;abstract; procedure buildderef;virtual;abstract;
procedure buildderefimpl;virtual;abstract; procedure buildderefimpl;virtual;abstract;
procedure deref;virtual;abstract; procedure deref;virtual;abstract;
procedure derefimpl;virtual;abstract; procedure derefimpl;virtual;abstract;
function gettypedef:tdef;virtual; function gettypedef:tdef;virtual;
procedure load_references(ppufile:tcompilerppufile;locals:boolean);virtual;
function write_references(ppufile:tcompilerppufile;locals:boolean):boolean;virtual;
function is_visible_for_object(currobjdef:Tdef):boolean;
end; end;
{************************************************ {************************************************
@ -163,6 +187,29 @@ interface
procedure buildderef; procedure buildderef;
end; end;
{************************************************
Tcompilerppufile
************************************************}
tcompilerppufile=class(tppufile)
public
procedure checkerror;
procedure getguid(var g: tguid);
function getexprint:tconstexprint;
function getptruint:TConstPtrUInt;
procedure getposinfo(var p:tfileposinfo);
procedure getderef(var d:tderef);
function getsymlist:tsymlist;
procedure gettype(var t:ttype);
function getasmsymbol:tasmsymbol;
procedure putguid(const g: tguid);
procedure putexprint(v:tconstexprint);
procedure PutPtrUInt(v:TConstPtrUInt);
procedure putposinfo(const p:tfileposinfo);
procedure putderef(const d:tderef);
procedure putsymlist(p:tsymlist);
procedure puttype(const t:ttype);
procedure putasmsymbol(s:tasmsymbol);
end;
{$ifdef MEMDEBUG} {$ifdef MEMDEBUG}
var var
@ -180,7 +227,8 @@ implementation
uses uses
verbose, verbose,
fmodule; fmodule,
symdef;
{**************************************************************************** {****************************************************************************
Tdef Tdef
@ -248,8 +296,40 @@ implementation
_realname:=stringdup(n); _realname:=stringdup(n);
typ:=abstractsym; typ:=abstractsym;
symoptions:=[]; symoptions:=[];
defref:=nil;
refs:=0;
lastwritten:=nil;
refcount:=0;
if (cs_browser in aktmoduleswitches) and make_ref then
begin
defref:=tref.create(defref,@akttokenpos);
inc(refcount);
end;
end; end;
constructor tsym.loadsym(ppufile:tcompilerppufile);
var
s : string;
nr : word;
begin
nr:=ppufile.getword;
s:=ppufile.getstring;
if s[1]='$' then
inherited createname(copy(s,2,255))
else
inherited createname(upper(s));
_realname:=stringdup(s);
typ:=abstractsym;
{ force the correct indexnr. must be after create! }
indexnr:=nr;
ppufile.getposinfo(fileinfo);
ppufile.getsmallset(symoptions);
lastref:=nil;
defref:=nil;
refs:=0;
lastwritten:=nil;
refcount:=0;
end;
destructor tsym.destroy; destructor tsym.destroy;
begin begin
@ -263,6 +343,68 @@ implementation
inherited destroy; inherited destroy;
end; end;
procedure Tsym.writesym(ppufile:tcompilerppufile);
begin
ppufile.putword(indexnr);
ppufile.putstring(_realname^);
ppufile.putposinfo(fileinfo);
ppufile.putsmallset(symoptions);
end;
{$ifdef xGDB}
function Tsym.get_var_value(const s:string):string;
begin
if s='name' then
get_var_value:=name
else if s='ownername' then
get_var_value:=owner.name^
else if s='mangledname' then
get_var_value:=mangledname
else if s='line' then
get_var_value:=tostr(fileinfo.line)
else if s='N_LSYM' then
get_var_value:=tostr(N_LSYM)
else if s='N_LCSYM' then
get_var_value:=tostr(N_LCSYM)
else if s='N_RSYM' then
get_var_value:=tostr(N_RSYM)
else if s='N_TSYM' then
get_var_value:=tostr(N_TSYM)
else if s='N_STSYM' then
get_var_value:=tostr(N_STSYM)
else if s='N_FUNCTION' then
get_var_value:=tostr(N_FUNCTION)
else
internalerror(200401152);
end;
function Tsym.stabstr_evaluate(const s:string;vars:array of string):Pchar;
begin
stabstr_evaluate:=string_evaluate(s,@get_var_value,vars);
end;
function Tsym.stabstring : pchar;
begin
stabstring:=stabstr_evaluate('"${name}",${N_LSYM},0,${line},0',[]);
end;
procedure Tsym.concatstabto(asmlist : taasmoutput);
var
stab_str : pchar;
begin
if not isstabwritten then
begin
stab_str := stabstring;
if assigned(stab_str) then
asmList.concat(Tai_stabs.Create(stab_str));
isstabwritten:=true;
end;
end;
{$endif xGDB}
function tsym.realname : string; function tsym.realname : string;
begin begin
@ -279,6 +421,107 @@ implementation
end; end;
procedure Tsym.load_references(ppufile:tcompilerppufile;locals:boolean);
var
pos : tfileposinfo;
move_last : boolean;
begin
move_last:=lastwritten=lastref;
while (not ppufile.endofentry) do
begin
ppufile.getposinfo(pos);
inc(refcount);
lastref:=tref.create(lastref,@pos);
lastref.is_written:=true;
if refcount=1 then
defref:=lastref;
end;
if move_last then
lastwritten:=lastref;
end;
{ big problem here :
wrong refs were written because of
interface parsing of other units PM
moduleindex must be checked !! }
function Tsym.write_references(ppufile:tcompilerppufile;locals:boolean):boolean;
var
d : tderef;
ref : tref;
symref_written,move_last : boolean;
begin
write_references:=false;
if lastwritten=lastref then
exit;
{ should we update lastref }
move_last:=true;
symref_written:=false;
{ write symbol refs }
d.reset;
if assigned(lastwritten) then
ref:=lastwritten
else
ref:=defref;
while assigned(ref) do
begin
if ref.moduleindex=current_module.unit_index then
begin
{ write address to this symbol }
if not symref_written then
begin
d.build(self);
ppufile.putderef(d);
symref_written:=true;
end;
ppufile.putposinfo(ref.posinfo);
ref.is_written:=true;
if move_last then
lastwritten:=ref;
end
else if not ref.is_written then
move_last:=false
else if move_last then
lastwritten:=ref;
ref:=ref.nextref;
end;
if symref_written then
ppufile.writeentry(ibsymref);
write_references:=symref_written;
end;
function Tsym.is_visible_for_object(currobjdef:Tdef):boolean;
begin
is_visible_for_object:=false;
{ private symbols are allowed when we are in the same
module as they are defined }
if (sp_private in symoptions) and
assigned(owner.defowner) and
(owner.defowner.owner.symtabletype in [globalsymtable,staticsymtable]) and
(owner.defowner.owner.unitid<>0) then
exit;
{ protected symbols are vissible in the module that defines them and
also visible to related objects }
if (sp_protected in symoptions) and
(
(
assigned(owner.defowner) and
(owner.defowner.owner.symtabletype in [globalsymtable,staticsymtable]) and
(owner.defowner.owner.unitid<>0)
) and
not(
assigned(currobjdef) and
Tobjectdef(currobjdef).is_related(tobjectdef(owner.defowner))
)
) then
exit;
is_visible_for_object:=true;
end;
{**************************************************************************** {****************************************************************************
TRef TRef
****************************************************************************} ****************************************************************************}
@ -912,6 +1155,340 @@ implementation
end; end;
end; end;
{*****************************************************************************
TCompilerPPUFile
*****************************************************************************}
procedure tcompilerppufile.checkerror;
begin
if error then
Message(unit_f_ppu_read_error);
end;
procedure tcompilerppufile.getguid(var g: tguid);
begin
getdata(g,sizeof(g));
end;
function tcompilerppufile.getexprint:tconstexprint;
var
l1,l2 : longint;
begin
if sizeof(tconstexprint)=8 then
begin
l1:=getlongint;
l2:=getlongint;
{$ifopt R+}
{$define Range_check_on}
{$endif opt R+}
{$R- needed here }
{$ifdef Delphi}
result:=int64(l1)+(int64(l2) shl 32);
{$else}
result:=qword(l1)+(int64(l2) shl 32);
{$endif}
{$ifdef Range_check_on}
{$R+}
{$undef Range_check_on}
{$endif Range_check_on}
end
else
result:=tconstexprint(getlongint);
end;
function tcompilerppufile.getPtrUInt:TConstPtrUInt;
var
l1,l2 : longint;
begin
if sizeof(TConstPtrUInt)=8 then
begin
l1:=getlongint;
l2:=getlongint;
{$ifopt R+}
{$define Range_check_on}
{$endif opt R+}
{$R- needed here }
{$ifdef Delphi}
result:=int64(l1)+(int64(l2) shl 32);
{$else}
result:=qword(l1)+(int64(l2) shl 32);
{$endif}
{$ifdef Range_check_on}
{$R+}
{$undef Range_check_on}
{$endif Range_check_on}
end
else
result:=TConstPtrUInt(getlongint);
end;
procedure tcompilerppufile.getposinfo(var p:tfileposinfo);
var
info : byte;
begin
{
info byte layout in bits:
0-1 - amount of bytes for fileindex
2-3 - amount of bytes for line
4-5 - amount of bytes for column
}
info:=getbyte;
case (info and $03) of
0 : p.fileindex:=getbyte;
1 : p.fileindex:=getword;
2 : p.fileindex:=(getbyte shl 16) or getword;
3 : p.fileindex:=getlongint;
end;
case ((info shr 2) and $03) of
0 : p.line:=getbyte;
1 : p.line:=getword;
2 : p.line:=(getbyte shl 16) or getword;
3 : p.line:=getlongint;
end;
case ((info shr 4) and $03) of
0 : p.column:=getbyte;
1 : p.column:=getword;
2 : p.column:=(getbyte shl 16) or getword;
3 : p.column:=getlongint;
end;
end;
procedure tcompilerppufile.getderef(var d:tderef);
begin
d.dataidx:=getlongint;
end;
function tcompilerppufile.getsymlist:tsymlist;
var
symderef : tderef;
tt : ttype;
slt : tsltype;
idx : longint;
p : tsymlist;
begin
p:=tsymlist.create;
getderef(p.procdefderef);
repeat
slt:=tsltype(getbyte);
case slt of
sl_none :
break;
sl_call,
sl_load,
sl_subscript :
begin
getderef(symderef);
p.addsymderef(slt,symderef);
end;
sl_typeconv :
begin
gettype(tt);
p.addtype(slt,tt);
end;
sl_vec :
begin
idx:=getlongint;
p.addconst(slt,idx);
end;
else
internalerror(200110204);
end;
until false;
getsymlist:=tsymlist(p);
end;
procedure tcompilerppufile.gettype(var t:ttype);
begin
getderef(t.deref);
t.def:=nil;
t.sym:=nil;
end;
function tcompilerppufile.getasmsymbol:tasmsymbol;
begin
getasmsymbol:=tasmsymbol(pointer(getlongint));
end;
procedure tcompilerppufile.putposinfo(const p:tfileposinfo);
var
oldcrc : boolean;
info : byte;
begin
{ posinfo is not relevant for changes in PPU }
oldcrc:=do_crc;
do_crc:=false;
{
info byte layout in bits:
0-1 - amount of bytes for fileindex
2-3 - amount of bytes for line
4-5 - amount of bytes for column
}
info:=0;
{ calculate info byte }
if (p.fileindex>$ff) then
begin
if (p.fileindex<=$ffff) then
info:=info or $1
else
if (p.fileindex<=$ffffff) then
info:=info or $2
else
info:=info or $3;
end;
if (p.line>$ff) then
begin
if (p.line<=$ffff) then
info:=info or $4
else
if (p.line<=$ffffff) then
info:=info or $8
else
info:=info or $c;
end;
if (p.column>$ff) then
begin
if (p.column<=$ffff) then
info:=info or $10
else
if (p.column<=$ffffff) then
info:=info or $20
else
info:=info or $30;
end;
{ write data }
putbyte(info);
case (info and $03) of
0 : putbyte(p.fileindex);
1 : putword(p.fileindex);
2 : begin
putbyte(p.fileindex shr 16);
putword(p.fileindex and $ffff);
end;
3 : putlongint(p.fileindex);
end;
case ((info shr 2) and $03) of
0 : putbyte(p.line);
1 : putword(p.line);
2 : begin
putbyte(p.line shr 16);
putword(p.line and $ffff);
end;
3 : putlongint(p.line);
end;
case ((info shr 4) and $03) of
0 : putbyte(p.column);
1 : putword(p.column);
2 : begin
putbyte(p.column shr 16);
putword(p.column and $ffff);
end;
3 : putlongint(p.column);
end;
do_crc:=oldcrc;
end;
procedure tcompilerppufile.putguid(const g: tguid);
begin
putdata(g,sizeof(g));
end;
procedure tcompilerppufile.putexprint(v:tconstexprint);
begin
if sizeof(TConstExprInt)=8 then
begin
putlongint(longint(lo(v)));
putlongint(longint(hi(v)));
end
else if sizeof(TConstExprInt)=4 then
putlongint(longint(v))
else
internalerror(2002082601);
end;
procedure tcompilerppufile.PutPtrUInt(v:TConstPtrUInt);
begin
if sizeof(TConstPtrUInt)=8 then
begin
putlongint(longint(lo(v)));
putlongint(longint(hi(v)));
end
else if sizeof(TConstPtrUInt)=4 then
putlongint(longint(v))
else
internalerror(2002082601);
end;
procedure tcompilerppufile.putderef(const d:tderef);
var
oldcrc : boolean;
begin
oldcrc:=do_crc;
do_crc:=false;
putlongint(d.dataidx);
do_crc:=oldcrc;
end;
procedure tcompilerppufile.putsymlist(p:tsymlist);
var
hp : psymlistitem;
begin
putderef(p.procdefderef);
hp:=p.firstsym;
while assigned(hp) do
begin
putbyte(byte(hp^.sltype));
case hp^.sltype of
sl_call,
sl_load,
sl_subscript :
putderef(hp^.symderef);
sl_typeconv :
puttype(hp^.tt);
sl_vec :
putlongint(hp^.value);
else
internalerror(200110205);
end;
hp:=hp^.next;
end;
putbyte(byte(sl_none));
end;
procedure tcompilerppufile.puttype(const t:ttype);
begin
putderef(t.deref);
end;
procedure tcompilerppufile.putasmsymbol(s:tasmsymbol);
begin
if assigned(s) then
begin
if s.ppuidx=-1 then
begin
inc(objectlibrary.asmsymbolppuidx);
s.ppuidx:=objectlibrary.asmsymbolppuidx;
end;
putlongint(s.ppuidx);
end
else
putlongint(0);
end;
{$ifdef MEMDEBUG} {$ifdef MEMDEBUG}
initialization initialization
@ -943,7 +1520,11 @@ finalization
end. end.
{ {
$Log$ $Log$
Revision 1.34 2003-11-10 22:02:52 peter Revision 1.35 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.34 2003/11/10 22:02:52 peter
* cross unit inlining fixed * cross unit inlining fixed
Revision 1.33 2003/10/28 15:36:01 peter Revision 1.33 2003/10/28 15:36:01 peter
@ -1044,3 +1625,7 @@ end.
on demand from tprocdef.mangledname on demand from tprocdef.mangledname
} }
end.

8
compiler/x86/aasmcpu.pas
View File

@ -34,7 +34,7 @@ interface
cclasses,globals,verbose, cclasses,globals,verbose,
cpuinfo,cpubase, cpuinfo,cpubase,
cgbase, cgbase,
symppu,symtype,symsym, symtype,symsym,
aasmbase,aasmtai; aasmbase,aasmtai;
const const
@ -1971,7 +1971,11 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.45 2004-01-15 14:01:32 florian Revision 1.46 2004-01-26 16:12:28 daniel
* reginfo now also only allocated during register allocation
* third round of gdb cleanups: kick out most of concatstabto
Revision 1.45 2004/01/15 14:01:32 florian
+ x86 instruction tables for x86-64 extended + x86 instruction tables for x86-64 extended
Revision 1.44 2004/01/12 16:37:59 peter Revision 1.44 2004/01/12 16:37:59 peter