From a637fbe596d4e8ec9c538f85475141dd704edf2e Mon Sep 17 00:00:00 2001 From: Jonas Maebe Date: Tue, 19 Aug 2014 20:22:24 +0000 Subject: [PATCH] * moved all g_exception_*() methods to hlcgobj and cleaned them up (no more 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 - --- compiler/cgobj.pas | 49 ------------------------------- compiler/hlcg2ll.pas | 7 ----- compiler/hlcgobj.pas | 44 ++++++++++++++++++++++++++++ compiler/i386/cgcpu.pas | 33 --------------------- compiler/i386/hlcgcpu.pas | 48 +++++++++++++++++++++++++++++-- compiler/i8086/cgcpu.pas | 34 ---------------------- compiler/i8086/hlcgcpu.pas | 45 ++++++++++++++++++++++++++++- compiler/ncgflw.pas | 59 +++++++++++++------------------------- compiler/ncgutil.pas | 18 ++++++------ 9 files changed, 162 insertions(+), 175 deletions(-) diff --git a/compiler/cgobj.pas b/compiler/cgobj.pas index 96a5a008b2..2722dce580 100644 --- a/compiler/cgobj.pas +++ b/compiler/cgobj.pas @@ -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; diff --git a/compiler/hlcg2ll.pas b/compiler/hlcg2ll.pas index ec2d61dd39..f72c3d8b24 100644 --- a/compiler/hlcg2ll.pas +++ b/compiler/hlcg2ll.pas @@ -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); diff --git a/compiler/hlcgobj.pas b/compiler/hlcgobj.pas index c4274ec26d..05965c4c6c 100644 --- a/compiler/hlcgobj.pas +++ b/compiler/hlcgobj.pas @@ -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 diff --git a/compiler/i386/cgcpu.pas b/compiler/i386/cgcpu.pas index 21e715860c..272f8427b4 100644 --- a/compiler/i386/cgcpu.pas +++ b/compiler/i386/cgcpu.pas @@ -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; diff --git a/compiler/i386/hlcgcpu.pas b/compiler/i386/hlcgcpu.pas index fa925ef54d..6d702741e5 100644 --- a/compiler/i386/hlcgcpu.pas +++ b/compiler/i386/hlcgcpu.pas @@ -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; diff --git a/compiler/i8086/cgcpu.pas b/compiler/i8086/cgcpu.pas index 8b56d671e2..3c588cf291 100644 --- a/compiler/i8086/cgcpu.pas +++ b/compiler/i8086/cgcpu.pas @@ -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 diff --git a/compiler/i8086/hlcgcpu.pas b/compiler/i8086/hlcgcpu.pas index 06e79d6299..d4d803ed80 100644 --- a/compiler/i8086/hlcgcpu.pas +++ b/compiler/i8086/hlcgcpu.pas @@ -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; diff --git a/compiler/ncgflw.pas b/compiler/ncgflw.pas index c0d73c431c..2ea7e7fe15 100644 --- a/compiler/ncgflw.pas +++ b/compiler/ncgflw.pas @@ -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); diff --git a/compiler/ncgutil.pas b/compiler/ncgutil.pas index e238fd2613..329c656dbf 100644 --- a/compiler/ncgutil.pas +++ b/compiler/ncgutil.pas @@ -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; {*****************************************************************************