From patchwork Tue Jan 6 09:47:55 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arnaud Charlet X-Patchwork-Id: 425588 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 008E714009B for ; Tue, 6 Jan 2015 20:48:19 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:mime-version:content-type; q=dns; s=default; b=M5AgeRbQNXu226Kt3yqE8FFuV8RMuohycVc9WmnEb5DdeW1tjL H8I9onnXx23qF4vaVgPmxW9QD5aqeEvKWH2b2QpwAkMAXXVXe/h7fg88P+TRmDvr LthCzJbzQVKrTdVAZ8xeBbjTGIfhE1CDwH5mQoj5N++fUKcPf7bkHkPeU= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:mime-version:content-type; s= default; bh=pUOK2vCZKIdWsyTFkg8JY/XNa6s=; b=NBnA3mUgW8Bf2fg0VAT7 Er5eBQnVsoSTtXcJJnG4Xd/Ymx7FO9qTR+arnoKY94oj+fS5+VGGhsQBn2xva5mw +Gpvr9UXsXh4zDt7eLC95U8NoC8qvhCZypjyg7cIpkCgHgWuCjQIsKs67IKqW+hh YUhJFejCKymwNhhqhfOu1Kk= Received: (qmail 1013 invoked by alias); 6 Jan 2015 09:48:07 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 983 invoked by uid 89); 6 Jan 2015 09:48:05 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.8 required=5.0 tests=BAYES_50 autolearn=ham version=3.3.2 X-HELO: rock.gnat.com Received: from rock.gnat.com (HELO rock.gnat.com) (205.232.38.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Tue, 06 Jan 2015 09:47:57 +0000 Received: from localhost (localhost.localdomain [127.0.0.1]) by filtered-rock.gnat.com (Postfix) with ESMTP id 65F77116374; Tue, 6 Jan 2015 04:47:55 -0500 (EST) Received: from rock.gnat.com ([127.0.0.1]) by localhost (rock.gnat.com [127.0.0.1]) (amavisd-new, port 10024) with LMTP id w30rSjk8qhNK; Tue, 6 Jan 2015 04:47:55 -0500 (EST) Received: from kwai.gnat.com (kwai.gnat.com [IPv6:2620:20:4000:0:7a2b:cbff:fe60:cb11]) by rock.gnat.com (Postfix) with ESMTP id 41C5011636D; Tue, 6 Jan 2015 04:47:55 -0500 (EST) Received: by kwai.gnat.com (Postfix, from userid 4192) id 3DA4B91A7D; Tue, 6 Jan 2015 04:47:55 -0500 (EST) Date: Tue, 6 Jan 2015 04:47:55 -0500 From: Arnaud Charlet To: gcc-patches@gcc.gnu.org Cc: Pascal Obry Subject: [Ada] Rework the initialization/finalization of the runtime. Message-ID: <20150106094755.GA23348@adacore.com> MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.5.21 (2010-09-15) A new routine named __gnat_runtime_initialize is introduced to initialize the runtime and another one to finalize it. Code from __gnat_finalize have been moved to __gnat_runtime_initialize when it applies. This makes a C main calling adainit() and adafinal() as documented behave as if the main was in Ada. Tested on x86_64-pc-linux-gnu, committed on trunk 2015-01-06 Pascal Obry * adaint.c (ProcListEvt): Set to NULL. * rtinit.c: New file. (__gnat_rt_init_count): New reference counter set to 0. (__gnat_runtime_initialize): Move code here from __gnat_initialize when this code is actually needed for the runtime initialization. This routine returns immediately if the initialization has already been done. * final.c: Revert previous change. * rtfinal.c: New file. (__gnat_runtime_finalize)[Win32]: Add finalization of the critical section and event. The default version of this routine is empty (except for the reference counting code). This routine returns immediately if some others libraries are referencing the runtime. * bindgen.adb (Gen_Adainit): Generate call to Runtime_Initialize remove circuitry to initialize the signal handler as this is now done by the runtime initialization routine. (Gen_Adafinal): Generate call to Runtime_Finalize. * gnat_ugn.texi: Update documentation about concurrency and initialization/finalization of the run-time. Index: rtfinal.c =================================================================== --- rtfinal.c (revision 0) +++ rtfinal.c (revision 0) @@ -0,0 +1,89 @@ +/**************************************************************************** + * * + * GNAT COMPILER COMPONENTS * + * * + * R T F I N A L * + * * + * C Implementation File * + * * + * Copyright (C) 2014-2015, Free Software Foundation, 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 3, 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. * + * * + * As a special exception under Section 7 of GPL version 3, you are granted * + * additional permissions described in the GCC Runtime Library Exception, * + * version 3.1, as published by the Free Software Foundation. * + * * + * You should have received a copy of the GNU General Public License and * + * a copy of the GCC Runtime Library Exception along with this program; * + * see the files COPYING3 and COPYING.RUNTIME respectively. If not, see * + * . * + * * + * GNAT was originally developed by the GNAT team at New York University. * + * Extensive contributions were provided by Ada Core Technologies Inc. * + * * + ****************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +extern void __gnat_runtime_finalize (void); + +/* This routine is called at the extreme end of execution of an Ada program + (the call is generated by the binder). The standard routine does nothing + at all, the intention is that this be replaced by system specific code + where finalization is required. + + Note that __gnat_runtime_initialize() is called in adafinal() */ + +extern int __gnat_rt_init_count; +/* see initialize.c */ + +#if defined (__MINGW32__) +#include "mingw32.h" +#include + +extern CRITICAL_SECTION ProcListCS; +extern HANDLE ProcListEvt; + +void +__gnat_runtime_finalize (void) +{ + /* decrement the reference counter */ + + __gnat_rt_init_count--; + + /* if still some referenced return now */ + if (__gnat_rt_init_count > 0) + return; + + /* delete critical section and event handle used for the + processes chain list */ + DeleteCriticalSection(&ProcListCS); + CloseHandle (ProcListEvt); +} + +#else + +void +__gnat_runtime_finalize (void) +{ + /* decrement the reference counter */ + + __gnat_rt_init_count--; + + /* if still some referenced return now */ + if (__gnat_rt_init_count > 0) + return; +} +#endif + +#ifdef __cplusplus +} +#endif Index: bindgen.adb =================================================================== --- bindgen.adb (revision 219191) +++ bindgen.adb (working copy) @@ -390,6 +390,11 @@ Write_Statement_Buffer; end if; + WBI (""); + WBI (" procedure Runtime_Finalize;"); + WBI (" pragma Import (C, Runtime_Finalize, " & + """__gnat_runtime_finalize"");"); + WBI (""); WBI (" begin"); if not CodePeer_Mode then @@ -399,6 +404,8 @@ WBI (" Is_Elaborated := False;"); end if; + WBI (" Runtime_Finalize;"); + -- On non-virtual machine targets, finalization is done differently -- depending on whether this is the main program or a library. @@ -599,13 +606,9 @@ -- installation, and indication of if it's been called previously. WBI (""); - WBI (" procedure Install_Handler;"); - WBI (" pragma Import (C, Install_Handler, " & - """__gnat_install_handler"");"); - WBI (""); - WBI (" Handler_Installed : Integer;"); - WBI (" pragma Import (C, Handler_Installed, " & - """__gnat_handler_installed"");"); + WBI (" procedure Runtime_Initialize;"); + WBI (" pragma Import (C, Runtime_Initialize, " & + """__gnat_runtime_initialize"");"); -- Import handlers attach procedure for sequential elaboration policy @@ -835,13 +838,9 @@ -- In .NET, when binding with -z, we don't install the signal handler -- to let the caller handle the last exception handler. - if VM_Target /= CLI_Target - or else Bind_Main_Program - then + if Bind_Main_Program then WBI (""); - WBI (" if Handler_Installed = 0 then"); - WBI (" Install_Handler;"); - WBI (" end if;"); + WBI (" Runtime_Initialize;"); end if; end if; Index: gnat_ugn.texi =================================================================== --- gnat_ugn.texi (revision 219191) +++ gnat_ugn.texi (working copy) @@ -17544,6 +17544,13 @@ No call to these libraries or to the Ada run-time library should be made after the finalization phase. +@noindent +Note also that special care must be taken with multi-tasks +applications. The initialization and finalization routines are not +protected against concurrent access. If such requirement is needed it +must be ensured at the application level using a specific operating +system services like a mutex or a critical-section. + @node Restrictions in Stand-alone Libraries @subsection Restrictions in Stand-alone Libraries @@ -22308,12 +22315,11 @@ -- as a unit name in the partition, in which case some other unique -- name is used. +@b{pragma} Ada_95; @b{with} System; @b{package} ada_main @b{is} + @b{pragma} Warnings (Off); - Elab_Final_Code : Integer; - @b{pragma} Import (C, Elab_Final_Code, "__gnat_inside_elab_final_code"); - -- The main program saves the parameters (argument count, -- argument values, environment pointer) in global variables -- for later access by other units including @@ -22337,17 +22343,12 @@ @b{pragma} Import (C, gnat_exit_status); GNAT_Version : @b{constant} String := - "GNAT Version: 6.0.0w (20061115)"; + "GNAT Version: Pro 7.4.0w (20141119-49)" & ASCII.NUL; @b{pragma} Export (C, GNAT_Version, "__gnat_version"); - -- This is the generated adafinal routine that performs - -- finalization at the end of execution. In the case where - -- Ada is the main program, this main program makes a call - -- to adafinal at program termination. + Ada_Main_Program_Name : constant String := "_ada_hello" & ASCII.NUL; + @b{pragma} Export (C, Ada_Main_Program_Name, "__gnat_ada_main_program_name"); - @b{procedure} adafinal; - @b{pragma} Export (C, adafinal, "adafinal"); - -- This is the generated adainit routine that performs -- initialization at the start of execution. In the case -- where Ada is the main program, this main program makes @@ -22356,13 +22357,18 @@ @b{procedure} adainit; @b{pragma} Export (C, adainit, "adainit"); + -- This is the generated adafinal routine that performs + -- finalization at the end of execution. In the case where + -- Ada is the main program, this main program makes a call + -- to adafinal at program termination. + + @b{procedure} adafinal; + @b{pragma} Export (C, adafinal, "adafinal"); + -- This routine is called at the start of execution. It is -- a dummy routine that is used by the debugger to breakpoint -- at the start of execution. - @b{procedure} Break_Start; - @b{pragma} Import (C, Break_Start, "__gnat_break_start"); - -- This is the actual generated main program (it would be -- suppressed if the no main program switch were used). As -- required by standard system conventions, this program has @@ -22382,191 +22388,300 @@ -- string that would be returned by use of the -- Body_Version or Version attributes. - @b{type} Version_32 @b{is} @b{mod} 2 ** 32; - u00001 : @b{constant} Version_32 := 16#7880BEB3#; - u00002 : @b{constant} Version_32 := 16#0D24CBD0#; - u00003 : @b{constant} Version_32 := 16#3283DBEB#; - u00004 : @b{constant} Version_32 := 16#2359F9ED#; - u00005 : @b{constant} Version_32 := 16#664FB847#; - u00006 : @b{constant} Version_32 := 16#68E803DF#; - u00007 : @b{constant} Version_32 := 16#5572E604#; - u00008 : @b{constant} Version_32 := 16#46B173D8#; - u00009 : @b{constant} Version_32 := 16#156A40CF#; - u00010 : @b{constant} Version_32 := 16#033DABE0#; - u00011 : @b{constant} Version_32 := 16#6AB38FEA#; - u00012 : @b{constant} Version_32 := 16#22B6217D#; - u00013 : @b{constant} Version_32 := 16#68A22947#; - u00014 : @b{constant} Version_32 := 16#18CC4A56#; - u00015 : @b{constant} Version_32 := 16#08258E1B#; - u00016 : @b{constant} Version_32 := 16#367D5222#; - u00017 : @b{constant} Version_32 := 16#20C9ECA4#; - u00018 : @b{constant} Version_32 := 16#50D32CB6#; - u00019 : @b{constant} Version_32 := 16#39A8BB77#; - u00020 : @b{constant} Version_32 := 16#5CF8FA2B#; - u00021 : @b{constant} Version_32 := 16#2F1EB794#; - u00022 : @b{constant} Version_32 := 16#31AB6444#; - u00023 : @b{constant} Version_32 := 16#1574B6E9#; - u00024 : @b{constant} Version_32 := 16#5109C189#; - u00025 : @b{constant} Version_32 := 16#56D770CD#; - u00026 : @b{constant} Version_32 := 16#02F9DE3D#; - u00027 : @b{constant} Version_32 := 16#08AB6B2C#; - u00028 : @b{constant} Version_32 := 16#3FA37670#; - u00029 : @b{constant} Version_32 := 16#476457A0#; - u00030 : @b{constant} Version_32 := 16#731E1B6E#; - u00031 : @b{constant} Version_32 := 16#23C2E789#; - u00032 : @b{constant} Version_32 := 16#0F1BD6A1#; - u00033 : @b{constant} Version_32 := 16#7C25DE96#; - u00034 : @b{constant} Version_32 := 16#39ADFFA2#; - u00035 : @b{constant} Version_32 := 16#571DE3E7#; - u00036 : @b{constant} Version_32 := 16#5EB646AB#; - u00037 : @b{constant} Version_32 := 16#4249379B#; - u00038 : @b{constant} Version_32 := 16#0357E00A#; - u00039 : @b{constant} Version_32 := 16#3784FB72#; - u00040 : @b{constant} Version_32 := 16#2E723019#; - u00041 : @b{constant} Version_32 := 16#623358EA#; - u00042 : @b{constant} Version_32 := 16#107F9465#; - u00043 : @b{constant} Version_32 := 16#6843F68A#; - u00044 : @b{constant} Version_32 := 16#63305874#; - u00045 : @b{constant} Version_32 := 16#31E56CE1#; - u00046 : @b{constant} Version_32 := 16#02917970#; - u00047 : @b{constant} Version_32 := 16#6CCBA70E#; - u00048 : @b{constant} Version_32 := 16#41CD4204#; - u00049 : @b{constant} Version_32 := 16#572E3F58#; - u00050 : @b{constant} Version_32 := 16#20729FF5#; - u00051 : @b{constant} Version_32 := 16#1D4F93E8#; - u00052 : @b{constant} Version_32 := 16#30B2EC3D#; - u00053 : @b{constant} Version_32 := 16#34054F96#; - u00054 : @b{constant} Version_32 := 16#5A199860#; - u00055 : @b{constant} Version_32 := 16#0E7F912B#; - u00056 : @b{constant} Version_32 := 16#5760634A#; - u00057 : @b{constant} Version_32 := 16#5D851835#; - -- The following Export pragmas export the version numbers -- with symbolic names ending in B (for body) or S -- (for spec) so that they can be located in a link. The -- information provided here is sufficient to track down -- the exact versions of units used in a given build. + + @b{type} Version_32 @b{is} @b{mod} 2 ** 32; + u00001 : @b{constant} Version_32 := 16#8ad6e54a#; @b{pragma} Export (C, u00001, "helloB"); + u00002 : @b{constant} Version_32 := 16#fbff4c67#; @b{pragma} Export (C, u00002, "system__standard_libraryB"); + u00003 : @b{constant} Version_32 := 16#1ec6fd90#; @b{pragma} Export (C, u00003, "system__standard_libraryS"); + u00004 : @b{constant} Version_32 := 16#3ffc8e18#; @b{pragma} Export (C, u00004, "adaS"); + u00005 : @b{constant} Version_32 := 16#28f088c2#; @b{pragma} Export (C, u00005, "ada__text_ioB"); + u00006 : @b{constant} Version_32 := 16#f372c8ac#; @b{pragma} Export (C, u00006, "ada__text_ioS"); + u00007 : @b{constant} Version_32 := 16#2c143749#; @b{pragma} Export (C, u00007, "ada__exceptionsB"); + u00008 : @b{constant} Version_32 := 16#f4f0cce8#; @b{pragma} Export (C, u00008, "ada__exceptionsS"); - @b{pragma} Export (C, u00009, "gnatS"); - @b{pragma} Export (C, u00010, "gnat__heap_sort_aB"); - @b{pragma} Export (C, u00011, "gnat__heap_sort_aS"); - @b{pragma} Export (C, u00012, "systemS"); - @b{pragma} Export (C, u00013, "system__exception_tableB"); - @b{pragma} Export (C, u00014, "system__exception_tableS"); - @b{pragma} Export (C, u00015, "gnat__htableB"); - @b{pragma} Export (C, u00016, "gnat__htableS"); - @b{pragma} Export (C, u00017, "system__exceptionsS"); - @b{pragma} Export (C, u00018, "system__machine_state_operationsB"); - @b{pragma} Export (C, u00019, "system__machine_state_operationsS"); - @b{pragma} Export (C, u00020, "system__machine_codeS"); - @b{pragma} Export (C, u00021, "system__storage_elementsB"); - @b{pragma} Export (C, u00022, "system__storage_elementsS"); - @b{pragma} Export (C, u00023, "system__secondary_stackB"); - @b{pragma} Export (C, u00024, "system__secondary_stackS"); - @b{pragma} Export (C, u00025, "system__parametersB"); - @b{pragma} Export (C, u00026, "system__parametersS"); - @b{pragma} Export (C, u00027, "system__soft_linksB"); - @b{pragma} Export (C, u00028, "system__soft_linksS"); - @b{pragma} Export (C, u00029, "system__stack_checkingB"); - @b{pragma} Export (C, u00030, "system__stack_checkingS"); + u00009 : @b{constant} Version_32 := 16#a46739c0#; + @b{pragma} Export (C, u00009, "ada__exceptions__last_chance_handlerB"); + u00010 : @b{constant} Version_32 := 16#3aac8c92#; + @b{pragma} Export (C, u00010, "ada__exceptions__last_chance_handlerS"); + u00011 : @b{constant} Version_32 := 16#1d274481#; + @b{pragma} Export (C, u00011, "systemS"); + u00012 : @b{constant} Version_32 := 16#a207fefe#; + @b{pragma} Export (C, u00012, "system__soft_linksB"); + u00013 : @b{constant} Version_32 := 16#467d9556#; + @b{pragma} Export (C, u00013, "system__soft_linksS"); + u00014 : @b{constant} Version_32 := 16#b01dad17#; + @b{pragma} Export (C, u00014, "system__parametersB"); + u00015 : @b{constant} Version_32 := 16#630d49fe#; + @b{pragma} Export (C, u00015, "system__parametersS"); + u00016 : @b{constant} Version_32 := 16#b19b6653#; + @b{pragma} Export (C, u00016, "system__secondary_stackB"); + u00017 : @b{constant} Version_32 := 16#b6468be8#; + @b{pragma} Export (C, u00017, "system__secondary_stackS"); + u00018 : @b{constant} Version_32 := 16#39a03df9#; + @b{pragma} Export (C, u00018, "system__storage_elementsB"); + u00019 : @b{constant} Version_32 := 16#30e40e85#; + @b{pragma} Export (C, u00019, "system__storage_elementsS"); + u00020 : @b{constant} Version_32 := 16#41837d1e#; + @b{pragma} Export (C, u00020, "system__stack_checkingB"); + u00021 : @b{constant} Version_32 := 16#93982f69#; + @b{pragma} Export (C, u00021, "system__stack_checkingS"); + u00022 : @b{constant} Version_32 := 16#393398c1#; + @b{pragma} Export (C, u00022, "system__exception_tableB"); + u00023 : @b{constant} Version_32 := 16#b33e2294#; + @b{pragma} Export (C, u00023, "system__exception_tableS"); + u00024 : @b{constant} Version_32 := 16#ce4af020#; + @b{pragma} Export (C, u00024, "system__exceptionsB"); + u00025 : @b{constant} Version_32 := 16#75442977#; + @b{pragma} Export (C, u00025, "system__exceptionsS"); + u00026 : @b{constant} Version_32 := 16#37d758f1#; + @b{pragma} Export (C, u00026, "system__exceptions__machineS"); + u00027 : @b{constant} Version_32 := 16#b895431d#; + @b{pragma} Export (C, u00027, "system__exceptions_debugB"); + u00028 : @b{constant} Version_32 := 16#aec55d3f#; + @b{pragma} Export (C, u00028, "system__exceptions_debugS"); + u00029 : @b{constant} Version_32 := 16#570325c8#; + @b{pragma} Export (C, u00029, "system__img_intB"); + u00030 : @b{constant} Version_32 := 16#1ffca443#; + @b{pragma} Export (C, u00030, "system__img_intS"); + u00031 : @b{constant} Version_32 := 16#b98c3e16#; @b{pragma} Export (C, u00031, "system__tracebackB"); + u00032 : @b{constant} Version_32 := 16#831a9d5a#; @b{pragma} Export (C, u00032, "system__tracebackS"); - @b{pragma} Export (C, u00033, "ada__streamsS"); - @b{pragma} Export (C, u00034, "ada__tagsB"); - @b{pragma} Export (C, u00035, "ada__tagsS"); - @b{pragma} Export (C, u00036, "system__string_opsB"); - @b{pragma} Export (C, u00037, "system__string_opsS"); - @b{pragma} Export (C, u00038, "interfacesS"); - @b{pragma} Export (C, u00039, "interfaces__c_streamsB"); - @b{pragma} Export (C, u00040, "interfaces__c_streamsS"); - @b{pragma} Export (C, u00041, "system__file_ioB"); - @b{pragma} Export (C, u00042, "system__file_ioS"); - @b{pragma} Export (C, u00043, "ada__finalizationB"); - @b{pragma} Export (C, u00044, "ada__finalizationS"); - @b{pragma} Export (C, u00045, "system__finalization_rootB"); - @b{pragma} Export (C, u00046, "system__finalization_rootS"); - @b{pragma} Export (C, u00047, "system__finalization_implementationB"); - @b{pragma} Export (C, u00048, "system__finalization_implementationS"); - @b{pragma} Export (C, u00049, "system__string_ops_concat_3B"); - @b{pragma} Export (C, u00050, "system__string_ops_concat_3S"); - @b{pragma} Export (C, u00051, "system__stream_attributesB"); - @b{pragma} Export (C, u00052, "system__stream_attributesS"); - @b{pragma} Export (C, u00053, "ada__io_exceptionsS"); - @b{pragma} Export (C, u00054, "system__unsigned_typesS"); - @b{pragma} Export (C, u00055, "system__file_control_blockS"); - @b{pragma} Export (C, u00056, "ada__finalization__list_controllerB"); - @b{pragma} Export (C, u00057, "ada__finalization__list_controllerS"); + u00033 : @b{constant} Version_32 := 16#9ed49525#; + @b{pragma} Export (C, u00033, "system__traceback_entriesB"); + u00034 : @b{constant} Version_32 := 16#1d7cb2f1#; + @b{pragma} Export (C, u00034, "system__traceback_entriesS"); + u00035 : @b{constant} Version_32 := 16#8c33a517#; + @b{pragma} Export (C, u00035, "system__wch_conB"); + u00036 : @b{constant} Version_32 := 16#065a6653#; + @b{pragma} Export (C, u00036, "system__wch_conS"); + u00037 : @b{constant} Version_32 := 16#9721e840#; + @b{pragma} Export (C, u00037, "system__wch_stwB"); + u00038 : @b{constant} Version_32 := 16#2b4b4a52#; + @b{pragma} Export (C, u00038, "system__wch_stwS"); + u00039 : @b{constant} Version_32 := 16#92b797cb#; + @b{pragma} Export (C, u00039, "system__wch_cnvB"); + u00040 : @b{constant} Version_32 := 16#09eddca0#; + @b{pragma} Export (C, u00040, "system__wch_cnvS"); + u00041 : @b{constant} Version_32 := 16#6033a23f#; + @b{pragma} Export (C, u00041, "interfacesS"); + u00042 : @b{constant} Version_32 := 16#ece6fdb6#; + @b{pragma} Export (C, u00042, "system__wch_jisB"); + u00043 : @b{constant} Version_32 := 16#899dc581#; + @b{pragma} Export (C, u00043, "system__wch_jisS"); + u00044 : @b{constant} Version_32 := 16#10558b11#; + @b{pragma} Export (C, u00044, "ada__streamsB"); + u00045 : @b{constant} Version_32 := 16#2e6701ab#; + @b{pragma} Export (C, u00045, "ada__streamsS"); + u00046 : @b{constant} Version_32 := 16#db5c917c#; + @b{pragma} Export (C, u00046, "ada__io_exceptionsS"); + u00047 : @b{constant} Version_32 := 16#12c8cd7d#; + @b{pragma} Export (C, u00047, "ada__tagsB"); + u00048 : @b{constant} Version_32 := 16#ce72c228#; + @b{pragma} Export (C, u00048, "ada__tagsS"); + u00049 : @b{constant} Version_32 := 16#c3335bfd#; + @b{pragma} Export (C, u00049, "system__htableB"); + u00050 : @b{constant} Version_32 := 16#99e5f76b#; + @b{pragma} Export (C, u00050, "system__htableS"); + u00051 : @b{constant} Version_32 := 16#089f5cd0#; + @b{pragma} Export (C, u00051, "system__string_hashB"); + u00052 : @b{constant} Version_32 := 16#3bbb9c15#; + @b{pragma} Export (C, u00052, "system__string_hashS"); + u00053 : @b{constant} Version_32 := 16#807fe041#; + @b{pragma} Export (C, u00053, "system__unsigned_typesS"); + u00054 : @b{constant} Version_32 := 16#d27be59e#; + @b{pragma} Export (C, u00054, "system__val_lluB"); + u00055 : @b{constant} Version_32 := 16#fa8db733#; + @b{pragma} Export (C, u00055, "system__val_lluS"); + u00056 : @b{constant} Version_32 := 16#27b600b2#; + @b{pragma} Export (C, u00056, "system__val_utilB"); + u00057 : @b{constant} Version_32 := 16#b187f27f#; + @b{pragma} Export (C, u00057, "system__val_utilS"); + u00058 : @b{constant} Version_32 := 16#d1060688#; + @b{pragma} Export (C, u00058, "system__case_utilB"); + u00059 : @b{constant} Version_32 := 16#392e2d56#; + @b{pragma} Export (C, u00059, "system__case_utilS"); + u00060 : @b{constant} Version_32 := 16#84a27f0d#; + @b{pragma} Export (C, u00060, "interfaces__c_streamsB"); + u00061 : @b{constant} Version_32 := 16#8bb5f2c0#; + @b{pragma} Export (C, u00061, "interfaces__c_streamsS"); + u00062 : @b{constant} Version_32 := 16#6db6928f#; + @b{pragma} Export (C, u00062, "system__crtlS"); + u00063 : @b{constant} Version_32 := 16#4e6a342b#; + @b{pragma} Export (C, u00063, "system__file_ioB"); + u00064 : @b{constant} Version_32 := 16#ba56a5e4#; + @b{pragma} Export (C, u00064, "system__file_ioS"); + u00065 : @b{constant} Version_32 := 16#b7ab275c#; + @b{pragma} Export (C, u00065, "ada__finalizationB"); + u00066 : @b{constant} Version_32 := 16#19f764ca#; + @b{pragma} Export (C, u00066, "ada__finalizationS"); + u00067 : @b{constant} Version_32 := 16#95817ed8#; + @b{pragma} Export (C, u00067, "system__finalization_rootB"); + u00068 : @b{constant} Version_32 := 16#52d53711#; + @b{pragma} Export (C, u00068, "system__finalization_rootS"); + u00069 : @b{constant} Version_32 := 16#769e25e6#; + @b{pragma} Export (C, u00069, "interfaces__cB"); + u00070 : @b{constant} Version_32 := 16#4a38bedb#; + @b{pragma} Export (C, u00070, "interfaces__cS"); + u00071 : @b{constant} Version_32 := 16#07e6ee66#; + @b{pragma} Export (C, u00071, "system__os_libB"); + u00072 : @b{constant} Version_32 := 16#d7b69782#; + @b{pragma} Export (C, u00072, "system__os_libS"); + u00073 : @b{constant} Version_32 := 16#1a817b8e#; + @b{pragma} Export (C, u00073, "system__stringsB"); + u00074 : @b{constant} Version_32 := 16#639855e7#; + @b{pragma} Export (C, u00074, "system__stringsS"); + u00075 : @b{constant} Version_32 := 16#e0b8de29#; + @b{pragma} Export (C, u00075, "system__file_control_blockS"); + u00076 : @b{constant} Version_32 := 16#b5b2aca1#; + @b{pragma} Export (C, u00076, "system__finalization_mastersB"); + u00077 : @b{constant} Version_32 := 16#69316dc1#; + @b{pragma} Export (C, u00077, "system__finalization_mastersS"); + u00078 : @b{constant} Version_32 := 16#57a37a42#; + @b{pragma} Export (C, u00078, "system__address_imageB"); + u00079 : @b{constant} Version_32 := 16#bccbd9bb#; + @b{pragma} Export (C, u00079, "system__address_imageS"); + u00080 : @b{constant} Version_32 := 16#7268f812#; + @b{pragma} Export (C, u00080, "system__img_boolB"); + u00081 : @b{constant} Version_32 := 16#e8fe356a#; + @b{pragma} Export (C, u00081, "system__img_boolS"); + u00082 : @b{constant} Version_32 := 16#d7aac20c#; + @b{pragma} Export (C, u00082, "system__ioB"); + u00083 : @b{constant} Version_32 := 16#8365b3ce#; + @b{pragma} Export (C, u00083, "system__ioS"); + u00084 : @b{constant} Version_32 := 16#6d4d969a#; + @b{pragma} Export (C, u00084, "system__storage_poolsB"); + u00085 : @b{constant} Version_32 := 16#e87cc305#; + @b{pragma} Export (C, u00085, "system__storage_poolsS"); + u00086 : @b{constant} Version_32 := 16#e34550ca#; + @b{pragma} Export (C, u00086, "system__pool_globalB"); + u00087 : @b{constant} Version_32 := 16#c88d2d16#; + @b{pragma} Export (C, u00087, "system__pool_globalS"); + u00088 : @b{constant} Version_32 := 16#9d39c675#; + @b{pragma} Export (C, u00088, "system__memoryB"); + u00089 : @b{constant} Version_32 := 16#445a22b5#; + @b{pragma} Export (C, u00089, "system__memoryS"); + u00090 : @b{constant} Version_32 := 16#6a859064#; + @b{pragma} Export (C, u00090, "system__storage_pools__subpoolsB"); + u00091 : @b{constant} Version_32 := 16#e3b008dc#; + @b{pragma} Export (C, u00091, "system__storage_pools__subpoolsS"); + u00092 : @b{constant} Version_32 := 16#63f11652#; + @b{pragma} Export (C, u00092, "system__storage_pools__subpools__finalizationB"); + u00093 : @b{constant} Version_32 := 16#fe2f4b3a#; + @b{pragma} Export (C, u00093, "system__storage_pools__subpools__finalizationS"); - -- BEGIN ELABORATION ORDER - -- ada (spec) - -- gnat (spec) - -- gnat.heap_sort_a (spec) - -- gnat.heap_sort_a (body) - -- gnat.htable (spec) - -- gnat.htable (body) - -- interfaces (spec) - -- system (spec) - -- system.machine_code (spec) - -- system.parameters (spec) - -- system.parameters (body) - -- interfaces.c_streams (spec) - -- interfaces.c_streams (body) - -- system.standard_library (spec) - -- ada.exceptions (spec) - -- system.exception_table (spec) - -- system.exception_table (body) - -- ada.io_exceptions (spec) - -- system.exceptions (spec) - -- system.storage_elements (spec) - -- system.storage_elements (body) - -- system.machine_state_operations (spec) - -- system.machine_state_operations (body) - -- system.secondary_stack (spec) - -- system.stack_checking (spec) - -- system.soft_links (spec) - -- system.soft_links (body) - -- system.stack_checking (body) - -- system.secondary_stack (body) - -- system.standard_library (body) - -- system.string_ops (spec) - -- system.string_ops (body) - -- ada.tags (spec) - -- ada.tags (body) - -- ada.streams (spec) - -- system.finalization_root (spec) - -- system.finalization_root (body) - -- system.string_ops_concat_3 (spec) - -- system.string_ops_concat_3 (body) - -- system.traceback (spec) - -- system.traceback (body) - -- ada.exceptions (body) - -- system.unsigned_types (spec) - -- system.stream_attributes (spec) - -- system.stream_attributes (body) - -- system.finalization_implementation (spec) - -- system.finalization_implementation (body) - -- ada.finalization (spec) - -- ada.finalization (body) - -- ada.finalization.list_controller (spec) - -- ada.finalization.list_controller (body) - -- system.file_control_block (spec) - -- system.file_io (spec) - -- system.file_io (body) - -- ada.text_io (spec) - -- ada.text_io (body) - -- hello (body) - -- END ELABORATION ORDER + -- BEGIN ELABORATION ORDER + -- ada%s + -- interfaces%s + -- system%s + -- system.case_util%s + -- system.case_util%b + -- system.htable%s + -- system.img_bool%s + -- system.img_bool%b + -- system.img_int%s + -- system.img_int%b + -- system.io%s + -- system.io%b + -- system.parameters%s + -- system.parameters%b + -- system.crtl%s + -- interfaces.c_streams%s + -- interfaces.c_streams%b + -- system.standard_library%s + -- system.exceptions_debug%s + -- system.exceptions_debug%b + -- system.storage_elements%s + -- system.storage_elements%b + -- system.stack_checking%s + -- system.stack_checking%b + -- system.string_hash%s + -- system.string_hash%b + -- system.htable%b + -- system.strings%s + -- system.strings%b + -- system.os_lib%s + -- system.traceback_entries%s + -- system.traceback_entries%b + -- ada.exceptions%s + -- system.soft_links%s + -- system.unsigned_types%s + -- system.val_llu%s + -- system.val_util%s + -- system.val_util%b + -- system.val_llu%b + -- system.wch_con%s + -- system.wch_con%b + -- system.wch_cnv%s + -- system.wch_jis%s + -- system.wch_jis%b + -- system.wch_cnv%b + -- system.wch_stw%s + -- system.wch_stw%b + -- ada.exceptions.last_chance_handler%s + -- ada.exceptions.last_chance_handler%b + -- system.address_image%s + -- system.exception_table%s + -- system.exception_table%b + -- ada.io_exceptions%s + -- ada.tags%s + -- ada.streams%s + -- ada.streams%b + -- interfaces.c%s + -- system.exceptions%s + -- system.exceptions%b + -- system.exceptions.machine%s + -- system.finalization_root%s + -- system.finalization_root%b + -- ada.finalization%s + -- ada.finalization%b + -- system.storage_pools%s + -- system.storage_pools%b + -- system.finalization_masters%s + -- system.storage_pools.subpools%s + -- system.storage_pools.subpools.finalization%s + -- system.storage_pools.subpools.finalization%b + -- system.memory%s + -- system.memory%b + -- system.standard_library%b + -- system.pool_global%s + -- system.pool_global%b + -- system.file_control_block%s + -- system.file_io%s + -- system.secondary_stack%s + -- system.file_io%b + -- system.storage_pools.subpools%b + -- system.finalization_masters%b + -- interfaces.c%b + -- ada.tags%b + -- system.soft_links%b + -- system.os_lib%b + -- system.secondary_stack%b + -- system.address_image%b + -- system.traceback%s + -- ada.exceptions%b + -- system.traceback%b + -- ada.text_io%s + -- ada.text_io%b + -- hello%b + -- END ELABORATION ORDER @b{end} ada_main; +@b{pragma} Ada_95; -- The following source file name pragmas allow the generated file -- names to be unique for different main programs. They are needed -- since the package name will always be Ada_Main. @@ -22574,16 +22689,95 @@ @b{pragma} Source_File_Name (ada_main, Spec_File_Name => "b~hello.ads"); @b{pragma} Source_File_Name (ada_main, Body_File_Name => "b~hello.adb"); +@b{pragma} Suppress (Overflow_Check); +@b{with} Ada.Exceptions; + -- Generated package body for Ada_Main starts here @b{package} @b{body} ada_main @b{is} + @b{pragma} Warnings (Off); - -- The actual finalization is performed by calling the - -- library routine in System.Standard_Library.Adafinal + -- These values are reference counter associated to units which have + -- been elaborated. It is also used to avoid elaborating the + -- same unit twice. - @b{procedure} Do_Finalize; - @b{pragma} Import (C, Do_Finalize, "system__standard_library__adafinal"); + E72 : Short_Integer; @b{pragma} Import (Ada, E72, "system__os_lib_E"); + E13 : Short_Integer; @b{pragma} Import (Ada, E13, "system__soft_links_E"); + E23 : Short_Integer; @b{pragma} Import (Ada, E23, "system__exception_table_E"); + E46 : Short_Integer; @b{pragma} Import (Ada, E46, "ada__io_exceptions_E"); + E48 : Short_Integer; @b{pragma} Import (Ada, E48, "ada__tags_E"); + E45 : Short_Integer; @b{pragma} Import (Ada, E45, "ada__streams_E"); + E70 : Short_Integer; @b{pragma} Import (Ada, E70, "interfaces__c_E"); + E25 : Short_Integer; @b{pragma} Import (Ada, E25, "system__exceptions_E"); + E68 : Short_Integer; @b{pragma} Import (Ada, E68, "system__finalization_root_E"); + E66 : Short_Integer; @b{pragma} Import (Ada, E66, "ada__finalization_E"); + E85 : Short_Integer; @b{pragma} Import (Ada, E85, "system__storage_pools_E"); + E77 : Short_Integer; @b{pragma} Import (Ada, E77, "system__finalization_masters_E"); + E91 : Short_Integer; @b{pragma} Import (Ada, E91, "system__storage_pools__subpools_E"); + E87 : Short_Integer; @b{pragma} Import (Ada, E87, "system__pool_global_E"); + E75 : Short_Integer; @b{pragma} Import (Ada, E75, "system__file_control_block_E"); + E64 : Short_Integer; @b{pragma} Import (Ada, E64, "system__file_io_E"); + E17 : Short_Integer; @b{pragma} Import (Ada, E17, "system__secondary_stack_E"); + E06 : Short_Integer; @b{pragma} Import (Ada, E06, "ada__text_io_E"); + Local_Priority_Specific_Dispatching : @b{constant} String := ""; + Local_Interrupt_States : @b{constant} String := ""; + + Is_Elaborated : Boolean := False; + +@findex finalize_library + @b{procedure} finalize_library @b{is} + @b{begin} + E06 := E06 - 1; + @b{declare} + @b{procedure} F1; + @b{pragma} Import (Ada, F1, "ada__text_io__finalize_spec"); + @b{begin} + F1; + @b{end}; + E77 := E77 - 1; + E91 := E91 - 1; + @b{declare} + @b{procedure} F2; + @b{pragma} Import (Ada, F2, "system__file_io__finalize_body"); + @b{begin} + E64 := E64 - 1; + F2; + @b{end}; + @b{declare} + @b{procedure} F3; + @b{pragma} Import (Ada, F3, "system__file_control_block__finalize_spec"); + @b{begin} + E75 := E75 - 1; + F3; + @b{end}; + E87 := E87 - 1; + @b{declare} + @b{procedure} F4; + @b{pragma} Import (Ada, F4, "system__pool_global__finalize_spec"); + @b{begin} + F4; + @b{end}; + @b{declare} + @b{procedure} F5; + @b{pragma} Import (Ada, F5, "system__storage_pools__subpools__finalize_spec"); + @b{begin} + F5; + @b{end}; + @b{declare} + @b{procedure} F6; + @b{pragma} Import (Ada, F6, "system__finalization_masters__finalize_spec"); + @b{begin} + F6; + @b{end}; + @b{declare} + @b{procedure} Reraise_Library_Exception_If_Any; + @b{pragma} Import (Ada, Reraise_Library_Exception_If_Any, "__gnat_reraise_library_exception_if_any"); + @b{begin} + Reraise_Library_Exception_If_Any; + @b{end}; + @b{end} finalize_library; + ------------- -- adainit -- ------------- @@ -22591,290 +22785,122 @@ @findex adainit @b{procedure} adainit @b{is} - -- These booleans are set to True once the associated unit has - -- been elaborated. It is also used to avoid elaborating the - -- same unit twice. + Main_Priority : Integer; + @b{pragma} Import (C, Main_Priority, "__gl_main_priority"); + Time_Slice_Value : Integer; + @b{pragma} Import (C, Time_Slice_Value, "__gl_time_slice_val"); + WC_Encoding : Character; + @b{pragma} Import (C, WC_Encoding, "__gl_wc_encoding"); + Locking_Policy : Character; + pragma Import (C, Locking_Policy, "__gl_locking_policy"); + Queuing_Policy : Character; + @b{pragma} Import (C, Queuing_Policy, "__gl_queuing_policy"); + Task_Dispatching_Policy : Character; + @b{pragma} Import (C, Task_Dispatching_Policy, "__gl_task_dispatching_policy"); + Priority_Specific_Dispatching : System.Address; + @b{pragma} Import (C, Priority_Specific_Dispatching, "__gl_priority_specific_dispatching"); + Num_Specific_Dispatching : Integer; + @b{pragma} Import (C, Num_Specific_Dispatching, "__gl_num_specific_dispatching"); + Main_CPU : Integer; + @b{pragma} Import (C, Main_CPU, "__gl_main_cpu"); + Interrupt_States : System.Address; + @b{pragma} Import (C, Interrupt_States, "__gl_interrupt_states"); + Num_Interrupt_States : Integer; + @b{pragma} Import (C, Num_Interrupt_States, "__gl_num_interrupt_states"); + Unreserve_All_Interrupts : Integer; + @b{pragma} Import (C, Unreserve_All_Interrupts, "__gl_unreserve_all_interrupts"); + Detect_Blocking : Integer; + @b{pragma} Import (C, Detect_Blocking, "__gl_detect_blocking"); + Default_Stack_Size : Integer; + @b{pragma} Import (C, Default_Stack_Size, "__gl_default_stack_size"); + Leap_Seconds_Support : Integer; + @b{pragma} Import (C, Leap_Seconds_Support, "__gl_leap_seconds_support"); - E040 : Boolean; - @b{pragma} Import (Ada, E040, "interfaces__c_streams_E"); + procedure Runtime_Initialize; + @b{pragma} Import (C, Runtime_Initialize, "__gnat_runtime_initialize"); - E008 : Boolean; - @b{pragma} Import (Ada, E008, "ada__exceptions_E"); + Finalize_Library_Objects : No_Param_Proc; + @b{pragma} Import (C, Finalize_Library_Objects, "__gnat_finalize_library_objects"); - E014 : Boolean; - @b{pragma} Import (Ada, E014, "system__exception_table_E"); - - E053 : Boolean; - @b{pragma} Import (Ada, E053, "ada__io_exceptions_E"); - - E017 : Boolean; - @b{pragma} Import (Ada, E017, "system__exceptions_E"); - - E024 : Boolean; - @b{pragma} Import (Ada, E024, "system__secondary_stack_E"); - - E030 : Boolean; - @b{pragma} Import (Ada, E030, "system__stack_checking_E"); - - E028 : Boolean; - @b{pragma} Import (Ada, E028, "system__soft_links_E"); - - E035 : Boolean; - @b{pragma} Import (Ada, E035, "ada__tags_E"); - - E033 : Boolean; - @b{pragma} Import (Ada, E033, "ada__streams_E"); - - E046 : Boolean; - @b{pragma} Import (Ada, E046, "system__finalization_root_E"); - - E048 : Boolean; - @b{pragma} Import (Ada, E048, "system__finalization_implementation_E"); - - E044 : Boolean; - @b{pragma} Import (Ada, E044, "ada__finalization_E"); - - E057 : Boolean; - @b{pragma} Import (Ada, E057, "ada__finalization__list_controller_E"); - - E055 : Boolean; - @b{pragma} Import (Ada, E055, "system__file_control_block_E"); - - E042 : Boolean; - @b{pragma} Import (Ada, E042, "system__file_io_E"); - - E006 : Boolean; - @b{pragma} Import (Ada, E006, "ada__text_io_E"); - - -- Set_Globals is a library routine that stores away the - -- value of the indicated set of global values in global - -- variables within the library. - - @b{procedure} Set_Globals - (Main_Priority : Integer; - Time_Slice_Value : Integer; - WC_Encoding : Character; - Locking_Policy : Character; - Queuing_Policy : Character; - Task_Dispatching_Policy : Character; - Adafinal : System.Address; - Unreserve_All_Interrupts : Integer; - Exception_Tracebacks : Integer); -@findex __gnat_set_globals - @b{pragma} Import (C, Set_Globals, "__gnat_set_globals"); - - -- SDP_Table_Build is a library routine used to build the - -- exception tables. See unit Ada.Exceptions in files - -- a-except.ads/adb for full details of how zero cost - -- exception handling works. This procedure, the call to - -- it, and the two following tables are all omitted if the - -- build is in longjmp/setjmp exception mode. - -@findex SDP_Table_Build -@findex Zero Cost Exceptions - @b{procedure} SDP_Table_Build - (SDP_Addresses : System.Address; - SDP_Count : Natural; - Elab_Addresses : System.Address; - Elab_Addr_Count : Natural); - @b{pragma} Import (C, SDP_Table_Build, "__gnat_SDP_Table_Build"); - - -- Table of Unit_Exception_Table addresses. Used for zero - -- cost exception handling to build the top level table. - - ST : @b{aliased} @b{constant} @b{array} (1 .. 23) @b{of} System.Address := ( - Hello'UET_Address, - Ada.Text_Io'UET_Address, - Ada.Exceptions'UET_Address, - Gnat.Heap_Sort_A'UET_Address, - System.Exception_Table'UET_Address, - System.Machine_State_Operations'UET_Address, - System.Secondary_Stack'UET_Address, - System.Parameters'UET_Address, - System.Soft_Links'UET_Address, - System.Stack_Checking'UET_Address, - System.Traceback'UET_Address, - Ada.Streams'UET_Address, - Ada.Tags'UET_Address, - System.String_Ops'UET_Address, - Interfaces.C_Streams'UET_Address, - System.File_Io'UET_Address, - Ada.Finalization'UET_Address, - System.Finalization_Root'UET_Address, - System.Finalization_Implementation'UET_Address, - System.String_Ops_Concat_3'UET_Address, - System.Stream_Attributes'UET_Address, - System.File_Control_Block'UET_Address, - Ada.Finalization.List_Controller'UET_Address); - - -- Table of addresses of elaboration routines. Used for - -- zero cost exception handling to make sure these - -- addresses are included in the top level procedure - -- address table. - - EA : @b{aliased} @b{constant} @b{array} (1 .. 23) @b{of} System.Address := ( - adainit'Code_Address, - Do_Finalize'Code_Address, - Ada.Exceptions'Elab_Spec'Address, - System.Exceptions'Elab_Spec'Address, - Interfaces.C_Streams'Elab_Spec'Address, - System.Exception_Table'Elab_Body'Address, - Ada.Io_Exceptions'Elab_Spec'Address, - System.Stack_Checking'Elab_Spec'Address, - System.Soft_Links'Elab_Body'Address, - System.Secondary_Stack'Elab_Body'Address, - Ada.Tags'Elab_Spec'Address, - Ada.Tags'Elab_Body'Address, - Ada.Streams'Elab_Spec'Address, - System.Finalization_Root'Elab_Spec'Address, - Ada.Exceptions'Elab_Body'Address, - System.Finalization_Implementation'Elab_Spec'Address, - System.Finalization_Implementation'Elab_Body'Address, - Ada.Finalization'Elab_Spec'Address, - Ada.Finalization.List_Controller'Elab_Spec'Address, - System.File_Control_Block'Elab_Spec'Address, - System.File_Io'Elab_Body'Address, - Ada.Text_Io'Elab_Spec'Address, - Ada.Text_Io'Elab_Body'Address); - -- Start of processing for adainit @b{begin} - -- Call SDP_Table_Build to build the top level procedure - -- table for zero cost exception handling (omitted in - -- longjmp/setjmp mode). + -- Record various information for this partition. The values + -- are derived by the binder from information stored in the ali + -- files by the compiler. - SDP_Table_Build (ST'Address, 23, EA'Address, 23); + @b{if} Is_Elaborated @b{then} + @b{return}; + @b{end if}; + Is_Elaborated := True; + Main_Priority := -1; + Time_Slice_Value := -1; + WC_Encoding := 'b'; + Locking_Policy := ' '; + Queuing_Policy := ' '; + Task_Dispatching_Policy := ' '; + Priority_Specific_Dispatching := + Local_Priority_Specific_Dispatching'Address; + Num_Specific_Dispatching := 0; + Main_CPU := -1; + Interrupt_States := Local_Interrupt_States'Address; + Num_Interrupt_States := 0; + Unreserve_All_Interrupts := 0; + Detect_Blocking := 0; + Default_Stack_Size := -1; + Leap_Seconds_Support := 0; - -- Call Set_Globals to record various information for - -- this partition. The values are derived by the binder - -- from information stored in the ali files by the compiler. + Runtime_Initialize; -@findex __gnat_set_globals - Set_Globals - (Main_Priority => -1, - -- Priority of main program, -1 if no pragma Priority used + Finalize_Library_Objects := finalize_library'access; - Time_Slice_Value => -1, - -- Time slice from Time_Slice pragma, -1 if none used - - WC_Encoding => 'b', - -- Wide_Character encoding used, default is brackets - - Locking_Policy => ' ', - -- Locking_Policy used, default of space means not - -- specified, otherwise it is the first character of - -- the policy name. - - Queuing_Policy => ' ', - -- Queuing_Policy used, default of space means not - -- specified, otherwise it is the first character of - -- the policy name. - - Task_Dispatching_Policy => ' ', - -- Task_Dispatching_Policy used, default of space means - -- not specified, otherwise first character of the - -- policy name. - - Adafinal => System.Null_Address, - -- Address of Adafinal routine, not used anymore - - Unreserve_All_Interrupts => 0, - -- Set true if pragma Unreserve_All_Interrupts was used - - Exception_Tracebacks => 0); - -- Indicates if exception tracebacks are enabled - - Elab_Final_Code := 1; - -- Now we have the elaboration calls for all units in the partition. -- The Elab_Spec and Elab_Body attributes generate references to the -- implicit elaboration procedures generated by the compiler for - -- each unit that requires elaboration. + -- each unit that requires elaboration. Increment a counter of + -- reference for each unit. - @b{if} @b{not} E040 @b{then} - Interfaces.C_Streams'Elab_Spec; - @b{end} @b{if}; - E040 := True; - @b{if} @b{not} E008 @b{then} - Ada.Exceptions'Elab_Spec; - @b{end} @b{if}; - @b{if} @b{not} E014 @b{then} - System.Exception_Table'Elab_Body; - E014 := True; - @b{end} @b{if}; - @b{if} @b{not} E053 @b{then} - Ada.Io_Exceptions'Elab_Spec; - E053 := True; - @b{end} @b{if}; - @b{if} @b{not} E017 @b{then} - System.Exceptions'Elab_Spec; - E017 := True; - @b{end} @b{if}; - @b{if} @b{not} E030 @b{then} - System.Stack_Checking'Elab_Spec; - @b{end} @b{if}; - @b{if} @b{not} E028 @b{then} - System.Soft_Links'Elab_Body; - E028 := True; - @b{end} @b{if}; - E030 := True; - @b{if} @b{not} E024 @b{then} - System.Secondary_Stack'Elab_Body; - E024 := True; - @b{end} @b{if}; - @b{if} @b{not} E035 @b{then} - Ada.Tags'Elab_Spec; - @b{end} @b{if}; - @b{if} @b{not} E035 @b{then} - Ada.Tags'Elab_Body; - E035 := True; - @b{end} @b{if}; - @b{if} @b{not} E033 @b{then} - Ada.Streams'Elab_Spec; - E033 := True; - @b{end} @b{if}; - @b{if} @b{not} E046 @b{then} - System.Finalization_Root'Elab_Spec; - @b{end} @b{if}; - E046 := True; - @b{if} @b{not} E008 @b{then} - Ada.Exceptions'Elab_Body; - E008 := True; - @b{end} @b{if}; - @b{if} @b{not} E048 @b{then} - System.Finalization_Implementation'Elab_Spec; - @b{end} @b{if}; - @b{if} @b{not} E048 @b{then} - System.Finalization_Implementation'Elab_Body; - E048 := True; - @b{end} @b{if}; - @b{if} @b{not} E044 @b{then} - Ada.Finalization'Elab_Spec; - @b{end} @b{if}; - E044 := True; - @b{if} @b{not} E057 @b{then} - Ada.Finalization.List_Controller'Elab_Spec; - @b{end} @b{if}; - E057 := True; - @b{if} @b{not} E055 @b{then} - System.File_Control_Block'Elab_Spec; - E055 := True; - @b{end} @b{if}; - @b{if} @b{not} E042 @b{then} - System.File_Io'Elab_Body; - E042 := True; - @b{end} @b{if}; - @b{if} @b{not} E006 @b{then} - Ada.Text_Io'Elab_Spec; - @b{end} @b{if}; - @b{if} @b{not} E006 @b{then} - Ada.Text_Io'Elab_Body; - E006 := True; - @b{end} @b{if}; - - Elab_Final_Code := 0; + System.Soft_Links'Elab_Spec; + System.Exception_Table'Elab_Body; + E23 := E23 + 1; + Ada.Io_Exceptions'Elab_Spec; + E46 := E46 + 1; + Ada.Tags'Elab_Spec; + Ada.Streams'Elab_Spec; + E45 := E45 + 1; + Interfaces.C'Elab_Spec; + System.Exceptions'Elab_Spec; + E25 := E25 + 1; + System.Finalization_Root'Elab_Spec; + E68 := E68 + 1; + Ada.Finalization'Elab_Spec; + E66 := E66 + 1; + System.Storage_Pools'Elab_Spec; + E85 := E85 + 1; + System.Finalization_Masters'Elab_Spec; + System.Storage_Pools.Subpools'Elab_Spec; + System.Pool_Global'Elab_Spec; + E87 := E87 + 1; + System.File_Control_Block'Elab_Spec; + E75 := E75 + 1; + System.File_Io'Elab_Body; + E64 := E64 + 1; + E91 := E91 + 1; + System.Finalization_Masters'Elab_Body; + E77 := E77 + 1; + E70 := E70 + 1; + Ada.Tags'Elab_Body; + E48 := E48 + 1; + System.Soft_Links'Elab_Body; + E13 := E13 + 1; + System.Os_Lib'Elab_Body; + E72 := E72 + 1; + System.Secondary_Stack'Elab_Body; + E17 := E17 + 1; + Ada.Text_Io'Elab_Spec; + Ada.Text_Io'Elab_Body; + E06 := E06 + 1; @b{end} adainit; -------------- @@ -22883,10 +22909,31 @@ @findex adafinal @b{procedure} adafinal @b{is} + @b{procedure} s_stalib_adafinal; + @b{pragma} Import (C, s_stalib_adafinal, "system__standard_library__adafinal"); + + @b{procedure} Runtime_Finalize; + @b{pragma} Import (C, Runtime_Finalize, "__gnat_runtime_finalize"); + @b{begin} - Do_Finalize; + @b{if not} Is_Elaborated @b{then} + @b{return}; + @b{end if}; + Is_Elaborated := False; + Runtime_Finalize; + s_stalib_adafinal; @b{end} adafinal; + -- We get to the main program of the partition by using + -- pragma Import because if we try to with the unit and + -- call it Ada style, then not only do we waste time + -- recompiling it, but also, we don't really know the right + -- switches (e.g.@: identifier character set) to be used + -- to compile it. + + @b{procedure} Ada_Main_Program; + @b{pragma} Import (Ada, Ada_Main_Program, "_ada_hello"); + ---------- -- main -- ---------- @@ -22923,16 +22970,13 @@ @b{procedure} finalize; @b{pragma} Import (C, finalize, "__gnat_finalize"); - -- We get to the main program of the partition by using - -- pragma Import because if we try to with the unit and - -- call it Ada style, then not only do we waste time - -- recompiling it, but also, we don't really know the right - -- switches (e.g.@: identifier character set) to be used - -- to compile it. + -- The following is to initialize the SEH exceptions - @b{procedure} Ada_Main_Program; - @b{pragma} Import (Ada, Ada_Main_Program, "_ada_hello"); + SEH : @b{aliased array} (1 .. 2) of Integer; + Ensure_Reference : aliased System.Address := Ada_Main_Program_Name'Address; + @b{pragma} Volatile (Ensure_Reference); + -- Start of processing for main @b{begin} @@ -22944,17 +22988,12 @@ -- Call low level system initialization - Initialize; + Initialize (SEH'Address); -- Call our generated Ada initialization routine adainit; - -- This is the point at which we want the debugger to get - -- control - - Break_Start; - -- Now we call the main program of the partition Ada_Main_Program; Index: final.c =================================================================== --- final.c (revision 219191) +++ final.c (working copy) @@ -40,29 +40,11 @@ at all, the intention is that this be replaced by system specific code where finalization is required. */ -#if defined (__MINGW32__) -#include "mingw32.h" -#include - -extern CRITICAL_SECTION ProcListCS; -extern HANDLE ProcListEvt; - void __gnat_finalize (void) { - /* delete critical section and event handle used for the - processes chain list */ - DeleteCriticalSection(&ProcListCS); - CloseHandle (ProcListEvt); } -#else -void -__gnat_finalize (void) -{ -} -#endif - #ifdef __cplusplus } #endif Index: initialize.c =================================================================== --- initialize.c (revision 219191) +++ initialize.c (working copy) @@ -62,230 +62,15 @@ /* __gnat_initialize (NT-mingw32 Version) */ /******************************************/ -int __gnat_wide_text_translation_required = 0; -/* wide text translation, 0=none, 1=activated */ +extern void __gnat_install_handler(void); #if defined (__MINGW32__) -#include "mingw32.h" -#include -extern void __gnat_init_float (void); extern void __gnat_install_SEH_handler (void *); -extern int gnat_argc; -extern char **gnat_argv; -extern CRITICAL_SECTION ProcListCS; -extern HANDLE ProcListEvt; - -#ifdef GNAT_UNICODE_SUPPORT - -#define EXPAND_ARGV_RATE 128 - -static void -append_arg (int *index, LPWSTR dir, LPWSTR value, - char ***argv, int *last, int quoted) -{ - int size; - LPWSTR fullvalue; - int vallen = _tcslen (value); - int dirlen; - - if (dir == NULL) - { - /* no dir prefix */ - dirlen = 0; - fullvalue = (LPWSTR) xmalloc ((vallen + 1) * sizeof(TCHAR)); - } - else - { - /* Add dir first */ - dirlen = _tcslen (dir); - - fullvalue = (LPWSTR) xmalloc ((dirlen + vallen + 1) * sizeof(TCHAR)); - _tcscpy (fullvalue, dir); - } - - /* Append value */ - - if (quoted) - { - _tcsncpy (fullvalue + dirlen, value + 1, vallen - 1); - fullvalue [dirlen + vallen - sizeof(TCHAR)] = _T('\0'); - } - else - _tcscpy (fullvalue + dirlen, value); - - if (*last <= *index) - { - *last += EXPAND_ARGV_RATE; - *argv = (char **) xrealloc (*argv, (*last) * sizeof (char *)); - } - - size = WS2SC (NULL, fullvalue, 0); - (*argv)[*index] = (char *) xmalloc (size + sizeof(TCHAR)); - WS2SC ((*argv)[*index], fullvalue, size); - - free (fullvalue); - - (*index)++; -} -#endif - void __gnat_initialize (void *eh ATTRIBUTE_UNUSED) { - /* Initialize floating-point coprocessor. This call is needed because - the MS libraries default to 64-bit precision instead of 80-bit - precision, and we require the full precision for proper operation, - given that we have set Max_Digits etc with this in mind */ - __gnat_init_float (); - - /* Initialize the critical section and event handle for the win32_wait() - implementation, see adaint.c */ - InitializeCriticalSection (&ProcListCS); - ProcListEvt = CreateEvent (NULL, FALSE, FALSE, NULL); - -#ifdef GNAT_UNICODE_SUPPORT - /* Set current code page for filenames handling. */ - { - char *codepage = getenv ("GNAT_CODE_PAGE"); - - /* Default code page is UTF-8. */ - CurrentCodePage = CP_UTF8; - - if (codepage != NULL) - { - if (strcmp (codepage, "CP_ACP") == 0) - CurrentCodePage = CP_ACP; - else if (strcmp (codepage, "CP_UTF8") == 0) - CurrentCodePage = CP_UTF8; - } - } - - /* Set current encoding for the IO. */ - { - char *ccsencoding = getenv ("GNAT_CCS_ENCODING"); - - /* Default CCS Encoding. */ - CurrentCCSEncoding = _O_TEXT; - __gnat_wide_text_translation_required = 0; - - if (ccsencoding != NULL) - { - if (strcmp (ccsencoding, "U16TEXT") == 0) - { - CurrentCCSEncoding = _O_U16TEXT; - __gnat_wide_text_translation_required = 1; - } - else if (strcmp (ccsencoding, "TEXT") == 0) - { - CurrentCCSEncoding = _O_TEXT; - __gnat_wide_text_translation_required = 0; - } - else if (strcmp (ccsencoding, "WTEXT") == 0) - { - CurrentCCSEncoding = _O_WTEXT; - __gnat_wide_text_translation_required = 1; - } - else if (strcmp (ccsencoding, "U8TEXT") == 0) - { - CurrentCCSEncoding = _O_U8TEXT; - __gnat_wide_text_translation_required = 1; - } - } - } - - /* Adjust gnat_argv to support Unicode characters. */ - { - LPWSTR *wargv; - int wargc; - int k; - int last; - int argc_expanded = 0; - TCHAR result [MAX_PATH]; - int quoted; - - wargv = CommandLineToArgvW (GetCommandLineW(), &wargc); - - if (wargv != NULL) - { - /* Set gnat_argv with arguments encoded in UTF-8. */ - last = wargc + 1; - gnat_argv = (char **) xmalloc ((last) * sizeof (char *)); - - /* argv[0] is the executable full path-name. */ - - SearchPath (NULL, wargv[0], _T(".exe"), MAX_PATH, result, NULL); - append_arg (&argc_expanded, NULL, result, &gnat_argv, &last, 0); - - for (k=1; k. * + * * + * GNAT was originally developed by the GNAT team at New York University. * + * Extensive contributions were provided by Ada Core Technologies Inc. * + * * + ****************************************************************************/ + +/* This unit provides implementation for __gnat_runtime_initialize () + which is called in adainit() to do special initialization needed by + the GNAT runtime. */ + + +/* The following include is here to meet the published VxWorks requirement + that the __vxworks header appear before any other include. */ +#ifdef __vxworks +#include "vxWorks.h" +#endif + +#ifdef IN_RTS +#include "tconfig.h" +#include "tsystem.h" +/* We don't have libiberty, so use malloc. */ +#define xmalloc(S) malloc (S) +#define xrealloc(V,S) realloc (V,S) +#else +#include "config.h" +#include "system.h" +#endif + +#include "raise.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/**************************************************/ +/* __gnat_runtime_initialize (NT-mingw32 Version) */ +/**************************************************/ + +extern void __gnat_install_handler(void); + +int __gnat_wide_text_translation_required = 0; +/* wide text translation, 0=none, 1=activated */ + +int __gnat_rt_init_count = 0; +/* number of references to the GNAT runtime, this is used to initialize + and finalize properly the run-time. */ + +#if defined (__MINGW32__) +#include "mingw32.h" +#include + +extern void __gnat_init_float (void); +extern void __gnat_install_SEH_handler (void *); + +extern int gnat_argc; +extern char **gnat_argv; +extern CRITICAL_SECTION ProcListCS; +extern HANDLE ProcListEvt; + +#ifdef GNAT_UNICODE_SUPPORT + +#define EXPAND_ARGV_RATE 128 + +static void +append_arg (int *index, LPWSTR dir, LPWSTR value, + char ***argv, int *last, int quoted) +{ + int size; + LPWSTR fullvalue; + int vallen = _tcslen (value); + int dirlen; + + if (dir == NULL) + { + /* no dir prefix */ + dirlen = 0; + fullvalue = (LPWSTR) xmalloc ((vallen + 1) * sizeof(TCHAR)); + } + else + { + /* Add dir first */ + dirlen = _tcslen (dir); + + fullvalue = (LPWSTR) xmalloc ((dirlen + vallen + 1) * sizeof(TCHAR)); + _tcscpy (fullvalue, dir); + } + + /* Append value */ + + if (quoted) + { + _tcsncpy (fullvalue + dirlen, value + 1, vallen - 1); + fullvalue [dirlen + vallen - sizeof(TCHAR)] = _T('\0'); + } + else + _tcscpy (fullvalue + dirlen, value); + + if (*last <= *index) + { + *last += EXPAND_ARGV_RATE; + *argv = (char **) xrealloc (*argv, (*last) * sizeof (char *)); + } + + size = WS2SC (NULL, fullvalue, 0); + (*argv)[*index] = (char *) xmalloc (size + sizeof(TCHAR)); + WS2SC ((*argv)[*index], fullvalue, size); + + free (fullvalue); + + (*index)++; +} +#endif + +void +__gnat_runtime_initialize(void) +{ + /* increment the reference counter */ + + __gnat_rt_init_count++; + + /* if already initialized return now */ + if (__gnat_rt_init_count > 1) + return; + + /* Initialize floating-point coprocessor. This call is needed because + the MS libraries default to 64-bit precision instead of 80-bit + precision, and we require the full precision for proper operation, + given that we have set Max_Digits etc with this in mind */ + + __gnat_init_float (); + + /* Initialize the critical section and event handle for the win32_wait() + implementation, see adaint.c */ + + InitializeCriticalSection (&ProcListCS); + ProcListEvt = CreateEvent (NULL, FALSE, FALSE, NULL); + +#ifdef GNAT_UNICODE_SUPPORT + /* Set current code page for filenames handling. */ + { + char *codepage = getenv ("GNAT_CODE_PAGE"); + + /* Default code page is UTF-8. */ + CurrentCodePage = CP_UTF8; + + if (codepage != NULL) + { + if (strcmp (codepage, "CP_ACP") == 0) + CurrentCodePage = CP_ACP; + else if (strcmp (codepage, "CP_UTF8") == 0) + CurrentCodePage = CP_UTF8; + } + } + + /* Set current encoding for the IO. */ + { + char *ccsencoding = getenv ("GNAT_CCS_ENCODING"); + + /* Default CCS Encoding. */ + CurrentCCSEncoding = _O_TEXT; + __gnat_wide_text_translation_required = 0; + + if (ccsencoding != NULL) + { + if (strcmp (ccsencoding, "U16TEXT") == 0) + { + CurrentCCSEncoding = _O_U16TEXT; + __gnat_wide_text_translation_required = 1; + } + else if (strcmp (ccsencoding, "TEXT") == 0) + { + CurrentCCSEncoding = _O_TEXT; + __gnat_wide_text_translation_required = 0; + } + else if (strcmp (ccsencoding, "WTEXT") == 0) + { + CurrentCCSEncoding = _O_WTEXT; + __gnat_wide_text_translation_required = 1; + } + else if (strcmp (ccsencoding, "U8TEXT") == 0) + { + CurrentCCSEncoding = _O_U8TEXT; + __gnat_wide_text_translation_required = 1; + } + } + } + + /* Adjust gnat_argv to support Unicode characters. */ + { + LPWSTR *wargv; + int wargc; + int k; + int last; + int argc_expanded = 0; + TCHAR result [MAX_PATH]; + int quoted; + + wargv = CommandLineToArgvW (GetCommandLineW(), &wargc); + + if (wargv != NULL) + { + /* Set gnat_argv with arguments encoded in UTF-8. */ + last = wargc + 1; + gnat_argv = (char **) xmalloc ((last) * sizeof (char *)); + + /* argv[0] is the executable full path-name. */ + + SearchPath (NULL, wargv[0], _T(".exe"), MAX_PATH, result, NULL); + append_arg (&argc_expanded, NULL, result, &gnat_argv, &last, 0); + + for (k=1; k 1) + return; + + __gnat_init_float (); + + __gnat_install_handler(); +} + +/***********************************************/ +/* __gnat_runtime_initialize (VxWorks Version) */ +/***********************************************/ + +#elif defined(__vxworks) + +extern void __gnat_init_float (void); + +void +__gnat_runtime_initialize(void) +{ + /* increment the reference counter */ + + __gnat_rt_init_count++; + + /* if already initialized return now */ + if (__gnat_rt_init_count > 1) + return; + + __gnat_init_float (); + + __gnat_install_handler(); +} + +#else + +/***********************************************/ +/* __gnat_runtime_initialize (default version) */ +/***********************************************/ + +void +__gnat_runtime_initialize(void) +{ + /* increment the reference counter */ + + __gnat_rt_init_count++; + + /* if already initialized return now */ + if (__gnat_rt_init_count > 1) + return; + + __gnat_install_handler(); +} + +#endif + +#ifdef __cplusplus +} +#endif Index: gcc-interface/Makefile.in =================================================================== --- gcc-interface/Makefile.in (revision 219191) +++ gcc-interface/Makefile.in (working copy) @@ -2400,7 +2400,7 @@ # thread.c is special as put into GNATRTL_TASKING_OBJS by Makefile.rtl LIBGNAT_OBJS = adadecode.o adaint.o argv.o aux-io.o \ cal.o cio.o cstreams.o ctrl_c.o \ - env.o errno.o exit.o expect.o final.o \ + env.o errno.o exit.o expect.o final.o rtfinal.o rtinit.o \ init.o initialize.o locales.o mkdir.o \ raise.o seh_init.o socket.o sysdep.o \ targext.o terminals.o tracebak.o \ @@ -3046,6 +3046,8 @@ exit.o : adaint.h exit.c expect.o : expect.c final.o : final.c +rtfinal.o : rtfinal.c +rtinit.o : rtinit.c locales.o : locales.c mkdir.o : mkdir.c socket.o : socket.c gsocket.h Index: gcc-interface/Make-lang.in =================================================================== --- gcc-interface/Make-lang.in (revision 219191) +++ gcc-interface/Make-lang.in (working copy) @@ -223,8 +223,8 @@ # Object files for gnat1 from C sources. GNAT1_C_OBJS = ada/adadecode.o ada/adaint.o ada/argv.o ada/cio.o \ ada/cstreams.o ada/env.o ada/init.o ada/initialize.o ada/raise.o \ - ada/seh_init.o ada/targext.o ada/cuintp.o ada/decl.o \ - ada/misc.o ada/utils.o ada/utils2.o ada/trans.o ada/targtyps.o + ada/seh_init.o ada/targext.o ada/cuintp.o ada/decl.o ada/rtfinal.o \ + ada/rtinit.o ada/misc.o ada/utils.o ada/utils2.o ada/trans.o ada/targtyps.o # Object files from Ada sources that are used by gnat1 GNAT_ADA_OBJS = \ @@ -513,6 +513,8 @@ ada/raise.o \ ada/restrict.o \ ada/rident.o \ + ada/rtfinal.o \ + ada/rtinit.o \ ada/s-addope.o \ ada/s-assert.o \ ada/s-carun8.o \