2007-12-06 Robert Dewar <dewar@adacore.com>

	* s-osinte-lynxos-3.ads, s-osinte-hpux.ads, s-osinte-solaris-posix.ads, 
	s-osinte-freebsd.ads, s-osinte-lynxos.ads, s-osinte-tru64.ads, 
	s-osinte-mingw.ads, s-osinte-aix.ads, s-osinte-hpux-dce.ads, 
	s-osinte-irix.ads, s-osinte-solaris.ads, s-intman-vms.adb,
	s-osinte-vms.ads, s-osinte-vxworks6.ads, s-osinte-vxworks.ads,
	s-auxdec.ads, s-auxdec-vms_64.ads, s-osinte-darwin.ads, 
	s-taprop-vms.adb, s-interr-sigaction.adb, s-osinte-linux-hppa.ads, 
	i-vxwork-x86.ads, s-tpopde-vms.ads: Add missing pragma Convention C
	for subprogram pointers.

	* g-ctrl_c.adb: New file.

	* g-ctrl_c.ads (Install_Handler): New body.

	* freeze.adb (Freeze_Subprogram): Use new flag Has_Pragma_Inline_Always
	instead of obsolete function Is_Always_Inlined.
	(Freeze_Entity): check for tagged type in imported C subprogram
	(Freeze_Entity): check for 8-bit boolean in imported C subprogram
	(Freeze_Entity): check for convention Ada subprogram pointer in
	imported C subprogram.
	(Freeze_Fixed_Point_Type): In the case of a base type where the low
	bound would be chopped off and go from negative to zero, force
	Loval_Excl_EP to be the same as Loval_Incl_EP (the included lower
	bound) so that the size computation for the base type will take
	negative values into account.



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

1 files changed, 89 insertions, 8 deletions

diff --git a/gcc/ada/s-auxdec-vms_64.ads b/gcc/ada/s-auxdec-vms_64.ads
index 0911dd647b0..9d55cb8f50e 100644
--- a/gcc/ada/s-auxdec-vms_64.ads
+++ b/gcc/ada/s-auxdec-vms_64.ads
@@ -465,28 +465,109 @@ private
    pragma Inline_Always (Fetch_From_Address);
    pragma Inline_Always (Assign_To_Address);
 
-   --  Synchronization related subprograms. These are declared to have
-   --  convention C so that the critical parameters are passed by reference.
+   --  Synchronization related subprograms. Mechanism is explicitly set
+   --  so that the critical parameters are passed by reference.
    --  Without this, the parameters are passed by copy, creating load/store
    --  race conditions. We also inline them, since this seems more in the
    --  spirit of the original (hardware intrinsic) routines.
 
-   pragma Convention (C, Clear_Interlocked);
+   pragma Export_Procedure
+     (Clear_Interlocked,
+      External        => "system__aux_dec__clear_interlocked__1",
+      Parameter_Types => (Boolean, Boolean),
+      Mechanism       => (Reference, Reference));
+   pragma Export_Procedure
+     (Clear_Interlocked,
+      External        => "system__aux_dec__clear_interlocked__2",
+      Parameter_Types => (Boolean, Boolean, Natural, Boolean),
+      Mechanism       => (Reference, Reference, Value, Reference));
    pragma Inline_Always (Clear_Interlocked);
 
-   pragma Convention (C, Set_Interlocked);
+   pragma Export_Procedure
+     (Set_Interlocked,
+      External        => "system__aux_dec__set_interlocked__1",
+      Parameter_Types => (Boolean, Boolean),
+      Mechanism       => (Reference, Reference));
+   pragma Export_Procedure
+     (Set_Interlocked,
+      External        => "system__aux_dec__set_interlocked__2",
+      Parameter_Types => (Boolean, Boolean, Natural, Boolean),
+      Mechanism       => (Reference, Reference, Value, Reference));
    pragma Inline_Always (Set_Interlocked);
 
-   pragma Convention (C, Add_Interlocked);
+   pragma Export_Procedure
+     (Add_Interlocked,
+      External        => "system__aux_dec__add_interlocked__1",
+      Mechanism       => (Value, Reference, Reference));
    pragma Inline_Always (Add_Interlocked);
 
-   pragma Convention (C, Add_Atomic);
+   pragma Export_Procedure
+     (Add_Atomic,
+      External        => "system__aux_dec__add_atomic__1",
+      Parameter_Types => (Aligned_Integer, Integer),
+      Mechanism       => (Reference, Value));
+   pragma Export_Procedure
+     (Add_Atomic,
+      External        => "system__aux_dec__add_atomic__2",
+      Parameter_Types => (Aligned_Integer, Integer, Natural, Integer, Boolean),
+      Mechanism       => (Reference, Value, Value, Reference, Reference));
+   pragma Export_Procedure
+     (Add_Atomic,
+      External        => "system__aux_dec__add_atomic__3",
+      Parameter_Types => (Aligned_Long_Integer, Long_Integer),
+      Mechanism       => (Reference, Value));
+   pragma Export_Procedure
+     (Add_Atomic,
+      External        => "system__aux_dec__add_atomic__4",
+      Parameter_Types => (Aligned_Long_Integer, Long_Integer, Natural,
+                          Long_Integer, Boolean),
+      Mechanism       => (Reference, Value, Value, Reference, Reference));
    pragma Inline_Always (Add_Atomic);
 
-   pragma Convention (C, And_Atomic);
+   pragma Export_Procedure
+     (And_Atomic,
+      External        => "system__aux_dec__and_atomic__1",
+      Parameter_Types => (Aligned_Integer, Integer),
+      Mechanism       => (Reference, Value));
+   pragma Export_Procedure
+     (And_Atomic,
+      External        => "system__aux_dec__and_atomic__2",
+      Parameter_Types => (Aligned_Integer, Integer, Natural, Integer, Boolean),
+      Mechanism       => (Reference, Value, Value, Reference, Reference));
+   pragma Export_Procedure
+     (And_Atomic,
+      External        => "system__aux_dec__and_atomic__3",
+      Parameter_Types => (Aligned_Long_Integer, Long_Integer),
+      Mechanism       => (Reference, Value));
+   pragma Export_Procedure
+     (And_Atomic,
+      External        => "system__aux_dec__and_atomic__4",
+      Parameter_Types => (Aligned_Long_Integer, Long_Integer, Natural,
+                          Long_Integer, Boolean),
+      Mechanism       => (Reference, Value, Value, Reference, Reference));
    pragma Inline_Always (And_Atomic);
 
-   pragma Convention (C, Or_Atomic);
+   pragma Export_Procedure
+     (Or_Atomic,
+      External        => "system__aux_dec__or_atomic__1",
+      Parameter_Types => (Aligned_Integer, Integer),
+      Mechanism       => (Reference, Value));
+   pragma Export_Procedure
+     (Or_Atomic,
+      External        => "system__aux_dec__or_atomic__2",
+      Parameter_Types => (Aligned_Integer, Integer, Natural, Integer, Boolean),
+      Mechanism       => (Reference, Value, Value, Reference, Reference));
+   pragma Export_Procedure
+     (Or_Atomic,
+      External        => "system__aux_dec__or_atomic__3",
+      Parameter_Types => (Aligned_Long_Integer, Long_Integer),
+      Mechanism       => (Reference, Value));
+   pragma Export_Procedure
+     (Or_Atomic,
+      External        => "system__aux_dec__or_atomic__4",
+      Parameter_Types => (Aligned_Long_Integer, Long_Integer, Natural,
+                          Long_Integer, Boolean),
+      Mechanism       => (Reference, Value, Value, Reference, Reference));
    pragma Inline_Always (Or_Atomic);
 
    --  Provide proper unchecked conversion definitions for transfer