2007-08-16 Thomas Quinot <quinot@adacore.com>

	* g-dyntab.adb, g-table.adb, table.adb: (Set_Item): Suppress
	Range_Check on Allocated_Table.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@127541 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ada/g-dyntab.adb b/gcc/ada/g-dyntab.adb
index a6a61a4..32604bd 100644 (file)
--- 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 2fd5d32..32d18a0 100644 (file)
--- 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 273be81..db64c4c 100644 (file)
--- 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