GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

util/crossgcc: Update gcc to 11.2 

Various fixes to gnat and the improved nds32 backend have been merged
into gcc by now, so we don't need to carry those patches anymore.

Change-Id: Icdee2a8beedd109ee1f0eef6f32f7accbf66674b
Signed-off-by: Patrick Georgi <pgeorgi@google.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/54050
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Nico Huber <nico.h@gmx.de>
This commit is contained in:
Patrick Georgi 2021-05-10 23:39:45 +02:00
parent e4cf38ed36
commit b0d87f753c
11 changed files with 25 additions and 21485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
util/crossgcc/buildgcc
View File

@ -35,7 +35,7 @@ THREADS=1
GMP_VERSION=6.2.1
MPFR_VERSION=4.1.0
MPC_VERSION=1.2.1
GCC_VERSION=8.3.0
GCC_VERSION=11.2.0
GCC_AUTOCONF_VERSION=2.69
BINUTILS_VERSION=2.37
GDB_VERSION=9.2

0
util/crossgcc/patches/gcc-8.3.0_ada-musl_workaround.patch → util/crossgcc/patches/gcc-11.2.0_ada-musl_workaround.patch
View File

53
util/crossgcc/patches/gcc-8.3.0_asan_shadow_offset_callback.patch → util/crossgcc/patches/gcc-11.2.0_asan_shadow_offset_callback.patch
View File

@ -28,12 +28,10 @@ patch, it will end up in the following compilation error:
"invalid --param name 'asan-use-shadow-offset-callback'"
So, you cannot accidentally enable the feature without having your compiler patched.
[pgeorgi: Updated for gcc 11.1]
Signed-off-by: Harshit Sharma <harshitsharmajs@gmail.com>
---
gcc/asan.c | 29 ++++++++++++++++++++++-------
gcc/params.def | 6 ++++++
gcc/params.h | 2 ++
3 files changed, 30 insertions(+), 7 deletions(-)
Signed-off-by: Patrick Georgi <pgeorgi@google.com>
diff --git a/gcc/asan.c b/gcc/asan.c
index 235e21947..713bf994d 100644
@ -50,10 +48,10 @@ index 235e21947..713bf994d 100644
- = plus_constant (Pmode, shadow_base,
- asan_shadow_offset ()
- + (base_align_bias >> ASAN_SHADOW_SHIFT));
+ if (ASAN_USE_SHADOW_OFFSET_CALLBACK) {
+ if (param_asan_use_shadow_offset_callback) {
+ rtx addr, shadow_offset_rtx;
+ ret = init_one_libfunc ("__asan_shadow_offset");
+ addr= convert_memory_address (ptr_mode, base);
+ addr = convert_memory_address (ptr_mode, base);
+ ret = emit_library_call_value (ret, NULL_RTX, LCT_NORMAL, ptr_mode,
+ addr, ptr_mode);
+ shadow_offset_rtx = convert_memory_address (Pmode, ret);
@ -75,35 +73,16 @@ index 235e21947..713bf994d 100644
gcc_assert (asan_shadow_set != -1
&& (ASAN_RED_ZONE_SIZE >> ASAN_SHADOW_SHIFT) == 4);
shadow_mem = gen_rtx_MEM (SImode, shadow_base);
diff --git a/gcc/params.def b/gcc/params.def
index dad47ec2b..bfe6eaa0b 100644
--- a/gcc/params.def
+++ b/gcc/params.def
@@ -1203,6 +1203,12 @@ DEFPARAM (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD,
"in function becomes greater or equal to this number.",
7000, 0, INT_MAX)
--- gcc-11.1.0/gcc/params.opt~ 2021-05-11 09:02:51.897508677 +0200
+++ gcc-11.1.0/gcc/params.opt 2021-05-11 09:10:43.692610696 +0200
@@ -50,6 +50,10 @@
Common Joined UInteger Var(param_asan_instrumentation_with_call_threshold) Init(7000) Param Optimization
Use callbacks instead of inline code if number of accesses in function becomes greater or equal to this number.
+DEFPARAM (PARAM_ASAN_USE_SHADOW_OFFSET_CALLBACK,
+ "asan-use-shadow-offset-callback",
+ "Use shadow offset callback function at runtime instead of "
+ "fixed value at compile time at the cost of runtime overhead.",
+ 0, 0, 1)
+-param=asan-use-shadow-offset-callback=
+Common Joined UInteger Var(param_asan_use_shadow_offset_callback) Init(0) IntegerRange(0, 1) Param Optimization
+Use shadow offset callback function at runtime instead of fixed value at compile time at the cost of runtime overhead.
+
DEFPARAM (PARAM_USE_AFTER_SCOPE_DIRECT_EMISSION_THRESHOLD,
"use-after-scope-direct-emission-threshold",
"Use direct poisoning/unpoisoning instructions for variables "
diff --git a/gcc/params.h b/gcc/params.h
index 98249d2a1..d3bd6be38 100644
--- a/gcc/params.h
+++ b/gcc/params.h
@@ -246,6 +246,8 @@ extern void init_param_values (int *params);
PARAM_VALUE (PARAM_ASAN_USE_AFTER_RETURN)
#define ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD \
PARAM_VALUE (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD)
+#define ASAN_USE_SHADOW_OFFSET_CALLBACK \
+ PARAM_VALUE (PARAM_ASAN_USE_SHADOW_OFFSET_CALLBACK)
#define ASAN_PARAM_USE_AFTER_SCOPE_DIRECT_EMISSION_THRESHOLD \
((unsigned) PARAM_VALUE (PARAM_USE_AFTER_SCOPE_DIRECT_EMISSION_THRESHOLD))
--
2.17.1
-param=asan-memintrin=
Common Joined UInteger Var(param_asan_memintrin) Init(1) IntegerRange(0, 1) Param Optimization
Enable asan builtin functions protection.

0
util/crossgcc/patches/gcc-8.3.0_gnat.patch → util/crossgcc/patches/gcc-11.2.0_gnat.patch
View File

14
util/crossgcc/patches/gcc-8.3.0_libcpp.patch → util/crossgcc/patches/gcc-11.2.0_libcpp.patch
View File

@ -4,7 +4,7 @@ by default rejects some codes in libcpp. This patch fixes them.
--- gcc-8.3.0/libcpp/expr.c.bak 2020-09-11 15:44:45.770000000 +0900
+++ gcc-8.3.0/libcpp/expr.c 2020-09-11 15:46:22.370000000 +0900
@@ -794,10 +794,10 @@
if (CPP_OPTION (pfile, c99))
cpp_warning_with_line (pfile, CPP_W_LONG_LONG, virtual_location,
- 0, message);
@ -14,7 +14,7 @@ by default rejects some codes in libcpp. This patch fixes them.
- virtual_location, 0, message);
+ virtual_location, 0, "%s", message);
}
result |= CPP_N_INTEGER;
--- gcc-8.3.0/libcpp/macro.c.bak 2020-09-11 16:01:42.550000000 +0900
+++ gcc-8.3.0/libcpp/macro.c 2020-09-11 16:03:47.850000000 +0900
@ -35,22 +35,22 @@ by default rejects some codes in libcpp. This patch fixes them.
+ "%s", vaopt_paste_error);
return ERROR;
}
@@ -3361,7 +3361,7 @@
function-like macros, but not at the end. */
if (following_paste_op)
{
- cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
+ cpp_error (pfile, CPP_DL_ERROR, "%s", paste_op_error_msg);
return false;
goto out;
}
break;
if (!vaopt_tracker.completed ())
@@ -3374,7 +3374,7 @@
function-like macros, but not at the beginning. */
if (macro->count == 1)
{
- cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
+ cpp_error (pfile, CPP_DL_ERROR, "%s", paste_op_error_msg);
return false;
goto out;
}

0
util/crossgcc/patches/gcc-8.3.0_libgcc.patch → util/crossgcc/patches/gcc-11.2.0_libgcc.patch
View File

150
util/crossgcc/patches/gcc-8.3.0_gnat-bad_constant.patch
View File

@ -1,150 +0,0 @@
commit b6f742f96c62bab0582021455328ae3be58e16d3
Author: pmderodat <pmderodat@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Fri May 25 09:05:10 2018 +0000
[Ada] Remove "constant" attribute on Osint.Unknown_Attributes
2018-05-25 Arnaud Charlet <charlet@adacore.com>
gcc/ada/
* exp_aggr.adb (Convert_To_Positional): Bump default for
Max_Others_Replicate to 32. Update comments.
* osint.ads (Unknown_Attributes): No longer pretend this is a constant.
(No_File_Info_Cache): Initialize separately.
* osint.adb (No_File_Info_Cache): Update initializer.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@260739 138bc75d-0d04-0410-961f-82ee72b054a4
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index e4127e472aa..d56240b7b82 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -188,6 +188,14 @@
an allocator if the type is an unconstrained record type with default
discriminant.
+2018-05-25 Arnaud Charlet <charlet@adacore.com>
+
+ * exp_aggr.adb (Convert_To_Positional): Bump default for
+ Max_Others_Replicate to 32. Update comments.
+ * osint.ads (Unknown_Attributes): No longer pretend this is a constant.
+ (No_File_Info_Cache): Initialize separately.
+ * osint.adb (No_File_Info_Cache): Update initializer.
+
2018-05-04 John Marino <gnugcc@marino.st>
PR ada/85635
diff --git a/gcc/ada/exp_aggr.adb b/gcc/ada/exp_aggr.adb
index f723c1b4d99..ff5210eb4e4 100644
--- a/gcc/ada/exp_aggr.adb
+++ b/gcc/ada/exp_aggr.adb
@@ -284,14 +284,14 @@ package body Exp_Aggr is
procedure Convert_To_Positional
(N : Node_Id;
- Max_Others_Replicate : Nat := 5;
+ Max_Others_Replicate : Nat := 32;
Handle_Bit_Packed : Boolean := False);
-- If possible, convert named notation to positional notation. This
-- conversion is possible only in some static cases. If the conversion is
-- possible, then N is rewritten with the analyzed converted aggregate.
-- The parameter Max_Others_Replicate controls the maximum number of
-- values corresponding to an others choice that will be converted to
- -- positional notation (the default of 5 is the normal limit, and reflects
+ -- positional notation (the default of 32 is the normal limit, and reflects
-- the fact that normally the loop is better than a lot of separate
-- assignments). Note that this limit gets overridden in any case if
-- either of the restrictions No_Elaboration_Code or No_Implicit_Loops is
@@ -301,11 +301,6 @@ package body Exp_Aggr is
-- Packed_Array_Aggregate_Handled, we set this parameter to True, since
-- these are cases we handle in there.
- -- It would seem useful to have a higher default for Max_Others_Replicate,
- -- but aggregates in the compiler make this impossible: the compiler
- -- bootstrap fails if Max_Others_Replicate is greater than 25. This
- -- is unexpected ???
-
procedure Expand_Array_Aggregate (N : Node_Id);
-- This is the top-level routine to perform array aggregate expansion.
-- N is the N_Aggregate node to be expanded.
@@ -4292,7 +4287,7 @@ package body Exp_Aggr is
procedure Convert_To_Positional
(N : Node_Id;
- Max_Others_Replicate : Nat := 5;
+ Max_Others_Replicate : Nat := 32;
Handle_Bit_Packed : Boolean := False)
is
Typ : constant Entity_Id := Etype (N);
diff --git a/gcc/ada/osint.adb b/gcc/ada/osint.adb
index 0c23761b6dc..896fbc7ee37 100644
--- a/gcc/ada/osint.adb
+++ b/gcc/ada/osint.adb
@@ -250,8 +250,7 @@ package body Osint is
Attr : aliased File_Attributes;
end record;
- No_File_Info_Cache : constant File_Info_Cache :=
- (No_File, Unknown_Attributes);
+ No_File_Info_Cache : constant File_Info_Cache := (No_File, (others => 0));
package File_Name_Hash_Table is new GNAT.HTable.Simple_HTable (
Header_Num => File_Hash_Num,
diff --git a/gcc/ada/osint.ads b/gcc/ada/osint.ads
index 65a87fe4ce3..6c75b521456 100644
--- a/gcc/ada/osint.ads
+++ b/gcc/ada/osint.ads
@@ -255,10 +255,26 @@ package Osint is
-- from the disk and then cached in the File_Attributes parameter (possibly
-- along with other values).
- type File_Attributes is private;
- Unknown_Attributes : constant File_Attributes;
+ File_Attributes_Size : constant Natural := 32;
+ -- This should be big enough to fit a "struct file_attributes" on any
+ -- system. It doesn't cause any malfunction if it is too big (which avoids
+ -- the need for either mapping the struct exactly or importing the sizeof
+ -- from C, which would result in dynamic code). However, it does waste
+ -- space (e.g. when a component of this type appears in a record, if it is
+ -- unnecessarily large). Note: for runtime units, use System.OS_Constants.
+ -- SIZEOF_struct_file_attributes instead, which has the exact value.
+
+ type File_Attributes is
+ array (1 .. File_Attributes_Size)
+ of System.Storage_Elements.Storage_Element;
+ for File_Attributes'Alignment use Standard'Maximum_Alignment;
+
+ Unknown_Attributes : File_Attributes;
-- A cache for various attributes for a file (length, accessibility,...)
- -- This must be initialized to Unknown_Attributes prior to the first call.
+ -- Will be initialized properly at elaboration (for efficiency later on,
+ -- avoid function calls every time we want to reset the attributes) prior
+ -- to the first usage. We cannot make it constant since the compiler may
+ -- put it in a read-only section.
function Is_Directory
(Name : C_File_Name;
@@ -754,22 +770,4 @@ private
-- detected, the file being written is deleted, and a fatal error is
-- signalled.
- File_Attributes_Size : constant Natural := 32;
- -- This should be big enough to fit a "struct file_attributes" on any
- -- system. It doesn't cause any malfunction if it is too big (which avoids
- -- the need for either mapping the struct exactly or importing the sizeof
- -- from C, which would result in dynamic code). However, it does waste
- -- space (e.g. when a component of this type appears in a record, if it is
- -- unnecessarily large). Note: for runtime units, use System.OS_Constants.
- -- SIZEOF_struct_file_attributes instead, which has the exact value.
-
- type File_Attributes is
- array (1 .. File_Attributes_Size)
- of System.Storage_Elements.Storage_Element;
- for File_Attributes'Alignment use Standard'Maximum_Alignment;
-
- Unknown_Attributes : constant File_Attributes := (others => 0);
- -- Will be initialized properly at elaboration (for efficiency later on,
- -- avoid function calls every time we want to reset the attributes).
-
end Osint;

270
util/crossgcc/patches/gcc-8.3.0_gnat_eh.patch
View File

@ -1,270 +0,0 @@
commit 5d733372faa97c1c3943a20a252d000db37c738b
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Aug 2 18:46:51 2019 +0000
rework Ada EH Machine_Occurrence deallocation
Introduce exception handler ABI #1 to ensure single release, no access
after release of reraised Machine_Occurrences, and no failure to
re-reraise a Machine_Occurrence.
Unlike Ada exceptions, foreign exceptions do not get a new
Machine_Occurrence upon reraise, but each handler would delete the
exception upon completion, normal or exceptional, save for the case of
a 'raise;' statement within the handler, that avoided the delete by
clearing the exception pointer that the cleanup would use to release
it. The cleared exception pointer might then be used by a subsequent
reraise within the same handler. Get_Current_Excep.all would also
expose the Machine_Occurrence to reuse by Reraise_Occurrence, even for
native exceptions.
Under ABI #1, Begin_Handler_v1 claims responsibility for releasing an
exception by saving its cleanup and setting it to Claimed_Cleanup.
End_Handler_v1 restores the cleanup and runs it, as long as it isn't
still Claimed_Cleanup (which indicates an enclosing handler has
already claimed responsibility for releasing it), and as long as the
same exception is not being propagated up (the next handler of the
propagating exception will then claim responsibility for releasing
it), so reraise no longer needs to clear the exception pointer, and it
can just propagate the exception, just like Reraise_Occurrence.
ABI #1 is fully interoperable with ABI #0, i.e., exception handlers
that call the #0 primitives can be linked together with ones that call
the #1 primitives, and they will not misbehave. When a #1 handler
claims responsibility for releasing an exception, even #0 reraises
dynamically nested within it will refrain from releasing it. However,
when a #0 handler is a handler of a foreign exception that would have
been responsible for releasing it with #1, a Reraise_Occurrence of
that foreign or other Machine_Occurrence-carrying exception may still
cause the exception to be released multiple times, and to be used
after it is first released, even if other handlers of the foreign
exception use #1.
for gcc/ada/ChangeLog
* libgnat/a-exexpr.adb (Begin_Handler_v1, End_Handler_v1): New.
(Claimed_Cleanup): New.
(Begin_Handler, End_Handler): Document.
* gcc-interface/trans.c (gigi): Switch to exception handler
ABI #1.
(Exception_Handler_to_gnu_gcc): Save the original cleanup
returned by begin handler, pass it to end handler, and use
EH_ELSE_EXPR to pass a propagating exception to end handler.
(gnat_to_gnu): Leave the exception pointer alone for reraise.
(add_cleanup): Handle EH_ELSE_EXPR, require it by itself.
From-SVN: r274029
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 --
-------------------

21019
util/crossgcc/patches/gcc-8.3.0_nds32_ite.patch
View File

File diff suppressed because it is too large Load Diff

1
util/crossgcc/sum/gcc-11.2.0.tar.xz.cksum Normal file
View File

@ -0,0 +1 @@
f902ccacecf8949978d6261e9f1d034cff73ffdb tarballs/gcc-11.2.0.tar.xz

1
util/crossgcc/sum/gcc-8.3.0.tar.xz.cksum
View File

@ -1 +0,0 @@
c27f4499dd263fe4fb01bcc5565917f3698583b2 tarballs/gcc-8.3.0.tar.xz