diff --git a/gcc/ada/g-dyntab.adb b/gcc/ada/g-dyntab.adb
index a6a61a432ea799d4aeadf495e26d92e7bd5d6a58..32604bdbca6db8335dbf94e92fd83c69c46c1d90 100644
--- a/gcc/ada/g-dyntab.adb
+++ b/gcc/ada/g-dyntab.adb
@@ -249,10 +249,20 @@ package body GNAT.Dynamic_Tables is
 
       Allocated_Table : Allocated_Table_T;
       pragma Import (Ada, Allocated_Table);
+      pragma Suppress (Range_Check, On => Allocated_Table);
       for Allocated_Table'Address use Allocated_Table_Address;
       --  Allocated_Table represents the currently allocated array, plus one
       --  element (the supplementary element is used to have a convenient way
-      --  to the address just past the end of the current allocation).
+      --  to the address just past the end of the current allocation). Range
+      --  checks are suppressed because this unit uses direct calls to
+      --  System.Memory for allocation, and this can yield misaligned storage
+      --  (and we cannot rely on the bootstrap compiler supporting specifically
+      --  disabling alignment cheks, so we need to suppress all range checks).
+      --  It is safe to suppress this check here because we know that a
+      --  (possibly misaligned) object of that type does actually exist at that
+      --  address.
+      --  ??? We should really improve the allocation circuitry here to
+      --  guarantee proper alignment.
 
       Need_Realloc : constant Boolean := Integer (Index) > T.P.Max;
       --  True if this operation requires storage reallocation (which may
diff --git a/gcc/ada/g-table.adb b/gcc/ada/g-table.adb
index 2fd5d320034ae5d0fa00c96413e5c89fa42e7348..32d18a08b74bd1356532af59814b95406fb15111 100644
--- a/gcc/ada/g-table.adb
+++ b/gcc/ada/g-table.adb
@@ -248,11 +248,20 @@ package body GNAT.Table is
 
       Allocated_Table : Allocated_Table_T;
       pragma Import (Ada, Allocated_Table);
+      pragma Suppress (Range_Check, On => Allocated_Table);
       for Allocated_Table'Address use Allocated_Table_Address;
       --  Allocated_Table represents the currently allocated array, plus
       --  one element (the supplementary element is used to have a
       --  convenient way of computing the address just past the end of the
-      --  current allocation).
+      --  current allocation). Range checks are suppressed because this unit
+      --  uses direct calls to System.Memory for allocation, and this can
+      --  yield misaligned storage (and we cannot rely on the bootstrap
+      --  compiler supporting specifically disabling alignment cheks, so we
+      --  need to suppress all range checks). It is safe to suppress this check
+      --  here because we know that a (possibly misaligned) object of that type
+      --  does actually exist at that address.
+      --  ??? We should really improve the allocation circuitry here to
+      --  guarantee proper alignment.
 
       Need_Realloc : constant Boolean := Integer (Index) > Max;
       --  True if this operation requires storage reallocation (which may
diff --git a/gcc/ada/table.adb b/gcc/ada/table.adb
index 273be819e2e565db32241b4543d09a558318ff2e..db64c4cf9564ce883f8026ed1243d5a727986e8b 100644
--- a/gcc/ada/table.adb
+++ b/gcc/ada/table.adb
@@ -287,11 +287,20 @@ package body Table is
 
          Allocated_Table : Allocated_Table_T;
          pragma Import (Ada, Allocated_Table);
+         pragma Suppress (Range_Check, On => Allocated_Table);
          for Allocated_Table'Address use Allocated_Table_Address;
          --  Allocated_Table represents the currently allocated array, plus one
          --  element (the supplementary element is used to have a convenient
          --  way of computing the address just past the end of the current
-         --  allocation).
+         --  allocation). Range checks are suppressed because this unit
+         --  uses direct calls to System.Memory for allocation, and this can
+         --  yield misaligned storage (and we cannot rely on the bootstrap
+         --  compiler supporting specifically disabling alignment cheks, so we
+         --  need to suppress all range checks). It is safe to suppress this
+         --  check here because we know that a (possibly misaligned) object
+         --  of that type does actually exist at that address.
+         --  ??? We should really improve the allocation circuitry here to
+         --  guarantee proper alignment.
 
          Need_Realloc : constant Boolean := Int (Index) > Max;
          --  True if this operation requires storage reallocation (which may