Renaming of target specific files for clarity

        * Makefile.in: Rename GNAT target specific files.

	* 31soccon.ads, 31soliop.ads 35soccon.ads, 3asoccon.ads,
	3bsoccon.ads, 3gsoccon.ads, 3hsoccon.ads, 3psoccon.ads,
	3ssoccon.ads, 3ssoliop.ads, 3veacodu.adb, 3vexpect.adb,
	3vsoccon.ads, 3vsocthi.adb, 3vsocthi.ads, 3vtrasym.adb,
	3wsoccon.ads, 3wsocthi.adb, 3wsocthi.ads, 3wsoliop.ads,
	3zsoccon.ads, 3zsocthi.adb, 3zsocthi.ads, 41intnam.ads,
	42intnam.ads, 45intnam.ads, 4aintnam.ads, 4cintnam.ads,
	4gintnam.ads, 4hexcpol.adb, 4hintnam.ads, 4lintnam.ads,
	4nintnam.ads, 4ointnam.ads, 4onumaux.ads, 4pintnam.ads,
	4sintnam.ads, 4vcaldel.adb, 4vcalend.adb, 4vcalend.ads,
	4vintnam.ads, 4wcalend.adb, 4wexcpol.adb, 4wintnam.ads,
	4zintnam.ads, 4znumaux.ads, 4zsytaco.adb, 4zsytaco.ads,
	51osinte.adb, 51osinte.ads, 51system.ads,
	52osinte.adb, 52osinte.ads, 53osinte.ads, 54osinte.ads,
	55osinte.adb, 55osinte.ads, 55system.ads, 56osinte.adb,
	56osinte.ads, 56system.ads, 56taprop.adb, 56taspri.ads,
	56tpopsp.adb, 57system.ads, 58system.ads,
	5amastop.adb, 5aml-tgt.adb, 5aosinte.adb, 5aosinte.ads,
	5asystem.ads, 5ataprop.adb, 5atasinf.ads, 5ataspri.ads,
	5atpopsp.adb, 5avxwork.ads, 5bml-tgt.adb, 5bosinte.adb,
	5bosinte.ads, 5bsystem.ads, 5cosinte.ads, 5csystem.ads,
	5dsystem.ads, 5esystem.ads, 5fintman.adb, 5fosinte.adb,
	5fosinte.ads, 5fsystem.ads, 5ftaprop.adb, 5ftasinf.ads,
	5ginterr.adb, 5gintman.adb, 5gmastop.adb, 5gml-tgt.adb,
	5gosinte.ads, 5gproinf.adb, 5gproinf.ads, 5gsystem.ads,
	5gtaprop.adb, 5gtasinf.adb, 5gtasinf.ads, 5gtpgetc.adb,
	5hml-tgt.adb, 5hosinte.adb, 5hosinte.ads, 5hparame.ads,
	5hsystem.ads, 5htaprop.adb, 5htaspri.ads, 5htraceb.adb,
	5iosinte.adb, 5iosinte.ads, 5itaprop.adb, 5itaspri.ads,
	5ksystem.ads, 5kvxwork.ads, 5lml-tgt.adb, 5losinte.ads,
	5lparame.adb, 5lsystem.ads, 5msystem.ads, 5mvxwork.ads,
	5ninmaop.adb, 5nintman.adb, 5nosinte.ads, 5nsystem.ads,
	5ntaprop.adb, 5ntaspri.ads, 5ointerr.adb, 5omastop.adb,
	5oosinte.adb, 5oosinte.ads, 5oosprim.adb, 5oparame.adb,
	5osystem.ads, 5otaprop.adb, 5otaspri.ads, 5posinte.ads,
	5posprim.adb, 5psystem.ads, 5pvxwork.ads, 5sintman.adb,
	5sml-tgt.adb, 5sosinte.adb, 5sosinte.ads, 5sosprim.adb,
	5sparame.adb, 5ssystem.ads, 5staprop.adb, 5stasinf.adb,
	5stasinf.ads, 5staspri.ads, 5stpopsp.adb, 5svxwork.ads,
	5tosinte.ads, 5usystem.ads, 5vasthan.adb, 5vdirval.adb,
	5vinmaop.adb, 5vinterr.adb, 5vintman.adb, 5vintman.ads,
	5vmastop.adb, 5vml-tgt.adb, 5vosinte.adb, 5vosinte.ads,
	5vosprim.adb, 5vosprim.ads, 5vparame.ads, 5vsymbol.adb,
	5vsystem.ads, 5vtaprop.adb, 5vtaspri.ads, 5vtpopde.adb,
	5vtpopde.ads, 5vtraent.adb, 5vtraent.ads, 5vvaflop.adb,
	5wdirval.adb, 5wgloloc.adb, 5wintman.adb, 5wmemory.adb,
	5wml-tgt.adb, 5wosinte.ads, 5wosprim.adb, 5wsystem.ads,
	5wtaprop.adb, 5wtaspri.ads, 5xparame.ads, 5xsystem.ads,
	5xvxwork.ads, 5yparame.ads, 5ysystem.ads, 5zinterr.adb,
	5zintman.adb, 5zintman.ads, 5zml-tgt.adb, 5zosinte.adb,
	5zosinte.ads, 5zosprim.adb, 5zparame.ads, 5zstchop.adb,
	5zsystem.ads, 5ztaprop.adb, 5ztaspri.ads, 5ztfsetr.adb,
	5ztpopsp.adb, 6vcpp.adb, 6vcstrea.adb, 6vinterf.ads,
	7sinmaop.adb, 7sintman.adb, 7sosinte.adb, 7sosprim.adb,
	7staprop.adb, 7staspri.ads, 7stfsetr.adb, 7stpopsp.adb,
	7straceb.adb, 7straces.adb, 7strafor.adb, 7strafor.ads,
	7stratas.adb, 86numaux.adb, 86numaux.ads: Replaced by files below.

	* a-caldel-vms.adb, a-calend-mingw.adb, a-calend-vms.adb,
	a-calend-vms.ads, a-dirval-mingw.adb, a-dirval-vms.adb,
	a-excpol-abort.adb, a-excpol-interix.adb, a-intnam-aix.ads,
	a-intnam-dummy.ads, a-intnam-freebsd.ads, a-intnam-hpux.ads,
	a-intnam-interix.ads, a-intnam-irix.ads, a-intnam-linux.ads,
	a-intnam-lynxos.ads, a-intnam-mingw.ads, a-intnam-os2.ads,
	a-intnam-solaris.ads, a-intnam-tru64.ads, a-intnam-unixware.ads,
	a-intnam-vms.ads, a-intnam-vxworks.ads, a-numaux-libc-x86.ads,
	a-numaux-vxworks.ads, a-numaux-x86.adb, a-numaux-x86.ads,
	a-sytaco-vxworks.adb, a-sytaco-vxworks.ads, g-eacodu-vms.adb,
	g-expect-vms.adb, g-soccon-aix.ads, g-soccon-freebsd.ads,
	g-soccon-hpux.ads, g-soccon-interix.ads, g-soccon-irix.ads,
	g-soccon-mingw.ads, g-soccon-solaris.ads, g-soccon-tru64.ads,
	g-soccon-unixware.ads, g-soccon-vms.adb, g-soccon-vxworks.ads,
	g-socthi-mingw.adb, g-socthi-mingw.ads, g-socthi-vms.adb,
	g-socthi-vms.ads, g-socthi-vxworks.adb, g-socthi-vxworks.ads,
	g-soliop-mingw.ads, g-soliop-solaris.ads, g-soliop-unixware.ads,
	g-trasym-vms.adb, i-cpp-vms.adb, i-cstrea-vms.adb,
	interfac-vms.ads, mlib-tgt-aix.adb, mlib-tgt-hpux.adb,
	mlib-tgt-irix.adb, mlib-tgt-linux.adb, mlib-tgt-mingw.adb,
	mlib-tgt-solaris.adb, mlib-tgt-tru64.adb, mlib-tgt-vms.adb,
	mlib-tgt-vxworks.adb, s-asthan-vms.adb, s-gloloc-mingw.adb,
	s-inmaop-dummy.adb, s-inmaop-posix.adb, s-inmaop-vms.adb,
	s-interr-dummy.adb, s-interr-sigaction.adb, s-interr-vms.adb,
	s-interr-vxworks.adb, s-intman-dummy.adb, s-intman-irix.adb,
	s-intman-irix-athread.adb, s-intman-mingw.adb, s-intman-posix.adb,
	s-intman-solaris.adb, s-intman-vms.adb, s-intman-vms.ads,
	s-intman-vxworks.adb, s-intman-vxworks.ads, s-mastop-irix.adb,
	s-mastop-tru64.adb, s-mastop-vms.adb, s-mastop-x86.adb,
	s-memory-mingw.adb, s-osinte-aix.adb, s-osinte-aix.ads,
	s-osinte-aix-fsu.ads, s-osinte-dummy.ads, s-osinte-freebsd.adb,
	s-osinte-freebsd.ads, s-osinte-fsu.adb, s-osinte-hpux.ads,
	s-osinte-hpux-dce.adb, s-osinte-hpux-dce.ads, s-osinte-interix.ads,
	s-osinte-irix.adb, s-osinte-irix.ads, s-osinte-irix-athread.ads,
	s-osinte-linux.ads, s-osinte-linux-fsu.ads, s-osinte-linux-ia64.ads,
	s-osinte-lynxos-3.adb, s-osinte-lynxos-3.ads, s-osinte-lynxos.adb,
	s-osinte-lynxos.ads, s-osinte-mingw.ads, s-osinte-os2.adb,
	s-osinte-os2.ads, s-osinte-posix.adb, s-osinte-solaris.adb,
	s-osinte-solaris.ads, s-osinte-solaris-fsu.ads,
	s-osinte-solaris-posix.ads, s-osinte-tru64.adb, s-osinte-tru64.ads,
	s-osinte-unixware.adb, s-osinte-unixware.ads, s-osinte-vms.adb,
	s-osinte-vms.ads, s-osinte-vxworks.adb,
	s-osinte-vxworks.ads, s-osprim-mingw.adb,
	s-osprim-os2.adb, s-osprim-posix.adb, s-osprim-solaris.adb,
	s-osprim-unix.adb, s-osprim-vms.adb, s-osprim-vms.ads,
	s-osprim-vxworks.adb, s-parame-ae653.ads, s-parame-hpux.ads,
	s-parame-linux.adb, s-parame-os2.adb, s-parame-solaris.adb,
	s-parame-vms.ads, s-parame-vms-restrict.ads, s-parame-vxworks.ads,
	s-proinf-irix-athread.adb, s-proinf-irix-athread.ads,
	s-stchop-vxworks.adb, s-taprop-dummy.adb,
	s-taprop-hpux-dce.adb, s-taprop-irix.adb,
	s-taprop-irix-athread.adb, s-taprop-linux.adb, s-taprop-lynxos.adb,
	s-taprop-mingw.adb, s-taprop-os2.adb, s-taprop-posix.adb,
	s-taprop-solaris.adb, s-taprop-tru64.adb, s-taprop-vms.adb,
	s-taprop-vxworks.adb, s-tasinf-irix.ads, s-tasinf-irix-athread.adb,
	s-tasinf-irix-athread.ads, s-tasinf-solaris.adb, s-tasinf-solaris.ads,
	s-tasinf-tru64.ads, s-taspri-dummy.ads, s-taspri-hpux-dce.ads,
	s-taspri-linux.ads, s-taspri-lynxos.ads, s-taspri-mingw.ads,
	s-taspri-os2.ads, s-taspri-posix.ads, s-taspri-solaris.ads,
	s-taspri-tru64.ads, s-taspri-vms.ads, s-taspri-vxworks.ads,
	s-tfsetr-default.adb, s-tfsetr-vxworks.adb, s-tpopde-vms.adb,
	s-tpopde-vms.ads, s-tpopsp-lynxos.adb, s-tpopsp-posix.adb,
	s-tpopsp-posix-foreign.adb, s-tpopsp-solaris.adb, s-tpopsp-vxworks.adb,
	s-traceb-hpux.adb, s-traceb-mastop.adb, s-traces-default.adb,
	s-traent-vms.adb, s-traent-vms.ads, s-trafor-default.adb,
	s-trafor-default.ads, s-tratas-default.adb, s-vaflop-vms.adb,
	s-vxwork-alpha.ads, s-vxwork-m68k.ads, s-vxwork-mips.ads,
	s-vxwork-ppc.ads, s-vxwork-sparcv9.ads, s-vxwork-xscale.ads,
	symbols-vms.adb, system-aix.ads, system-freebsd-x86.ads,
	system-hpux.ads, system-interix.ads, system-irix-n32.ads,
	system-irix-o32.ads, system-linux-x86_64.ads,
	system-linux-x86.ads, system-lynxos-ppc.ads, system-lynxos-x86.ads,
	system-mingw.ads, system-os2.ads, system-solaris-sparc.ads,
	system-solaris-sparcv9.ads, system-solaris-x86.ads, system-tru64.ads,
	system-unixware.ads, system-vms.ads, system-vms-zcx.ads,
	system-vxworks-alpha.ads, system-vxworks-m68k.ads,
	system-vxworks-mips.ads, system-vxworks-ppc.ads,
	system-vxworks-sparcv9.ads, system-vxworks-xscale.ads: Replace files
	above.


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

1 files changed, 600 insertions, 0 deletions

diff --git a/gcc/ada/s-traceb-hpux.adb b/gcc/ada/s-traceb-hpux.adb
new file mode 100644
index 00000000000..dce251a05a9
--- /dev/null
+++ b/gcc/ada/s-traceb-hpux.adb
@@ -0,0 +1,600 @@
+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT COMPILER COMPONENTS                         --
+--                                                                          --
+--                     S Y S T E M . T R A C E B A C K                      --
+--                             (HP/UX Version)                              --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--           Copyright (C) 1999-2003 Ada Core Technologies, Inc.            --
+--                                                                          --
+-- GNAT is free software;  you can  redistribute it  and/or modify it under --
+-- terms of the  GNU General Public License as published  by the Free Soft- --
+-- ware  Foundation;  either version 2,  or (at your option) any later ver- --
+-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
+-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
+-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Unchecked_Conversion;
+
+package body System.Traceback is
+
+   --  This package implements the backtracing facility by way of a dedicated
+   --  HP library for stack unwinding described in the "Runtime Architecture
+   --  Document".
+
+   pragma Linker_Options ("/usr/lib/libcl.a");
+
+   --  The library basically offers services to fetch information about a
+   --  "previous" frame based on information about a "current" one.
+
+   type Current_Frame_Descriptor is record
+      cur_fsz : Address;  --  Frame size of current routine.
+      cur_sp  : Address;  --  The current value of stack pointer.
+      cur_rls : Address;  --  PC-space of the caller.
+      cur_rlo : Address;  --  PC-offset of the caller.
+      cur_dp  : Address;  --  Data Pointer of the current routine.
+      top_rp  : Address;  --  Initial value of RP.
+      top_mrp : Address;  --  Initial value of MRP.
+      top_sr0 : Address;  --  Initial value of sr0.
+      top_sr4 : Address;  --  Initial value of sr4.
+      top_r3  : Address;  --  Initial value of gr3.
+      cur_r19 : Address;  --  GR19 value of the calling routine.
+      top_r4  : Address;  --  Initial value of gr4.
+      dummy   : Address;  --  Reserved.
+      out_rlo : Address;  --  PC-offset of the caller after get_previous.
+   end record;
+
+   type Previous_Frame_Descriptor is record
+      prev_fsz : Address;  --  frame size of calling routine.
+      prev_sp  : Address;  --  SP of calling routine.
+      prev_rls : Address;  --  PC_space of calling routine's caller.
+      prev_rlo : Address;  --  PC_offset of calling routine's caller.
+      prev_dp  : Address;  --  DP of calling routine.
+      udescr0  : Address;  --  low word of calling routine's unwind desc.
+      udescr1  : Address;  --  high word of calling routine's unwind desc.
+      ustart   : Address;  --  start of the unwind region.
+      uend     : Address;  --  end of the unwind region.
+      uw_index : Address;  --  index into the unwind table.
+      prev_r19 : Address;  --  GR19 value of the caller's caller.
+      top_r3   : Address;  --  Caller's initial gr3.
+      top_r4   : Address;  --  Caller's initial gr4.
+   end record;
+
+   --  Provide useful shortcuts for the names
+
+   subtype CFD is Current_Frame_Descriptor;
+   subtype PFD is Previous_Frame_Descriptor;
+
+   --  Frames with dynamic stack allocation are handled using the associated
+   --  frame pointer, but HP compilers and GCC setup this pointer differently.
+   --  HP compilers set it to point at the top (highest address) of the static
+   --  part of the frame, wheras GCC sets it to point at the bottom of this
+   --  region. We have to fake the unwinder to compensate for this difference,
+   --  for which we'll need to access some subprograms unwind descriptors.
+
+   type Bits_2_Value is mod 2 ** 2;
+   for Bits_2_Value'Size use 2;
+
+   type Bits_4_Value  is mod 2 ** 4;
+   for Bits_4_Value'Size use 4;
+
+   type Bits_5_Value  is mod 2 ** 5;
+   for Bits_5_Value'Size use 5;
+
+   type Bits_27_Value is mod 2 ** 27;
+   for Bits_27_Value'Size use 27;
+
+   type Unwind_Descriptor is record
+      cannot_unwind         : Boolean;
+      mcode                 : Boolean;
+      mcode_save_restore    : Boolean;
+      region_desc           : Bits_2_Value;
+      reserved0             : Boolean;
+      entry_sr              : Boolean;
+      entry_fr              : Bits_4_Value;
+      entry_gr              : Bits_5_Value;
+
+      args_stored           : Boolean;
+      variable_frame        : Boolean;
+      separate_package_body : Boolean;
+      frame_extension_mcode : Boolean;
+
+      stack_overflow_check  : Boolean;
+      two_steps_sp_adjust   : Boolean;
+      sr4_export            : Boolean;
+      cxx_info              : Boolean;
+
+      cxx_try_catch         : Boolean;
+      sched_entry_seq       : Boolean;
+      reserved1             : Boolean;
+      save_sp               : Boolean;
+
+      save_rp               : Boolean;
+      save_mrp              : Boolean;
+      save_r19              : Boolean;
+      cleanups              : Boolean;
+
+      hpe_interrupt_marker  : Boolean;
+      hpux_interrupt_marker : Boolean;
+      large_frame           : Boolean;
+      alloca_frame          : Boolean;
+
+      reserved2             : Boolean;
+      frame_size            : Bits_27_Value;
+   end record;
+
+   for Unwind_Descriptor'Size use 64;
+
+   for Unwind_Descriptor use record
+      cannot_unwind         at 0 range 0 .. 0;
+      mcode                 at 0 range 1 .. 1;
+      mcode_save_restore    at 0 range 2 .. 2;
+      region_desc           at 0 range 3 .. 4;
+      reserved0             at 0 range 5 .. 5;
+      entry_sr              at 0 range 6 .. 6;
+      entry_fr              at 0 range 7 .. 10;
+
+      entry_gr              at 1 range 3 .. 7;
+
+      args_stored           at 2 range 0 .. 0;
+      variable_frame        at 2 range 1 .. 1;
+      separate_package_body at 2 range 2 .. 2;
+      frame_extension_mcode at 2 range 3 .. 3;
+      stack_overflow_check  at 2 range 4 .. 4;
+      two_steps_sp_adjust   at 2 range 5 .. 5;
+      sr4_export            at 2 range 6 .. 6;
+      cxx_info              at 2 range 7 .. 7;
+
+      cxx_try_catch         at 3 range 0 .. 0;
+      sched_entry_seq       at 3 range 1 .. 1;
+      reserved1             at 3 range 2 .. 2;
+      save_sp               at 3 range 3 .. 3;
+      save_rp               at 3 range 4 .. 4;
+      save_mrp              at 3 range 5 .. 5;
+      save_r19              at 3 range 6 .. 6;
+      cleanups              at 3 range 7 .. 7;
+
+      hpe_interrupt_marker  at 4 range 0 .. 0;
+      hpux_interrupt_marker at 4 range 1 .. 1;
+      large_frame           at 4 range 2 .. 2;
+      alloca_frame          at 4 range 3 .. 3;
+
+      reserved2             at 4 range 4 .. 4;
+      frame_size            at 4 range 5 .. 31;
+   end record;
+
+   subtype UWD is Unwind_Descriptor;
+   type UWD_Ptr is access all UWD;
+
+   function To_UWD_Access is new Ada.Unchecked_Conversion (Address, UWD_Ptr);
+
+   --  The descriptor associated with a given code location is retrieved
+   --  using functions imported from the HP library, requiring the definition
+   --  of additional structures.
+
+   type Unwind_Table_Region is record
+      Table_Start : Address;
+      Table_End   : Address;
+   end record;
+   --  An Unwind Table region, which is a memory area containing Unwind
+   --  Descriptors.
+
+   subtype UWT is Unwind_Table_Region;
+
+   --  The subprograms imported below are provided by the HP library
+
+   function U_get_unwind_table return UWT;
+   pragma Import (C, U_get_unwind_table, "U_get_unwind_table");
+   --  Get the unwind table region associated with the current executable.
+   --  This function is actually documented as having an argument, but which
+   --  is only used for the MPE/iX targets.
+
+   function U_get_shLib_unwind_table (r19 : Address) return UWT;
+   pragma Import (C, U_get_shLib_unwind_table, "U_get_shLib_unw_tbl");
+   --  Return the unwind table region associated with a possible shared
+   --  library, as determined by the provided r19 value.
+
+   function U_get_shLib_text_addr (r19 : Address) return Address;
+   pragma Import (C, U_get_shLib_text_addr, "U_get_shLib_text_addr");
+   --  Return the address at which the code for a shared library begins, or
+   --  -1 if the value provided for r19 does not identify shared library code.
+
+   function U_get_unwind_entry
+     (Pc          : Address;
+      Space       : Address;
+      Table_Start : Address;
+      Table_End   : Address) return Address;
+   pragma Import (C, U_get_unwind_entry, "U_get_unwind_entry");
+   --  Given the bounds of an unwind table, return the address of the
+   --  unwind descriptor associated with a code location/space. In the case
+   --  of shared library code, the offset from the beginning of the library
+   --  is expected as Pc.
+
+   procedure U_init_frame_record (Frame : access CFD);
+   pragma Import (C, U_init_frame_record, "U_init_frame_record");
+
+   procedure U_prep_frame_rec_for_unwind (Frame : access CFD);
+   pragma Import (C, U_prep_frame_rec_for_unwind,
+                    "U_prep_frame_rec_for_unwind");
+
+   --  Fetch the description data of the frame in which these two procedures
+   --  are called.
+
+   function U_get_u_rlo (Cur : access CFD; Prev : access PFD) return Integer;
+   pragma Import (C, U_get_u_rlo, "U_IS_STUB_OR_CALLX");
+   --  From a complete current frame with a return location possibly located
+   --  into a linker generated stub, and basic information about the previous
+   --  frame, place the first non stub return location into the current frame.
+   --  Return -1 if something went wrong during the computation.
+
+   function U_is_shared_pc (rlo : Address; r19 : Address) return Address;
+   pragma Import (C, U_is_shared_pc, "U_is_shared_pc");
+   --  Return 0 if the provided return location does not correspond to code
+   --  in a shared library, or something non null otherwise.
+
+   function U_get_previous_frame_x
+     (current_frame  : access CFD;
+      previous_frame : access PFD;
+      previous_size  : Integer) return Integer;
+   pragma Import (C, U_get_previous_frame_x, "U_get_previous_frame_x");
+   --  Fetch the data describing the "previous" frame relatively to the
+   --  "current" one. "previous_size" should be the size of the "previous"
+   --  frame descriptor provided.
+   --
+   --  The library provides a simpler interface without the size parameter
+   --  but it is not usable when frames with dynamically allocated space are
+   --  on the way.
+
+   ------------------
+   -- C_Call_Chain --
+   ------------------
+
+   function C_Call_Chain
+     (Traceback : System.Address;
+      Max_Len   : Natural) return Natural
+   is
+      Val : Natural;
+
+   begin
+      Call_Chain (Traceback, Max_Len, Val);
+      return Val;
+   end C_Call_Chain;
+
+   ----------------
+   -- Call_Chain --
+   ----------------
+
+   procedure Call_Chain
+     (Traceback   : System.Address;
+      Max_Len     : Natural;
+      Len         : out Natural;
+      Exclude_Min : System.Address := System.Null_Address;
+      Exclude_Max : System.Address := System.Null_Address;
+      Skip_Frames : Natural := 1)
+   is
+      type Tracebacks_Array is array (1 .. Max_Len) of System.Address;
+      pragma Suppress_Initialization (Tracebacks_Array);
+
+      --  The code location returned by the unwinder is a return location but
+      --  what we need is a call point. Under HP-UX call instructions are 4
+      --  bytes long and the return point they specify is 4 bytes beyond the
+      --  next instruction because of the delay slot.
+
+      Call_Size  : constant := 4;
+      DSlot_Size : constant := 4;
+      Rlo_Offset : constant := Call_Size + DSlot_Size;
+
+      --  Moreover, the return point is passed via a register which two least
+      --  significant bits specify a privilege level that we will have to mask.
+
+      Priv_Mask  : constant := 16#00000003#;
+
+      Frame       : aliased CFD;
+      Code        : System.Address;
+      J           : Natural := 1;
+      Pop_Success : Boolean;
+      Trace       : Tracebacks_Array;
+      for Trace'Address use Traceback;
+
+      --  The backtracing process needs a set of subprograms :
+
+      function UWD_For_RLO_Of (Frame : access CFD) return UWD_Ptr;
+      --  Return an access to the unwind descriptor for the caller of
+      --  a given frame, using only the provided return location.
+
+      function UWD_For_Caller_Of (Frame : access CFD) return UWD_Ptr;
+      --  Return an access to the unwind descriptor for the user code caller
+      --  of a given frame, or null if the information is not available.
+
+      function Pop_Frame (Frame : access CFD) return Boolean;
+      --  Update the provided machine state structure so that it reflects
+      --  the state one call frame "above" the initial one.
+      --
+      --  Return True if the operation has been successful, False otherwise.
+      --  Failure typically occurs when the top of the call stack has been
+      --  reached.
+
+      function Prepare_For_Unwind_Of (Frame : access CFD) return Boolean;
+      --  Perform the necessary adaptations to the machine state before
+      --  calling the unwinder. Currently used for the specific case of
+      --  dynamically sized previous frames.
+      --
+      --  Return True if everything went fine, or False otherwise.
+
+      Program_UWT : constant UWT := U_get_unwind_table;
+
+      ---------------
+      -- Pop_Frame --
+      ---------------
+
+      function Pop_Frame (Frame : access CFD) return Boolean is
+         Up_Frame    : aliased PFD;
+         State_Ready : Boolean;
+
+      begin
+         --  Check/adapt the state before calling the unwinder and return
+         --  if anything went wrong.
+
+         State_Ready := Prepare_For_Unwind_Of (Frame);
+
+         if not State_Ready then
+            return False;
+         end if;
+
+         --  Now, safely call the unwinder and use the results.
+
+         if U_get_previous_frame_x (Frame,
+                                    Up_Frame'Access,
+                                    Up_Frame'Size) /= 0
+         then
+            return False;
+         end if;
+
+         --  In case a stub is on the way, the usual previous return location
+         --  (the one in prev_rlo) is the one in the stub and the "real" one
+         --  is placed in the "current" record, so let's take this one into
+         --  account.
+
+         Frame.out_rlo := Frame.cur_rlo;
+
+         Frame.cur_fsz := Up_Frame.prev_fsz;
+         Frame.cur_sp  := Up_Frame.prev_sp;
+         Frame.cur_rls := Up_Frame.prev_rls;
+         Frame.cur_rlo := Up_Frame.prev_rlo;
+         Frame.cur_dp  := Up_Frame.prev_dp;
+         Frame.cur_r19 := Up_Frame.prev_r19;
+         Frame.top_r3  := Up_Frame.top_r3;
+         Frame.top_r4  := Up_Frame.top_r4;
+
+         return True;
+      end Pop_Frame;
+
+      ---------------------------------
+      -- Prepare_State_For_Unwind_Of --
+      ---------------------------------
+
+      function Prepare_For_Unwind_Of (Frame : access CFD) return Boolean
+      is
+         Caller_UWD    : UWD_Ptr;
+         FP_Adjustment : Integer;
+
+      begin
+         --  No need to bother doing anything if the stack is already fully
+         --  unwound.
+
+         if Frame.cur_rlo = 0 then
+            return False;
+         end if;
+
+         --  When ALLOCA_FRAME is set in an unwind descriptor, the unwinder
+         --  uses the value provided in current.top_r3 or current.top_r4 as
+         --  a frame pointer to compute the size of the frame. What decides
+         --  between r3 or r4 is the unwind descriptor LARGE_FRAME bit, with
+         --  r4 chosen if the bit is set.
+
+         --  The size computed by the unwinder is STATIC_PART + (SP - FP),
+         --  which is correct with HP's frame pointer convention, but not
+         --  with GCC's one since we end up with the static part accounted
+         --  for twice.
+
+         --  We have to compute r4 when it is required because the unwinder
+         --  has looked for it at a place where it was not if we went through
+         --  GCC frames.
+
+         --  The size of the static part of a frame can be found in the
+         --  associated unwind descriptor.
+
+         Caller_UWD := UWD_For_Caller_Of (Frame);
+
+         --  If we cannot get it, we are unable to compute the potentially
+         --  necessary adjustments. We'd better not try to go on then.
+
+         if Caller_UWD = null then
+            return False;
+         end if;
+
+         --  If the caller frame is a GCC one, r3 is its frame pointer and
+         --  points to the bottom of the frame. The value to provide for r4
+         --  can then be computed directly from the one of r3, compensating
+         --  for the static part of the frame.
+
+         --  If the caller frame is an HP one, r3 is used to locate the
+         --  previous frame marker, that is it also points to the bottom of
+         --  the frame (this is why r3 cannot be used as the frame pointer in
+         --  the HP sense for large frames). The value to provide for r4 can
+         --  then also be computed from the one of r3 with the compensation
+         --  for the static part of the frame.
+
+         FP_Adjustment := Integer (Caller_UWD.frame_size * 8);
+         Frame.top_r4  := Address (Integer (Frame.top_r3) + FP_Adjustment);
+
+         return True;
+      end Prepare_For_Unwind_Of;
+
+      -----------------------
+      -- UWD_For_Caller_Of --
+      -----------------------
+
+      function UWD_For_Caller_Of (Frame : access CFD) return UWD_Ptr
+      is
+         UWD_Access : UWD_Ptr;
+
+      begin
+         --  First try the most direct path, using the return location data
+         --  associated with the frame.
+
+         UWD_Access := UWD_For_RLO_Of (Frame);
+
+         if UWD_Access /= null then
+            return UWD_Access;
+         end if;
+
+         --  If we did not get a result, we might face an in-stub return
+         --  address. In this case U_get_previous_frame can tell us what the
+         --  first not-in-stub return point is. We cannot call it directly,
+         --  though, because we haven't computed the potentially necessary
+         --  frame pointer adjustments, which might lead to SEGV in some
+         --  circumstances. Instead, we directly call the libcl routine which
+         --  is called by U_get_previous_frame and which only requires few
+         --  information. Take care, however, that the information is provided
+         --  in the "current" argument, so we need to work on a copy to avoid
+         --  disturbing our caller.
+
+         declare
+            U_Current  : aliased CFD := Frame.all;
+            U_Previous : aliased PFD;
+
+         begin
+            U_Previous.prev_dp  := U_Current.cur_dp;
+            U_Previous.prev_rls := U_Current.cur_rls;
+            U_Previous.prev_sp  := U_Current.cur_sp - U_Current.cur_fsz;
+
+            if U_get_u_rlo (U_Current'Access, U_Previous'Access) /= -1 then
+               UWD_Access := UWD_For_RLO_Of (U_Current'Access);
+            end if;
+         end;
+
+         return UWD_Access;
+      end UWD_For_Caller_Of;
+
+      --------------------
+      -- UWD_For_RLO_Of --
+      --------------------
+
+      function UWD_For_RLO_Of (Frame : access CFD) return UWD_Ptr
+      is
+         UWD_Address : Address;
+
+         --  The addresses returned by the library point to full descriptors
+         --  including the frame information bits but also the applicable PC
+         --  range. We need to account for this.
+
+         Frame_Info_Offset  : constant := 8;
+
+      begin
+         --  First try to locate the descriptor in the program's unwind table.
+
+         UWD_Address := U_get_unwind_entry (Frame.cur_rlo,
+                                            Frame.cur_rls,
+                                            Program_UWT.Table_Start,
+                                            Program_UWT.Table_End);
+
+         --  If we did not get it, we might have a frame from code in a
+         --  stub or shared library. For code in stub we would have to
+         --  compute the first non-stub return location but this is not
+         --  the role of this subprogram, so let's just try to see if we
+         --  can get a result from the tables in shared libraries.
+
+         if UWD_Address = -1
+           and then U_is_shared_pc (Frame.cur_rlo, Frame.cur_r19) /= 0
+         then
+            declare
+               Shlib_UWT   : constant UWT     :=
+                               U_get_shLib_unwind_table (Frame.cur_r19);
+               Shlib_Start : constant Address :=
+                               U_get_shLib_text_addr (Frame.cur_r19);
+               Rlo_Offset  : constant Address :=
+                               Frame.cur_rlo - Shlib_Start;
+            begin
+               UWD_Address := U_get_unwind_entry (Rlo_Offset,
+                                                  Frame.cur_rls,
+                                                  Shlib_UWT.Table_Start,
+                                                  Shlib_UWT.Table_End);
+            end;
+         end if;
+
+         if UWD_Address /= -1 then
+            return To_UWD_Access (UWD_Address + Frame_Info_Offset);
+         else
+            return null;
+         end if;
+      end UWD_For_RLO_Of;
+
+   --  Start of processing for Call_Chain
+
+   begin
+      --  Fetch the state for this subprogram's frame and pop it so that we
+      --  start with an initial out_rlo "here".
+
+      U_init_frame_record (Frame'Access);
+      Frame.top_sr0 := 0;
+      Frame.top_sr4 := 0;
+
+      U_prep_frame_rec_for_unwind (Frame'Access);
+
+      Pop_Success := Pop_Frame (Frame'Access);
+
+      --  Skip the requested number of frames.
+
+      for I in 1 .. Skip_Frames loop
+         Pop_Success := Pop_Frame (Frame'Access);
+      end loop;
+
+      --  Loop popping frames and storing locations until either a problem
+      --  occurs, or the top of the call chain is reached, or the provided
+      --  array is full.
+
+      loop
+         --  We have to test some conditions against the return location
+         --  as it is returned, so get it as is first.
+
+         Code := Frame.out_rlo;
+
+         exit when not Pop_Success or else Code = 0 or else J = Max_Len + 1;
+
+         --  Compute the call point from the retrieved return location :
+         --  Mask the privilege bits and account for the delta between the
+         --  call site and the return point.
+
+         Code := (Code and not Priv_Mask) - Rlo_Offset;
+
+         if Code < Exclude_Min or else Code > Exclude_Max then
+            Trace (J) := Code;
+            J := J + 1;
+         end if;
+
+         Pop_Success := Pop_Frame (Frame'Access);
+      end loop;
+
+      Len := J - 1;
+   end Call_Chain;
+
+end System.Traceback;