diff options
Diffstat (limited to 'config/coreboot/fam15h_udimm/patches')
| -rw-r--r-- | config/coreboot/fam15h_udimm/patches/0011-gcc-8.3.0_gnat_eh_new.patch | 232 |
1 files changed, 0 insertions, 232 deletions
diff --git a/config/coreboot/fam15h_udimm/patches/0011-gcc-8.3.0_gnat_eh_new.patch b/config/coreboot/fam15h_udimm/patches/0011-gcc-8.3.0_gnat_eh_new.patch deleted file mode 100644 index 443d8512..00000000 --- a/config/coreboot/fam15h_udimm/patches/0011-gcc-8.3.0_gnat_eh_new.patch +++ /dev/null @@ -1,232 +0,0 @@ -From c5a03de594d6bb6ea5012a6549404e4631c903c8 Mon Sep 17 00:00:00 2001 -From: Alexandre Oliva <oliva@adacore.com> -Date: Wed, 9 Aug 2023 16:57:31 +0200 -Subject: [PATCH] crossgcc: Backport GNAT exception handler v1 patch - -Signed-off-by: Adrien Bourmault <neox@gnu.org> ---- - .../patches/gcc-8.3.0_gnat_eh_new.patch | 212 ++++++++++++++++++ - 1 file changed, 212 insertions(+) - create mode 100644 util/crossgcc/patches/gcc-8.3.0_gnat_eh_new.patch - -diff --git a/util/crossgcc/patches/gcc-8.3.0_gnat_eh_new.patch b/util/crossgcc/patches/gcc-8.3.0_gnat_eh_new.patch -new file mode 100644 -index 00000000..75e4f18d ---- /dev/null -+++ b/util/crossgcc/patches/gcc-8.3.0_gnat_eh_new.patch -@@ -0,0 +1,212 @@ -+diff --git a/gcc/ada/libgnat/a-exexpr.adb b/gcc/ada/libgnat/a-exexpr.adb -+index b1aa1c6e6ba..5e72fd6e3f2 100644 -+--- a/gcc/ada/libgnat/a-exexpr.adb -++++ b/gcc/ada/libgnat/a-exexpr.adb -+@@ -197,15 +197,75 @@ package body Exception_Propagation is -+ -- whose machine occurrence is Mo. The message is empty, the backtrace -+ -- is empty too and the exception identity is Foreign_Exception. -+ -+- -- Hooks called when entering/leaving an exception handler for a given -+- -- occurrence, aimed at handling the stack of active occurrences. The -+- -- calls are generated by gigi in tree_transform/N_Exception_Handler. -++ -- Hooks called when entering/leaving an exception handler for a -++ -- given occurrence. The calls are generated by gigi in -++ -- Exception_Handler_to_gnu_gcc. -++ -++ -- Begin_Handler_v1, called when entering an exception handler, -++ -- claims responsibility for the handler to release the -++ -- GCC_Exception occurrence. End_Handler_v1, called when -++ -- leaving the handler, releases the occurrence, unless the -++ -- occurrence is propagating further up, or the handler is -++ -- dynamically nested in the context of another handler that -++ -- claimed responsibility for releasing that occurrence. -++ -++ -- Responsibility is claimed by changing the Cleanup field to -++ -- Claimed_Cleanup, which enables claimed exceptions to be -++ -- recognized, and avoids accidental releases even by foreign -++ -- handlers. -++ -++ function Begin_Handler_v1 -++ (GCC_Exception : not null GCC_Exception_Access) -++ return System.Address; -++ pragma Export (C, Begin_Handler_v1, "__gnat_begin_handler_v1"); -++ -- Called when entering an exception handler. Claim -++ -- responsibility for releasing GCC_Exception, by setting the -++ -- cleanup/release function to Claimed_Cleanup, and return the -++ -- address of the previous cleanup/release function. -++ -++ procedure End_Handler_v1 -++ (GCC_Exception : not null GCC_Exception_Access; -++ Saved_Cleanup : System.Address; -++ Propagating_Exception : GCC_Exception_Access); -++ pragma Export (C, End_Handler_v1, "__gnat_end_handler_v1"); -++ -- Called when leaving an exception handler. Restore the -++ -- Saved_Cleanup in the GCC_Exception occurrence, and then release -++ -- it, unless it remains claimed by an enclosing handler, or -++ -- GCC_Exception and Propagating_Exception are the same -++ -- occurrence. Propagating_Exception could be either an -++ -- occurrence (re)raised within the handler of GCC_Exception, when -++ -- we're executing as an exceptional cleanup, or null, if we're -++ -- completing the handler of GCC_Exception normally. -++ -++ procedure Claimed_Cleanup -++ (Reason : Unwind_Reason_Code; -++ GCC_Exception : not null GCC_Exception_Access); -++ pragma Export (C, Claimed_Cleanup, "__gnat_claimed_cleanup"); -++ -- A do-nothing placeholder installed as GCC_Exception.Cleanup -++ -- while handling GCC_Exception, to claim responsibility for -++ -- releasing it, and to stop it from being accidentally released. -++ -++ -- The following are version 0 implementations of the version 1 -++ -- hooks above. They remain in place for compatibility with the -++ -- output of compilers that still use version 0, such as those -++ -- used during bootstrap. They are interoperable with the v1 -++ -- hooks, except that the older versions may malfunction when -++ -- handling foreign exceptions passed to Reraise_Occurrence. -+ -+ procedure Begin_Handler (GCC_Exception : not null GCC_Exception_Access); -+ pragma Export (C, Begin_Handler, "__gnat_begin_handler"); -++ -- Called when entering an exception handler translated by an old -++ -- compiler. It does nothing. -+ -+ procedure End_Handler (GCC_Exception : GCC_Exception_Access); -+ pragma Export (C, End_Handler, "__gnat_end_handler"); -++ -- Called when leaving an exception handler translated by an old -++ -- compiler. It releases GCC_Exception, unless it is null. It is -++ -- only ever null when the handler has a 'raise;' translated by a -++ -- v0-using compiler. The artificial handler variable passed to -++ -- End_Handler was set to null to tell End_Handler to refrain from -++ -- releasing the reraised exception. In v1 safer ways are used to -++ -- accomplish that. -+ -+ -------------------------------------------------------------------- -+ -- Accessors to Basic Components of a GNAT Exception Data Pointer -- -+@@ -352,6 +412,128 @@ package body Exception_Propagation is -+ end if; -+ end Setup_Current_Excep; -+ -++ ---------------------- -++ -- Begin_Handler_v1 -- -++ ---------------------- -++ -++ function Begin_Handler_v1 -++ (GCC_Exception : not null GCC_Exception_Access) -++ return System.Address is -++ Saved_Cleanup : constant System.Address := GCC_Exception.Cleanup; -++ begin -++ -- Claim responsibility for releasing this exception, and stop -++ -- others from releasing it. -++ GCC_Exception.Cleanup := Claimed_Cleanup'Address; -++ return Saved_Cleanup; -++ end Begin_Handler_v1; -++ -++ -------------------- -++ -- End_Handler_v1 -- -++ -------------------- -++ -++ procedure End_Handler_v1 -++ (GCC_Exception : not null GCC_Exception_Access; -++ Saved_Cleanup : System.Address; -++ Propagating_Exception : GCC_Exception_Access) is -++ begin -++ GCC_Exception.Cleanup := Saved_Cleanup; -++ -- Restore the Saved_Cleanup, so that it is either used to -++ -- release GCC_Exception below, or transferred to the next -++ -- handler of the Propagating_Exception occurrence. The -++ -- following test ensures that an occurrence is only released -++ -- once, even after reraises. -++ -- -++ -- The idea is that the GCC_Exception is not to be released -++ -- unless it had an unclaimed Cleanup when the handler started -++ -- (see Begin_Handler_v1 above), but if we propagate across its -++ -- handler a reraise of the same exception, we transfer to the -++ -- Propagating_Exception the responsibility for running the -++ -- Saved_Cleanup when its handler completes. -++ -- -++ -- This ownership transfer mechanism ensures safety, as in -++ -- single release and no dangling pointers, because there is no -++ -- way to hold on to the Machine_Occurrence of an -++ -- Exception_Occurrence: the only situations in which another -++ -- Exception_Occurrence gets the same Machine_Occurrence are -++ -- through Reraise_Occurrence, and plain reraise, and so we -++ -- have the following possibilities: -++ -- -++ -- - Reraise_Occurrence is handled within the running handler, -++ -- and so when completing the dynamically nested handler, we -++ -- must NOT release the exception. A Claimed_Cleanup upon -++ -- entry of the nested handler, installed when entering the -++ -- enclosing handler, ensures the exception will not be -++ -- released by the nested handler, but rather by the enclosing -++ -- handler. -++ -- -++ -- - Reraise_Occurrence/reraise escapes the running handler, -++ -- and we run as an exceptional cleanup for GCC_Exception. The -++ -- Saved_Cleanup was reinstalled, but since we're propagating -++ -- the same machine occurrence, we do not release it. Instead, -++ -- we transfer responsibility for releasing it to the eventual -++ -- handler of the propagating exception. -++ -- -++ -- - An unrelated exception propagates through the running -++ -- handler. We restored GCC_Exception.Saved_Cleanup above. -++ -- Since we're propagating a different exception, we proceed to -++ -- release GCC_Exception, unless Saved_Cleanup was -++ -- Claimed_Cleanup, because then we know we're not in the -++ -- outermost handler for GCC_Exception. -++ -- -++ -- - The handler completes normally, so it reinstalls the -++ -- Saved_Cleanup and runs it, unless it was Claimed_Cleanup. -++ -- If Saved_Cleanup is null, Unwind_DeleteException (currently) -++ -- has no effect, so we could skip it, but if it is ever -++ -- changed to do more in this case, we're ready for that, -++ -- calling it exactly once. -++ if Saved_Cleanup /= Claimed_Cleanup'Address -++ and then -++ Propagating_Exception /= GCC_Exception -++ then -++ declare -++ Current : constant EOA := Get_Current_Excep.all; -++ Cur_Occ : constant GCC_Exception_Access -++ := To_GCC_Exception (Current.Machine_Occurrence); -++ begin -++ -- If we are releasing the Machine_Occurrence of the current -++ -- exception, reset the access to it, so that it is no -++ -- longer accessible. -++ if Cur_Occ = GCC_Exception then -++ Current.Machine_Occurrence := System.Null_Address; -++ end if; -++ end; -++ Unwind_DeleteException (GCC_Exception); -++ end if; -++ end End_Handler_v1; -++ -++ --------------------- -++ -- Claimed_Cleanup -- -++ --------------------- -++ -++ procedure Claimed_Cleanup -++ (Reason : Unwind_Reason_Code; -++ GCC_Exception : not null GCC_Exception_Access) is -++ pragma Unreferenced (Reason); -++ pragma Unreferenced (GCC_Exception); -++ begin -++ -- This procedure should never run. If it does, it's either a -++ -- version 0 handler or a foreign handler, attempting to -++ -- release an exception while a version 1 handler that claimed -++ -- responsibility for releasing the exception remains still -++ -- active. This placeholder stops GCC_Exception from being -++ -- released by them. -++ -++ -- We could get away with just Null_Address instead, with -++ -- nearly the same effect, but with this placeholder we can -++ -- detect and report unexpected releases, and we can tell apart -++ -- a GCC_Exception without a Cleanup, from one with another -++ -- active handler, so as to still call Unwind_DeleteException -++ -- exactly once: currently, Unwind_DeleteException does nothing -++ -- when the Cleanup is null, but should it ever be changed to -++ -- do more, we'll still be safe. -++ null; -++ end Claimed_Cleanup; -++ -+ ------------------- -+ -- Begin_Handler -- -+ ------------------- --- -2.30.2 - |