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

* moved all g_exception_*() methods to hlcgobj and cleaned them up (no more

Browse Source 
hardcoded registers for the most part)
  + added extra g_exception_discard_reason() that can be called when we only
    want to get rid of the currently pushed exception reason, and don't have
    to load it (so it can do nothing on platforms that don't use push/pop)

git-svn-id: branches/hlcgllvm@28481 -
This commit is contained in:
Jonas Maebe 2014-08-19 20:22:24 +00:00
parent 9d118567cd
commit a637fbe596
9 changed files with 162 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
compiler/cgobj.pas
View File

@ -347,36 +347,6 @@ unit cgobj;
}
procedure optimize_op_const(size: TCGSize; var op: topcg; var a : tcgint);virtual;
{#
This routine is used in exception management nodes. It should
save the exception reason currently in the FUNCTION_RETURN_REG. The
save should be done either to a temp (pointed to by href).
or on the stack (pushing the value on the stack).
The size of the value to save is OS_S32. The default version
saves the exception reason to a temp. memory area.
}
procedure g_exception_reason_save(list : TAsmList; const href : treference);virtual;
{#
This routine is used in exception management nodes. It should
save the exception reason constant. The
save should be done either to a temp (pointed to by href).
or on the stack (pushing the value on the stack).
The size of the value to save is OS_S32. The default version
saves the exception reason to a temp. memory area.
}
procedure g_exception_reason_save_const(list : TAsmList; const href : treference; a: tcgint);virtual;
{#
This routine is used in exception management nodes. It should
load the exception reason to the FUNCTION_RETURN_REG. The saved value
should either be in the temp. area (pointed to by href , href should
*NOT* be freed) or on the stack (the value should be popped).
The size of the value to save is OS_S32. The default version
saves the exception reason to a temp. memory area.
}
procedure g_exception_reason_load(list : TAsmList; const href : treference);virtual;
procedure g_maybe_testvmt(list : TAsmList;reg:tregister;objdef:tobjectdef);
{# This should emit the opcode to copy len bytes from the source
@ -2364,25 +2334,6 @@ implementation
end;
procedure tcg.g_exception_reason_save(list : TAsmList; const href : treference);
begin
a_load_reg_ref(list, OS_INT, OS_INT, NR_FUNCTION_RESULT_REG, href);
end;
procedure tcg.g_exception_reason_save_const(list : TAsmList; const href : treference; a: tcgint);
begin
a_load_const_ref(list, OS_INT, a, href);
end;
procedure tcg.g_exception_reason_load(list : TAsmList; const href : treference);
begin
a_reg_alloc(list,NR_FUNCTION_RESULT_REG);
a_load_ref_reg(list, OS_INT, OS_INT, href, NR_FUNCTION_RESULT_REG);
end;
procedure tcg.g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: tcgint);
var
hsym : tsym;

7
compiler/hlcg2ll.pas
View File

@ -246,8 +246,6 @@ unit hlcg2ll;
procedure g_flags2ref(list: TAsmList; size: tdef; const f: tresflags; const ref:TReference); override;
{$endif cpuflags}
procedure g_exception_reason_save(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const href: treference); override;
// procedure g_maybe_testvmt(list : TAsmList;reg:tregister;objdef:tobjectdef);
{# This should emit the opcode to copy len bytes from the source
to destination.
@ -949,11 +947,6 @@ implementation
cg.g_flags2ref(list,def_cgsize(size),f,ref);
end;
procedure thlcg2ll.g_exception_reason_save(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const href: treference);
begin
cg.g_exception_reason_save(list,href);
end;
{$endif cpuflags}
procedure thlcg2ll.g_concatcopy(list: TAsmList; size: tdef; const source, dest: treference);

44
compiler/hlcgobj.pas
View File

@ -400,6 +400,33 @@ unit hlcgobj;
}
procedure g_exception_reason_save(list : TAsmList; fromsize, tosize: tdef; reg: tregister; const href : treference);virtual;
{#
This routine is used in exception management nodes. It should
save the exception reason constant. The
save should be done either to a temp (pointed to by href).
or on the stack (pushing the value on the stack).
The size of the value to save is OS_S32. The default version
saves the exception reason to a temp. memory area.
}
procedure g_exception_reason_save_const(list: TAsmList; size: tdef; a: tcgint; const href: treference);virtual;
{#
This routine is used in exception management nodes. It should
load the exception reason to reg. The saved value
should either be in the temp. area (pointed to by href , href should
*NOT* be freed) or on the stack (the value should be popped).
The size of the value to save is OS_S32. The default version
saves the exception reason to a temp. memory area.
}
procedure g_exception_reason_load(list : TAsmList; fromsize, tosize: tdef; const href : treference; reg: tregister);virtual;
{#
This routine is called when the current exception reason can be
discarded. On platforms that use push/pop, it causes the current
value to be popped. On other platforms it doesn't do anything
}
procedure g_exception_reason_discard(list : TAsmList; size: tdef; href: treference); virtual;
procedure g_maybe_testself(list : TAsmList; selftype: tdef; reg:tregister);
// procedure g_maybe_testvmt(list : TAsmList;reg:tregister;objdef:tobjectdef);
@ -3037,6 +3064,23 @@ implementation
a_load_reg_ref(list,fromsize,tosize,reg,href);
end;
procedure thlcgobj.g_exception_reason_save_const(list: TAsmList; size: tdef; a: tcgint; const href: treference);
begin
a_load_const_ref(list,size,a,href);
end;
procedure thlcgobj.g_exception_reason_load(list: TAsmList; fromsize, tosize: tdef; const href: treference; reg: tregister);
begin
a_load_ref_reg(list,fromsize,tosize,href,reg);
end;
procedure thlcgobj.g_exception_reason_discard(list: TAsmList; size: tdef; href: treference);
begin
{ do nothing by default }
end;
procedure thlcgobj.g_maybe_testself(list: TAsmList; selftype: tdef; reg: tregister);
var

33
compiler/i386/cgcpu.pas
View File

@ -48,9 +48,6 @@ unit cgcpu;
procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister);
procedure g_releasevaluepara_openarray(list : TAsmList;const l:tlocation);
procedure g_exception_reason_save(list : TAsmList; const href : treference);override;
procedure g_exception_reason_save_const(list : TAsmList; const href : treference; a: tcgint);override;
procedure g_exception_reason_load(list : TAsmList; const href : treference);override;
procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override;
procedure g_maybe_got_init(list: TAsmList); override;
end;
@ -543,36 +540,6 @@ unit cgcpu;
end;
procedure tcg386.g_exception_reason_save(list : TAsmList; const href : treference);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_reg(A_PUSH,tcgsize2opsize[OS_INT],NR_FUNCTION_RESULT_REG))
else
inherited g_exception_reason_save(list,href);
end;
procedure tcg386.g_exception_reason_save_const(list : TAsmList;const href : treference; a: tcgint);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_const(A_PUSH,tcgsize2opsize[OS_INT],a))
else
inherited g_exception_reason_save_const(list,href,a);
end;
procedure tcg386.g_exception_reason_load(list : TAsmList; const href : treference);
begin
if not paramanager.use_fixed_stack then
begin
a_reg_alloc(list,NR_FUNCTION_RESULT_REG);
list.concat(Taicpu.op_reg(A_POP,tcgsize2opsize[OS_INT],NR_FUNCTION_RESULT_REG))
end
else
inherited g_exception_reason_load(list,href);
end;
procedure tcg386.g_maybe_got_init(list: TAsmList);
var
notdarwin: boolean;

48
compiler/i386/hlcgcpu.pas
View File

@ -29,6 +29,7 @@ unit hlcgcpu;
interface
uses
globtype,
aasmdata,
symtype,symdef,parabase,
cgbase,cgutils,
@ -42,6 +43,10 @@ interface
public
procedure g_copyvaluepara_openarray(list: TAsmList; const ref: treference; const lenloc: tlocation; arrdef: tarraydef; destreg: tregister); override;
procedure g_releasevaluepara_openarray(list: TAsmList; arrdef: tarraydef; const l: tlocation); override;
procedure g_exception_reason_save(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const href: treference); override;
procedure g_exception_reason_save_const(list: TAsmList; size: tdef; a: tcgint; const href: treference); override;
procedure g_exception_reason_load(list: TAsmList; fromsize, tosize: tdef; const href: treference; reg: tregister); override;
procedure g_exception_reason_discard(list: TAsmList; size: tdef; href: treference); override;
end;
procedure create_hlcodegen;
@ -49,9 +54,10 @@ interface
implementation
uses
globtype,verbose,
verbose,
paramgr,
cpubase,tgobj,cgobj,cgcpu;
defutil,
cpubase,aasmcpu,tgobj,cgobj,cgx86,cgcpu;
{ thlcgcpu }
@ -192,6 +198,44 @@ implementation
end;
procedure thlcgcpu.g_exception_reason_save(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const href: treference);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_reg(A_PUSH,tcgsize2opsize[def_cgsize(tosize)],reg))
else
inherited
end;
procedure thlcgcpu.g_exception_reason_save_const(list: TAsmList; size: tdef; a: tcgint; const href: treference);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_const(A_PUSH,tcgsize2opsize[def_cgsize(size)],a))
else
inherited;
end;
procedure thlcgcpu.g_exception_reason_load(list: TAsmList; fromsize, tosize: tdef; const href: treference; reg: tregister);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_reg(A_POP,tcgsize2opsize[def_cgsize(tosize)],reg))
else
inherited;
end;
procedure thlcgcpu.g_exception_reason_discard(list: TAsmList; size: tdef; href: treference);
begin
if not paramanager.use_fixed_stack then
begin
getcpuregister(list,NR_FUNCTION_RESULT_REG);
list.concat(Taicpu.op_reg(A_POP,tcgsize2opsize[def_cgsize(size)],NR_FUNCTION_RESULT_REG));
ungetcpuregister(list,NR_FUNCTION_RESULT_REG);
end;
end;
procedure create_hlcodegen;
begin
hlcg:=thlcgcpu.create;

34
compiler/i8086/cgcpu.pas
View File

@ -91,10 +91,6 @@ unit cgcpu;
procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:tcgint;destreg:tregister);
procedure g_releasevaluepara_openarray(list : TAsmList;const l:tlocation);
procedure g_exception_reason_save(list : TAsmList; const href : treference);override;
procedure g_exception_reason_save_const(list : TAsmList; const href : treference; a: tcgint);override;
procedure g_exception_reason_load(list : TAsmList; const href : treference);override;
procedure g_adjust_self_value(list:TAsmList;procdef: tprocdef;ioffset: tcgint);override;
procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override;
@ -1964,36 +1960,6 @@ unit cgcpu;
end;
procedure tcg8086.g_exception_reason_save(list : TAsmList; const href : treference);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_reg(A_PUSH,tcgsize2opsize[OS_INT],NR_FUNCTION_RESULT_REG))
else
inherited g_exception_reason_save(list,href);
end;
procedure tcg8086.g_exception_reason_save_const(list : TAsmList;const href : treference; a: tcgint);
begin
if not paramanager.use_fixed_stack then
push_const(list,OS_INT,a)
else
inherited g_exception_reason_save_const(list,href,a);
end;
procedure tcg8086.g_exception_reason_load(list : TAsmList; const href : treference);
begin
if not paramanager.use_fixed_stack then
begin
cg.a_reg_alloc(list,NR_FUNCTION_RESULT_REG);
list.concat(Taicpu.op_reg(A_POP,tcgsize2opsize[OS_INT],NR_FUNCTION_RESULT_REG))
end
else
inherited g_exception_reason_load(list,href);
end;
procedure tcg8086.get_32bit_ops(op: TOpCG; out op1, op2: TAsmOp);
begin
case op of

45
compiler/i8086/hlcgcpu.pas
View File

@ -77,6 +77,11 @@ interface
procedure g_copyvaluepara_openarray(list: TAsmList; const ref: treference; const lenloc: tlocation; arrdef: tarraydef; destreg: tregister); override;
procedure g_releasevaluepara_openarray(list: TAsmList; arrdef: tarraydef; const l: tlocation); override;
procedure g_exception_reason_save(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const href: treference); override;
procedure g_exception_reason_save_const(list: TAsmList; size: tdef; a: tcgint; const href: treference); override;
procedure g_exception_reason_load(list: TAsmList; fromsize, tosize: tdef; const href: treference; reg: tregister); override;
procedure g_exception_reason_discard(list: TAsmList; size: tdef; href: treference); override;
procedure location_force_mem(list:TAsmList;var l:tlocation;size:tdef);override;
end;
@ -87,7 +92,7 @@ implementation
uses
verbose,
paramgr,
cpubase,cpuinfo,tgobj,cgobj,cgcpu,
cpubase,cpuinfo,tgobj,cgobj,cgx86,cgcpu,
defutil,
symconst,symcpu,
procinfo,fmodule,
@ -393,6 +398,44 @@ implementation
end;
procedure thlcgcpu.g_exception_reason_save(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const href: treference);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_reg(A_PUSH,tcgsize2opsize[def_cgsize(tosize)],reg))
else
inherited
end;
procedure thlcgcpu.g_exception_reason_save_const(list: TAsmList; size: tdef; a: tcgint; const href: treference);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_const(A_PUSH,tcgsize2opsize[def_cgsize(size)],a))
else
inherited;
end;
procedure thlcgcpu.g_exception_reason_load(list: TAsmList; fromsize, tosize: tdef; const href: treference; reg: tregister);
begin
if not paramanager.use_fixed_stack then
list.concat(Taicpu.op_reg(A_POP,tcgsize2opsize[def_cgsize(tosize)],reg))
else
inherited;
end;
procedure thlcgcpu.g_exception_reason_discard(list: TAsmList; size: tdef; href: treference);
begin
if not paramanager.use_fixed_stack then
begin
getcpuregister(list,NR_FUNCTION_RESULT_REG);
list.concat(Taicpu.op_reg(A_POP,tcgsize2opsize[def_cgsize(size)],NR_FUNCTION_RESULT_REG));
ungetcpuregister(list,NR_FUNCTION_RESULT_REG);
end;
end;
procedure thlcgcpu.location_force_mem(list: TAsmList; var l: tlocation; size: tdef);
var
r,tmpref: treference;

59
compiler/ncgflw.pas
View File

@ -1160,11 +1160,9 @@ implementation
{ we must also destroy the address frame which guards }
{ exception object }
cg.g_call(current_asmdata.CurrAsmList,'FPC_POPADDRSTACK');
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
cleanupobjectstack;
cg.a_jmp_always(current_asmdata.CurrAsmList,oldCurrExitLabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
if fc_break in exceptflowcontrol then
@ -1173,11 +1171,9 @@ implementation
{ we must also destroy the address frame which guards }
{ exception object }
cg.g_call(current_asmdata.CurrAsmList,'FPC_POPADDRSTACK');
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
cleanupobjectstack;
cg.a_jmp_always(current_asmdata.CurrAsmList,oldBreakLabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
if fc_continue in exceptflowcontrol then
@ -1186,11 +1182,9 @@ implementation
{ we must also destroy the address frame which guards }
{ exception object }
cg.g_call(current_asmdata.CurrAsmList,'FPC_POPADDRSTACK');
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
cleanupobjectstack;
cg.a_jmp_always(current_asmdata.CurrAsmList,oldContinueLabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
if fc_exit in tryflowcontrol then
@ -1198,30 +1192,24 @@ implementation
{ do some magic for exit in the try block }
cg.a_label(current_asmdata.CurrAsmList,exittrylabel);
cg.g_call(current_asmdata.CurrAsmList,'FPC_POPADDRSTACK');
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
cg.a_jmp_always(current_asmdata.CurrAsmList,oldCurrExitLabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
if fc_break in tryflowcontrol then
begin
cg.a_label(current_asmdata.CurrAsmList,breaktrylabel);
cg.g_call(current_asmdata.CurrAsmList,'FPC_POPADDRSTACK');
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
cg.a_jmp_always(current_asmdata.CurrAsmList,oldBreakLabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
if fc_continue in tryflowcontrol then
begin
cg.a_label(current_asmdata.CurrAsmList,continuetrylabel);
cg.g_call(current_asmdata.CurrAsmList,'FPC_POPADDRSTACK');
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
cg.a_jmp_always(current_asmdata.CurrAsmList,oldContinueLabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
unget_exception_temps(current_asmdata.CurrAsmList,excepttemps);
cg.a_label(current_asmdata.CurrAsmList,endexceptlabel);
@ -1427,6 +1415,7 @@ implementation
oldBreakLabel : tasmlabel;
oldflowcontrol,tryflowcontrol : tflowcontrol;
excepttemps : texceptiontemps;
reasonreg : tregister;
begin
location_reset(location,LOC_VOID,OS_NO);
tryflowcontrol:=[];
@ -1504,12 +1493,11 @@ implementation
current_asmdata.CurrAsmList.concat(tai_marker.create(mark_NoLineInfoStart));
{ the value should now be in the exception handler }
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
reasonreg:=hlcg.getintregister(current_asmdata.CurrAsmList,osuinttype);
hlcg.g_exception_reason_load(current_asmdata.CurrAsmList,osuinttype,osuinttype,excepttemps.reasonbuf,reasonreg);
if implicitframe then
begin
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,0,NR_FUNCTION_RESULT_REG,endfinallylabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,0,reasonreg,endfinallylabel);
{ finally code only needed to be executed on exception }
flowcontrol:=[fc_inflowcontrol];
secondpass(t1);
@ -1525,42 +1513,35 @@ implementation
end
else
begin
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,0,NR_FUNCTION_RESULT_REG,endfinallylabel);
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,0,reasonreg,endfinallylabel);
if fc_exit in tryflowcontrol then
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,2,NR_FUNCTION_RESULT_REG,oldCurrExitLabel);
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,2,reasonreg,oldCurrExitLabel);
if fc_break in tryflowcontrol then
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,3,NR_FUNCTION_RESULT_REG,oldBreakLabel);
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,3,reasonreg,oldBreakLabel);
if fc_continue in tryflowcontrol then
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,4,NR_FUNCTION_RESULT_REG,oldContinueLabel);
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_INT,OC_EQ,4,reasonreg,oldContinueLabel);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_RERAISE',false);
{ do some magic for exit,break,continue in the try block }
if fc_exit in tryflowcontrol then
begin
cg.a_label(current_asmdata.CurrAsmList,exitfinallylabel);
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
cg.g_exception_reason_save_const(current_asmdata.CurrAsmList,excepttemps.reasonbuf,2);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
hlcg.g_exception_reason_save_const(current_asmdata.CurrAsmList,osuinttype,2,excepttemps.reasonbuf);
cg.a_jmp_always(current_asmdata.CurrAsmList,finallylabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
if fc_break in tryflowcontrol then
begin
cg.a_label(current_asmdata.CurrAsmList,breakfinallylabel);
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
cg.g_exception_reason_save_const(current_asmdata.CurrAsmList,excepttemps.reasonbuf,3);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
hlcg.g_exception_reason_save_const(current_asmdata.CurrAsmList,osuinttype,3,excepttemps.reasonbuf);
cg.a_jmp_always(current_asmdata.CurrAsmList,finallylabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
if fc_continue in tryflowcontrol then
begin
cg.a_label(current_asmdata.CurrAsmList,continuefinallylabel);
cg.g_exception_reason_load(current_asmdata.CurrAsmList,excepttemps.reasonbuf);
cg.g_exception_reason_save_const(current_asmdata.CurrAsmList,excepttemps.reasonbuf,4);
hlcg.g_exception_reason_discard(current_asmdata.CurrAsmList,osuinttype,excepttemps.reasonbuf);
hlcg.g_exception_reason_save_const(current_asmdata.CurrAsmList,osuinttype,4,excepttemps.reasonbuf);
cg.a_jmp_always(current_asmdata.CurrAsmList,finallylabel);
{ from g_exception_reason_load }
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
end;
end;
unget_exception_temps(current_asmdata.CurrAsmList,excepttemps);

18
compiler/ncgutil.pas
View File

@ -468,19 +468,17 @@ implementation
procedure free_exception(list:TAsmList;const t:texceptiontemps;a:aint;endexceptlabel:tasmlabel;onlyfree:boolean);
begin
cg.allocallcpuregisters(list);
cg.a_call_name(list,'FPC_POPADDRSTACK',false);
cg.deallocallcpuregisters(list);
var
reasonreg: tregister;
begin
hlcg.g_call_system_proc(list,'fpc_popaddrstack',[],nil);
if not onlyfree then
begin
{ g_exception_reason_load already allocates NR_FUNCTION_RESULT_REG }
cg.g_exception_reason_load(list, t.reasonbuf);
cg.a_cmp_const_reg_label(list,OS_INT,OC_EQ,a,NR_FUNCTION_RESULT_REG,endexceptlabel);
cg.a_reg_dealloc(list,NR_FUNCTION_RESULT_REG);
reasonreg:=hlcg.getintregister(list,osuinttype);
hlcg.g_exception_reason_load(list,osuinttype,osuinttype,t.reasonbuf,reasonreg);
hlcg.a_cmp_const_reg_label(list,osuinttype,OC_EQ,a,reasonreg,endexceptlabel);
end;
end;
end;
{*****************************************************************************