paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-30 22:33:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

* Just to update repsitory

Browse Source
This commit is contained in:
mazen 2002-10-10 19:57:51 +00:00
parent 674d20ef5e
commit b44010f639
5 changed files with 126 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
compiler/sparc/cgcpu.pas
View File

@ -40,10 +40,9 @@ TYPE
{This method is used to pass a parameter, which is located in a register, to a {This method is used to pass a parameter, which is located in a register, to a
routine. It should give the parameter to the routine, as required by the routine. It should give the parameter to the routine, as required by the
specific processor ABI. It is overriden for each CPU target. specific processor ABI. It is overriden for each CPU target.
Size : is the size of the operand in the register Size : is the size of the operand in the register
r : is the register source of the operand r : is the register source of the operand
nr : is number of that parameter in the routine parameters list starting LocPara : is the location where the parameter will be stored}
from one from left to right}
procedure a_param_reg(list:TAasmOutput;size:tcgsize;r:tregister;const LocPara:TParaLocation);override; procedure a_param_reg(list:TAasmOutput;size:tcgsize;r:tregister;const LocPara:TParaLocation);override;
procedure a_param_const(list:TAasmOutput;size:tcgsize;a:aword;CONST LocPara:TParaLocation);override; procedure a_param_const(list:TAasmOutput;size:tcgsize;a:aword;CONST LocPara:TParaLocation);override;
procedure a_param_ref(list:TAasmOutput;size:tcgsize;CONST r:TReference;CONST LocPara:TParaLocation);override; procedure a_param_ref(list:TAasmOutput;size:tcgsize;CONST r:TReference;CONST LocPara:TParaLocation);override;
@ -117,8 +116,16 @@ procedure tcgSPARC.a_param_reg(list:TAasmOutput;size:tcgsize;r:tregister;CONST L
IF(Size<>OS_32)AND(Size<>OS_S32) IF(Size<>OS_32)AND(Size<>OS_S32)
THEN THEN
InternalError(2002032212); InternalError(2002032212);
List.Concat(taicpu.op_reg(A_LD,S_L,r)); with list,LocPara do
END; case Loc of
LOC_REGISTER:
if r<>Register
then
Concat(taicpu.op_Reg_Reg_Reg(A_OR,S_L,r,R_G0,Register));
else
InternalError(2002101002);
end;
end;
procedure tcgSPARC.a_param_const(list:TAasmOutput;size:tcgsize;a:aword;CONST LocPara:TParaLocation); procedure tcgSPARC.a_param_const(list:TAasmOutput;size:tcgsize;a:aword;CONST LocPara:TParaLocation);
BEGIN BEGIN
IF(Size<>OS_32)AND(Size<>OS_S32) IF(Size<>OS_32)AND(Size<>OS_S32)
@ -131,36 +138,37 @@ procedure tcgSPARC.a_param_ref(list:TAasmOutput;size:tcgsize;const r:TReference;
ref: treference; ref: treference;
tmpreg:TRegister; tmpreg:TRegister;
begin begin
case locpara.loc of with LocPara do
LOC_REGISTER,LOC_CREGISTER: case locpara.loc of
a_load_ref_reg(list,size,r,locpara.register); LOC_REGISTER,LOC_CREGISTER:
LOC_REFERENCE: a_load_ref_reg(list,size,r,Register);
begin LOC_REFERENCE:
begin
{Code conventions need the parameters being allocated in %o6+92. See {Code conventions need the parameters being allocated in %o6+92. See
comment on g_stack_frame} comment on g_stack_frame}
if locpara.sp_fixup<92 if locpara.sp_fixup<92
then then
InternalError(2002081104); InternalError(2002081104);
reference_reset(ref); reference_reset(ref);
ref.base:=locpara.reference.index; ref.base:=locpara.reference.index;
ref.offset:=locpara.reference.offset; ref.offset:=locpara.reference.offset;
tmpreg := get_scratch_reg_int(list); tmpreg := get_scratch_reg_int(list);
a_load_ref_reg(list,size,r,tmpreg); a_load_ref_reg(list,size,r,tmpreg);
a_load_reg_ref(list,size,tmpreg,ref); a_load_reg_ref(list,size,tmpreg,ref);
free_scratch_reg(list,tmpreg); free_scratch_reg(list,tmpreg);
end; end;
LOC_FPUREGISTER,LOC_CFPUREGISTER: LOC_FPUREGISTER,LOC_CFPUREGISTER:
case size of case size of
OS_32: OS_32:
a_loadfpu_ref_reg(list,OS_F32,r,locpara.register); a_loadfpu_ref_reg(list,OS_F32,r,locpara.register);
OS_64: OS_64:
a_loadfpu_ref_reg(list,OS_F64,r,locpara.register); a_loadfpu_ref_reg(list,OS_F64,r,locpara.register);
else else
internalerror(2002072801); internalerror(2002072801);
end; end;
else else
internalerror(2002081103); internalerror(2002081103);
end; end;
end; end;
procedure tcgSPARC.a_paramaddr_ref(list:TAasmOutput;CONST r:TReference;CONST LocPara:TParaLocation); procedure tcgSPARC.a_paramaddr_ref(list:TAasmOutput;CONST r:TReference;CONST LocPara:TParaLocation);
VAR VAR
@ -1256,7 +1264,10 @@ BEGIN
END. END.
{ {
$Log$ $Log$
Revision 1.13 2002-10-10 15:10:39 mazen Revision 1.14 2002-10-10 19:57:51 mazen
* Just to update repsitory
Revision 1.13 2002/10/10 15:10:39 mazen
* Internal error fixed, but usually i386 parameter model used * Internal error fixed, but usually i386 parameter model used
Revision 1.12 2002/10/08 17:17:03 mazen Revision 1.12 2002/10/08 17:17:03 mazen

45
compiler/sparc/cpubase.pas
View File

@ -1,12 +1,5 @@
{*****************************************************************************} {******************************************************************************
{ File : cpubase.pas } $Id$
{ Author : Mazen NEIFER }
{ Project : Free Pascal Compiler (FPC) }
{ Creation date : 2002\04\26 }
{ Licence : GPL }
{ Bug report : mazen.neifer.01@supaero.org }
{*****************************************************************************}
{ $Id$
Copyright (c) 1998-2000 by Florian Klaempfl and Peter Vreman Copyright (c) 1998-2000 by Florian Klaempfl and Peter Vreman
Contains the base types for the Scalable Processor ARChitecture (SPARC) Contains the base types for the Scalable Processor ARChitecture (SPARC)
@ -401,7 +394,6 @@ used, because contains a lot of unnessary fields.}
CONST CONST
general_registers = [R_L0..R_L7]; general_registers = [R_L0..R_L7];
{ legEND: } { legEND: }
{ xxxregs = set of all possibly used registers of that type in the code } { xxxregs = set of all possibly used registers of that type in the code }
{ generator } { generator }
@ -410,19 +402,16 @@ CONST
{ excludes registers which can be only used for parameter } { excludes registers which can be only used for parameter }
{ passing on ABI's that define this) } { passing on ABI's that define this) }
{ c_countusableregsxxx = amount of registers in the usableregsxxx set } { c_countusableregsxxx = amount of registers in the usableregsxxx set }
IntRegs=[R_L0..R_O7];
intregs = [R_G0..R_I7]; usableregsint=general_registers;
usableregsint = general_registers;
c_countusableregsint = 4; c_countusableregsint = 4;
fpuregs=[R_F0..R_F31];
fpuregs = [R_F0..R_F31]; usableregsfpu=[];
usableregsfpu = []; c_countusableregsfpu=0;
c_countusableregsfpu = 0; mmregs=[];
usableregsmm=[];
mmregs = [R_G0..R_G7]; c_countusableregsmm=8;
usableregsmm = [R_G0..R_G7];
c_countusableregsmm = 8;
firstsaveintreg = R_G0; firstsaveintreg = R_G0;
lastsaveintreg = R_I7; lastsaveintreg = R_I7;
firstsavefpureg = R_F0; firstsavefpureg = R_F0;
@ -468,9 +457,10 @@ function othewise it contains a pointer to the returned result}
{There is no accumulator in the SPARC architecture. There are just families of {There is no accumulator in the SPARC architecture. There are just families of
registers. All registers belonging to the same family are identical except in registers. All registers belonging to the same family are identical except in
the "global registers" family where GO is different from the others : G0 gives the "global registers" family where GO is different from the others : G0 gives
always 0 when it is red and thows away any value written to it} always 0 when it is red and thows away any value written to it.Nevertheless,
accumulator = R_L0; scalar routine results are returned onto R_O0.}
accumulatorhigh = R_L7; accumulator = R_O0;
accumulatorhigh = R_O1;
fpu_result_reg =R_F0; fpu_result_reg =R_F0;
mmresultreg =R_G0; mmresultreg =R_G0;
{*****************************************************************************} {*****************************************************************************}
@ -581,7 +571,10 @@ FUNCTION flags_to_cond(CONST f:TResFlags):TAsmCond;
END. END.
{ {
$Log$ $Log$
Revision 1.10 2002-10-02 22:20:28 mazen Revision 1.11 2002-10-10 19:57:51 mazen
* Just to update repsitory
Revision 1.10 2002/10/02 22:20:28 mazen
+ out registers allocator for the first 6 scalar parameters which must be passed into %o0..%o5 + out registers allocator for the first 6 scalar parameters which must be passed into %o0..%o5
Revision 1.9 2002/10/01 21:06:29 mazen Revision 1.9 2002/10/01 21:06:29 mazen

29
compiler/sparc/cpupara.pas
View File

@ -42,22 +42,20 @@ function TSparcParaManager.GetIntParaLoc(nr:longint):TParaLocation;
if nr<1 if nr<1
then then
InternalError(2002100806); InternalError(2002100806);
FillChar(Result,SizeOf(TParaLocation),0); FillChar(GetIntParaLoc,SizeOf(TParaLocation),0);
Dec(nr); Dec(nr);
with Result do with GetIntParaLoc do
if nr<6 if nr<6
then{The six first parameters are passed into registers} then{The six first parameters are passed into registers}
begin begin
loc:=LOC_REGISTER; loc:=LOC_REGISTER;
register:=TRegister(LongInt(R_O0)+nr); register:=TRegister(LongInt(R_i0)+nr);
WriteLn('-------------------------------------------');
end end
else{The other parameters are passed into the frame} else{The other parameters are passed into the frame}
begin begin
loc:=LOC_REFERENCE; loc:=LOC_REFERENCE;
reference.index:=frame_pointer_reg; reference.index:=frame_pointer_reg;
reference.offset:=-92-(nr-6)*4; reference.offset:=-68-nr*4;
WriteLn('+++++++++++++++++++++++++++++++++++++++++++');
end; end;
end; end;
function GetParaLoc(p:TDef):TLoc; function GetParaLoc(p:TDef):TLoc;
@ -124,7 +122,7 @@ procedure TSparcParaManager.create_param_loc_info(p:tabstractprocdef);
loc : tloc; loc : tloc;
is_64bit: boolean; is_64bit: boolean;
begin begin
nextintreg:=R_O0; nextintreg:=R_i0;
nextfloatreg:=R_F0; nextfloatreg:=R_F0;
stack_offset:=92; stack_offset:=92;
WriteLn('***********************************************'); WriteLn('***********************************************');
@ -140,7 +138,7 @@ WriteLn('***********************************************');
then then
hp.paraloc.size:=OS_ADDR; hp.paraloc.size:=OS_ADDR;
is_64bit:=hp.paraloc.size in [OS_64,OS_S64]; is_64bit:=hp.paraloc.size in [OS_64,OS_S64];
if NextIntReg<=TRegister(ord(R_O5)-ord(is_64bit)) if NextIntReg<=TRegister(ord(R_i5)-ord(is_64bit))
then then
begin begin
WriteLn('Allocating ',std_reg2str[NextIntReg]); WriteLn('Allocating ',std_reg2str[NextIntReg]);
@ -156,7 +154,7 @@ WriteLn('***********************************************');
end end
else else
begin begin
nextintreg:=R_O6; nextintreg:=R_i6;
hp.paraloc.loc:=LOC_REFERENCE; hp.paraloc.loc:=LOC_REFERENCE;
hp.paraloc.reference.index:=stack_pointer_reg; hp.paraloc.reference.index:=stack_pointer_reg;
hp.paraloc.reference.offset:=stack_offset; hp.paraloc.reference.offset:=stack_offset;
@ -239,11 +237,11 @@ function tSparcParaManager.GetFuncRetParaLoc(p:TAbstractProcDef):TParaLocation;
begin begin
WriteLn('Allocating i0 as return register'); WriteLn('Allocating i0 as return register');
GetFuncRetParaLoc.loc:=LOC_REGISTER; GetFuncRetParaLoc.loc:=LOC_REGISTER;
GetFuncRetParaLoc.register:=R_i0; GetFuncRetParaLoc.register:=R_I0;
GetFuncRetParaLoc.size:=def_cgsize(p.rettype.def); GetFuncRetParaLoc.size:=def_cgsize(p.rettype.def);
if GetFuncRetParaLoc.size in [OS_S64,OS_64] if GetFuncRetParaLoc.size in [OS_S64,OS_64]
then then
GetFuncRetParaLoc.RegisterHigh:=R_O1; GetFuncRetParaLoc.RegisterHigh:=R_I1;
end; end;
floatdef: floatdef:
begin begin
@ -251,8 +249,6 @@ function tSparcParaManager.GetFuncRetParaLoc(p:TAbstractProcDef):TParaLocation;
GetFuncRetParaLoc.register:=R_F1; GetFuncRetParaLoc.register:=R_F1;
GetFuncRetParaLoc.size:=def_cgsize(p.rettype.def); GetFuncRetParaLoc.size:=def_cgsize(p.rettype.def);
end; end;
{ smallsets are OS_INT in R3, others are OS_ADDR in R3 -> the same }
{ ugly, I know :) (JM) }
setdef, setdef,
variantdef, variantdef,
pointerdef, pointerdef,
@ -267,7 +263,7 @@ function tSparcParaManager.GetFuncRetParaLoc(p:TAbstractProcDef):TParaLocation;
errordef: errordef:
begin begin
GetFuncRetParaLoc.loc:=LOC_REGISTER; GetFuncRetParaLoc.loc:=LOC_REGISTER;
GetFuncRetParaLoc.register:=R_O0; GetFuncRetParaLoc.register:=R_I0;
GetFuncRetParaLoc.size:=OS_ADDR; GetFuncRetParaLoc.size:=OS_ADDR;
end; end;
else else
@ -279,7 +275,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.6 2002-10-10 15:10:39 mazen Revision 1.7 2002-10-10 19:57:51 mazen
* Just to update repsitory
Revision 1.6 2002/10/10 15:10:39 mazen
* Internal error fixed, but usually i386 parameter model used * Internal error fixed, but usually i386 parameter model used
Revision 1.5 2002/10/09 13:52:19 mazen Revision 1.5 2002/10/09 13:52:19 mazen

91
compiler/sparc/ncpucall.pas
View File

@ -1,20 +1,11 @@
{*****************************************************************************} {******************************************************************************
{ File : ncpucall.pas }
{ Author : Mazen NEIFER }
{ Project : Free Pascal Compiler (FPC) }
{ Creation date : 2002\26\26 }
{ Last modification date : 2002\07\01 }
{ Licence : GPL }
{ Bug report : mazen.neifer.01@supaero.org }
{*****************************************************************************}
{
$Id$ $Id$
Copyright (c) 1998-2002 by Florian Klaempfl Copyright (c) 1998-2002 by Florian Klaempfl
Generate SPARC assembler for in call nodes Generate SPARC assembler for in call nodes
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published bymethodpointer it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
@ -34,60 +25,60 @@ interface
uses uses
symdef,node,ncal,ncgcal; symdef,node,ncal,ncgcal;
type type
TSparccallnode = class(tcgcallnode) TSparcCallNode=class(TCgCallNode)
function pass_1 : tnode;override; function pass_1:TNode;override;
{Under SPARC, the frame pointer is automatically set by the SAVE instruction {Under SPARC, the frame pointer is automatically set by the SAVE instruction
which is part of the stardrad calling mechanism. This function will do nothing which is part of the stardrad calling mechanism. This function will do nothing.
else than adding the function prologue, which is in some case loading the the frame pointer register is the stack pointer register of the caller, and is
correct value into the frame pointer register!} set when generating function prologue in cgcpu.tcgSPARC.g_stackframe_entry}
procedure load_framepointer;override; procedure load_framepointer;override;
end; end;
implementation implementation
uses
uses globtype,systems,
globtype,systems, cutils,verbose,globals,
cutils,verbose,globals, symconst,symbase,symsym,symtable,defbase,paramgr,
symconst,symbase,symsym,symtable,defbase,paramgr,
{$ifdef GDB} {$ifdef GDB}
{$ifdef delphi} {$ifdef delphi}
sysutils, sysutils,
{$else} {$else}
strings, strings,
{$endif} {$endif}
gdb, gdb,
{$endif GDB} {$endif GDB}
cginfo,cgbase,pass_2, cginfo,cgbase,pass_2,
cpuinfo,cpubase,aasmbase,aasmtai,aasmcpu, cpuinfo,cpubase,aasmbase,aasmtai,aasmcpu,
nmem,nld,ncnv, nmem,nld,ncnv,
ncgutil,cgobj,tgobj,regvars,rgobj,rgcpu,cg64f32,cgcpu,cpupi; ncgutil,cgobj,tgobj,regvars,rgobj,rgcpu,cg64f32,cgcpu,cpupi;
function TSparcCallNode.pass_1:TNode;
function TSparccallnode.pass_1 : tnode; begin
result:=inherited pass_1;
begin if assigned(result)
result:=inherited pass_1; then
if assigned(result) then exit;
exit; if ProcDefinition is TProcDef
if procdefinition is tprocdef then then
begin begin
if tprocdef(procdefinition).parast.datasize>TSparcprocinfo(procinfo).maxpushedparasize then if TProcDef(procdefinition).parast.datasize>TSparcProcInfo(procinfo).maxpushedparasize
TSparcprocinfo(procinfo).maxpushedparasize:=tprocdef(procdefinition).parast.datasize then
end TSparcProcInfo(procinfo).maxpushedparasize:=TProcdef(procdefinition).parast.datasize
else end
begin else
{!!!!} InternalError(2002101001);
end; end;
end;
procedure TSparcCallNode.load_framepointer; procedure TSparcCallNode.load_framepointer;
begin begin
exprasmList.concat(TAiCpu.Op_reg_const_reg(A_SAVE,S_L,stack_pointer_reg,-tprocdef(procdefinition).parast.datasize,stack_pointer_reg)); InternalError(2002101000);
end; end;
begin begin
ccallnode:=TSparccallnode; ccallnode:=TSparcCallNode;
end. end.
{ {
$Log$ $Log$
Revision 1.3 2002-09-30 19:12:14 mazen Revision 1.4 2002-10-10 19:57:52 mazen
* Just to update repsitory
Revision 1.3 2002/09/30 19:12:14 mazen
* function prologue fixed * function prologue fixed
Revision 1.2 2002/08/30 13:16:23 mazen Revision 1.2 2002/08/30 13:16:23 mazen

8
compiler/sparc/ncpucnv.pas
View File

@ -375,7 +375,8 @@ implementation
@second_class_to_intf, @second_class_to_intf,
@second_char_to_char, @second_char_to_char,
@second_nothing, { normal_2_smallset } @second_nothing, { normal_2_smallset }
@second_nothing { dynarray_2_openarray } @second_nothing, { dynarray_2_openarray }
@second_nothing
); );
type type
tprocedureofobject = procedure of object; tprocedureofobject = procedure of object;
@ -421,7 +422,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.3 2002-09-07 15:25:14 peter Revision 1.4 2002-10-10 19:57:52 mazen
* Just to update repsitory
Revision 1.3 2002/09/07 15:25:14 peter
* old logs removed and tabs fixed * old logs removed and tabs fixed
Revision 1.2 2002/08/30 06:15:27 mazen Revision 1.2 2002/08/30 06:15:27 mazen