gcc/ada/doc/gnat_ugn/example_of_binder_output.rst

   1 .. _Example_of_Binder_Output_File:
   2
   3 *****************************
   4 Example of Binder Output File
   5 *****************************
   6
   7 .. index:: Binder output (example)
   8
   9 This Appendix displays the source code for the output file
  10 generated by *gnatbind* for a simple 'Hello World' program.
  11 Comments have been added for clarification purposes.
  12
  13
  14 .. code-block:: ada
  15
  16   --  The package is called Ada_Main unless this name is actually used
  17   --  as a unit name in the partition, in which case some other unique
  18   --  name is used.
  19
  20   pragma Ada_95;
  21   with System;
  22   package ada_main is
  23      pragma Warnings (Off);
  24
  25      --  The main program saves the parameters (argument count,
  26      --  argument values, environment pointer) in global variables
  27      --  for later access by other units including
  28      --  Ada.Command_Line.
  29
  30      gnat_argc : Integer;
  31      gnat_argv : System.Address;
  32      gnat_envp : System.Address;
  33
  34      --  The actual variables are stored in a library routine. This
  35      --  is useful for some shared library situations, where there
  36      --  are problems if variables are not in the library.
  37
  38      pragma Import (C, gnat_argc);
  39      pragma Import (C, gnat_argv);
  40      pragma Import (C, gnat_envp);
  41
  42      --  The exit status is similarly an external location
  43
  44      gnat_exit_status : Integer;
  45      pragma Import (C, gnat_exit_status);
  46
  47      GNAT_Version : constant String :=
  48                       "GNAT Version: Pro 7.4.0w (20141119-49)" & ASCII.NUL;
  49      pragma Export (C, GNAT_Version, "__gnat_version");
  50
  51      Ada_Main_Program_Name : constant String := "_ada_hello" & ASCII.NUL;
  52      pragma Export (C, Ada_Main_Program_Name, "__gnat_ada_main_program_name");
  53
  54      --  This is the generated adainit routine that performs
  55      --  initialization at the start of execution. In the case
  56      --  where Ada is the main program, this main program makes
  57      --  a call to adainit at program startup.
  58
  59      procedure adainit;
  60      pragma Export (C, adainit, "adainit");
  61
  62      --  This is the generated adafinal routine that performs
  63      --  finalization at the end of execution. In the case where
  64      --  Ada is the main program, this main program makes a call
  65      --  to adafinal at program termination.
  66
  67      procedure adafinal;
  68      pragma Export (C, adafinal, "adafinal");
  69
  70      --  This routine is called at the start of execution. It is
  71      --  a dummy routine that is used by the debugger to breakpoint
  72      --  at the start of execution.
  73
  74      --  This is the actual generated main program (it would be
  75      --  suppressed if the no main program switch were used). As
  76      --  required by standard system conventions, this program has
  77      --  the external name main.
  78
  79      function main
  80        (argc : Integer;
  81         argv : System.Address;
  82         envp : System.Address)
  83         return Integer;
  84      pragma Export (C, main, "main");
  85
  86      --  The following set of constants give the version
  87      --  identification values for every unit in the bound
  88      --  partition. This identification is computed from all
  89      --  dependent semantic units, and corresponds to the
  90      --  string that would be returned by use of the
  91      --  Body_Version or Version attributes.
  92
  93      --  The following Export pragmas export the version numbers
  94      --  with symbolic names ending in B (for body) or S
  95      --  (for spec) so that they can be located in a link. The
  96      --  information provided here is sufficient to track down
  97      --  the exact versions of units used in a given build.
  98
  99      type Version_32 is mod 2 ** 32;
 100      u00001 : constant Version_32 := 16#8ad6e54a#;
 101      pragma Export (C, u00001, "helloB");
 102      u00002 : constant Version_32 := 16#fbff4c67#;
 103      pragma Export (C, u00002, "system__standard_libraryB");
 104      u00003 : constant Version_32 := 16#1ec6fd90#;
 105      pragma Export (C, u00003, "system__standard_libraryS");
 106      u00004 : constant Version_32 := 16#3ffc8e18#;
 107      pragma Export (C, u00004, "adaS");
 108      u00005 : constant Version_32 := 16#28f088c2#;
 109      pragma Export (C, u00005, "ada__text_ioB");
 110      u00006 : constant Version_32 := 16#f372c8ac#;
 111      pragma Export (C, u00006, "ada__text_ioS");
 112      u00007 : constant Version_32 := 16#2c143749#;
 113      pragma Export (C, u00007, "ada__exceptionsB");
 114      u00008 : constant Version_32 := 16#f4f0cce8#;
 115      pragma Export (C, u00008, "ada__exceptionsS");
 116      u00009 : constant Version_32 := 16#a46739c0#;
 117      pragma Export (C, u00009, "ada__exceptions__last_chance_handlerB");
 118      u00010 : constant Version_32 := 16#3aac8c92#;
 119      pragma Export (C, u00010, "ada__exceptions__last_chance_handlerS");
 120      u00011 : constant Version_32 := 16#1d274481#;
 121      pragma Export (C, u00011, "systemS");
 122      u00012 : constant Version_32 := 16#a207fefe#;
 123      pragma Export (C, u00012, "system__soft_linksB");
 124      u00013 : constant Version_32 := 16#467d9556#;
 125      pragma Export (C, u00013, "system__soft_linksS");
 126      u00014 : constant Version_32 := 16#b01dad17#;
 127      pragma Export (C, u00014, "system__parametersB");
 128      u00015 : constant Version_32 := 16#630d49fe#;
 129      pragma Export (C, u00015, "system__parametersS");
 130      u00016 : constant Version_32 := 16#b19b6653#;
 131      pragma Export (C, u00016, "system__secondary_stackB");
 132      u00017 : constant Version_32 := 16#b6468be8#;
 133      pragma Export (C, u00017, "system__secondary_stackS");
 134      u00018 : constant Version_32 := 16#39a03df9#;
 135      pragma Export (C, u00018, "system__storage_elementsB");
 136      u00019 : constant Version_32 := 16#30e40e85#;
 137      pragma Export (C, u00019, "system__storage_elementsS");
 138      u00020 : constant Version_32 := 16#41837d1e#;
 139      pragma Export (C, u00020, "system__stack_checkingB");
 140      u00021 : constant Version_32 := 16#93982f69#;
 141      pragma Export (C, u00021, "system__stack_checkingS");
 142      u00022 : constant Version_32 := 16#393398c1#;
 143      pragma Export (C, u00022, "system__exception_tableB");
 144      u00023 : constant Version_32 := 16#b33e2294#;
 145      pragma Export (C, u00023, "system__exception_tableS");
 146      u00024 : constant Version_32 := 16#ce4af020#;
 147      pragma Export (C, u00024, "system__exceptionsB");
 148      u00025 : constant Version_32 := 16#75442977#;
 149      pragma Export (C, u00025, "system__exceptionsS");
 150      u00026 : constant Version_32 := 16#37d758f1#;
 151      pragma Export (C, u00026, "system__exceptions__machineS");
 152      u00027 : constant Version_32 := 16#b895431d#;
 153      pragma Export (C, u00027, "system__exceptions_debugB");
 154      u00028 : constant Version_32 := 16#aec55d3f#;
 155      pragma Export (C, u00028, "system__exceptions_debugS");
 156      u00029 : constant Version_32 := 16#570325c8#;
 157      pragma Export (C, u00029, "system__img_intB");
 158      u00030 : constant Version_32 := 16#1ffca443#;
 159      pragma Export (C, u00030, "system__img_intS");
 160      u00031 : constant Version_32 := 16#b98c3e16#;
 161      pragma Export (C, u00031, "system__tracebackB");
 162      u00032 : constant Version_32 := 16#831a9d5a#;
 163      pragma Export (C, u00032, "system__tracebackS");
 164      u00033 : constant Version_32 := 16#9ed49525#;
 165      pragma Export (C, u00033, "system__traceback_entriesB");
 166      u00034 : constant Version_32 := 16#1d7cb2f1#;
 167      pragma Export (C, u00034, "system__traceback_entriesS");
 168      u00035 : constant Version_32 := 16#8c33a517#;
 169      pragma Export (C, u00035, "system__wch_conB");
 170      u00036 : constant Version_32 := 16#065a6653#;
 171      pragma Export (C, u00036, "system__wch_conS");
 172      u00037 : constant Version_32 := 16#9721e840#;
 173      pragma Export (C, u00037, "system__wch_stwB");
 174      u00038 : constant Version_32 := 16#2b4b4a52#;
 175      pragma Export (C, u00038, "system__wch_stwS");
 176      u00039 : constant Version_32 := 16#92b797cb#;
 177      pragma Export (C, u00039, "system__wch_cnvB");
 178      u00040 : constant Version_32 := 16#09eddca0#;
 179      pragma Export (C, u00040, "system__wch_cnvS");
 180      u00041 : constant Version_32 := 16#6033a23f#;
 181      pragma Export (C, u00041, "interfacesS");
 182      u00042 : constant Version_32 := 16#ece6fdb6#;
 183      pragma Export (C, u00042, "system__wch_jisB");
 184      u00043 : constant Version_32 := 16#899dc581#;
 185      pragma Export (C, u00043, "system__wch_jisS");
 186      u00044 : constant Version_32 := 16#10558b11#;
 187      pragma Export (C, u00044, "ada__streamsB");
 188      u00045 : constant Version_32 := 16#2e6701ab#;
 189      pragma Export (C, u00045, "ada__streamsS");
 190      u00046 : constant Version_32 := 16#db5c917c#;
 191      pragma Export (C, u00046, "ada__io_exceptionsS");
 192      u00047 : constant Version_32 := 16#12c8cd7d#;
 193      pragma Export (C, u00047, "ada__tagsB");
 194      u00048 : constant Version_32 := 16#ce72c228#;
 195      pragma Export (C, u00048, "ada__tagsS");
 196      u00049 : constant Version_32 := 16#c3335bfd#;
 197      pragma Export (C, u00049, "system__htableB");
 198      u00050 : constant Version_32 := 16#99e5f76b#;
 199      pragma Export (C, u00050, "system__htableS");
 200      u00051 : constant Version_32 := 16#089f5cd0#;
 201      pragma Export (C, u00051, "system__string_hashB");
 202      u00052 : constant Version_32 := 16#3bbb9c15#;
 203      pragma Export (C, u00052, "system__string_hashS");
 204      u00053 : constant Version_32 := 16#807fe041#;
 205      pragma Export (C, u00053, "system__unsigned_typesS");
 206      u00054 : constant Version_32 := 16#d27be59e#;
 207      pragma Export (C, u00054, "system__val_lluB");
 208      u00055 : constant Version_32 := 16#fa8db733#;
 209      pragma Export (C, u00055, "system__val_lluS");
 210      u00056 : constant Version_32 := 16#27b600b2#;
 211      pragma Export (C, u00056, "system__val_utilB");
 212      u00057 : constant Version_32 := 16#b187f27f#;
 213      pragma Export (C, u00057, "system__val_utilS");
 214      u00058 : constant Version_32 := 16#d1060688#;
 215      pragma Export (C, u00058, "system__case_utilB");
 216      u00059 : constant Version_32 := 16#392e2d56#;
 217      pragma Export (C, u00059, "system__case_utilS");
 218      u00060 : constant Version_32 := 16#84a27f0d#;
 219      pragma Export (C, u00060, "interfaces__c_streamsB");
 220      u00061 : constant Version_32 := 16#8bb5f2c0#;
 221      pragma Export (C, u00061, "interfaces__c_streamsS");
 222      u00062 : constant Version_32 := 16#6db6928f#;
 223      pragma Export (C, u00062, "system__crtlS");
 224      u00063 : constant Version_32 := 16#4e6a342b#;
 225      pragma Export (C, u00063, "system__file_ioB");
 226      u00064 : constant Version_32 := 16#ba56a5e4#;
 227      pragma Export (C, u00064, "system__file_ioS");
 228      u00065 : constant Version_32 := 16#b7ab275c#;
 229      pragma Export (C, u00065, "ada__finalizationB");
 230      u00066 : constant Version_32 := 16#19f764ca#;
 231      pragma Export (C, u00066, "ada__finalizationS");
 232      u00067 : constant Version_32 := 16#95817ed8#;
 233      pragma Export (C, u00067, "system__finalization_rootB");
 234      u00068 : constant Version_32 := 16#52d53711#;
 235      pragma Export (C, u00068, "system__finalization_rootS");
 236      u00069 : constant Version_32 := 16#769e25e6#;
 237      pragma Export (C, u00069, "interfaces__cB");
 238      u00070 : constant Version_32 := 16#4a38bedb#;
 239      pragma Export (C, u00070, "interfaces__cS");
 240      u00071 : constant Version_32 := 16#07e6ee66#;
 241      pragma Export (C, u00071, "system__os_libB");
 242      u00072 : constant Version_32 := 16#d7b69782#;
 243      pragma Export (C, u00072, "system__os_libS");
 244      u00073 : constant Version_32 := 16#1a817b8e#;
 245      pragma Export (C, u00073, "system__stringsB");
 246      u00074 : constant Version_32 := 16#639855e7#;
 247      pragma Export (C, u00074, "system__stringsS");
 248      u00075 : constant Version_32 := 16#e0b8de29#;
 249      pragma Export (C, u00075, "system__file_control_blockS");
 250      u00076 : constant Version_32 := 16#b5b2aca1#;
 251      pragma Export (C, u00076, "system__finalization_mastersB");
 252      u00077 : constant Version_32 := 16#69316dc1#;
 253      pragma Export (C, u00077, "system__finalization_mastersS");
 254      u00078 : constant Version_32 := 16#57a37a42#;
 255      pragma Export (C, u00078, "system__address_imageB");
 256      u00079 : constant Version_32 := 16#bccbd9bb#;
 257      pragma Export (C, u00079, "system__address_imageS");
 258      u00080 : constant Version_32 := 16#7268f812#;
 259      pragma Export (C, u00080, "system__img_boolB");
 260      u00081 : constant Version_32 := 16#e8fe356a#;
 261      pragma Export (C, u00081, "system__img_boolS");
 262      u00082 : constant Version_32 := 16#d7aac20c#;
 263      pragma Export (C, u00082, "system__ioB");
 264      u00083 : constant Version_32 := 16#8365b3ce#;
 265      pragma Export (C, u00083, "system__ioS");
 266      u00084 : constant Version_32 := 16#6d4d969a#;
 267      pragma Export (C, u00084, "system__storage_poolsB");
 268      u00085 : constant Version_32 := 16#e87cc305#;
 269      pragma Export (C, u00085, "system__storage_poolsS");
 270      u00086 : constant Version_32 := 16#e34550ca#;
 271      pragma Export (C, u00086, "system__pool_globalB");
 272      u00087 : constant Version_32 := 16#c88d2d16#;
 273      pragma Export (C, u00087, "system__pool_globalS");
 274      u00088 : constant Version_32 := 16#9d39c675#;
 275      pragma Export (C, u00088, "system__memoryB");
 276      u00089 : constant Version_32 := 16#445a22b5#;
 277      pragma Export (C, u00089, "system__memoryS");
 278      u00090 : constant Version_32 := 16#6a859064#;
 279      pragma Export (C, u00090, "system__storage_pools__subpoolsB");
 280      u00091 : constant Version_32 := 16#e3b008dc#;
 281      pragma Export (C, u00091, "system__storage_pools__subpoolsS");
 282      u00092 : constant Version_32 := 16#63f11652#;
 283      pragma Export (C, u00092, "system__storage_pools__subpools__finalizationB");
 284      u00093 : constant Version_32 := 16#fe2f4b3a#;
 285      pragma Export (C, u00093, "system__storage_pools__subpools__finalizationS");
 286
 287      --  BEGIN ELABORATION ORDER
 288      --  ada%s
 289      --  interfaces%s
 290      --  system%s
 291      --  system.case_util%s
 292      --  system.case_util%b
 293      --  system.htable%s
 294      --  system.img_bool%s
 295      --  system.img_bool%b
 296      --  system.img_int%s
 297      --  system.img_int%b
 298      --  system.io%s
 299      --  system.io%b
 300      --  system.parameters%s
 301      --  system.parameters%b
 302      --  system.crtl%s
 303      --  interfaces.c_streams%s
 304      --  interfaces.c_streams%b
 305      --  system.standard_library%s
 306      --  system.exceptions_debug%s
 307      --  system.exceptions_debug%b
 308      --  system.storage_elements%s
 309      --  system.storage_elements%b
 310      --  system.stack_checking%s
 311      --  system.stack_checking%b
 312      --  system.string_hash%s
 313      --  system.string_hash%b
 314      --  system.htable%b
 315      --  system.strings%s
 316      --  system.strings%b
 317      --  system.os_lib%s
 318      --  system.traceback_entries%s
 319      --  system.traceback_entries%b
 320      --  ada.exceptions%s
 321      --  system.soft_links%s
 322      --  system.unsigned_types%s
 323      --  system.val_llu%s
 324      --  system.val_util%s
 325      --  system.val_util%b
 326      --  system.val_llu%b
 327      --  system.wch_con%s
 328      --  system.wch_con%b
 329      --  system.wch_cnv%s
 330      --  system.wch_jis%s
 331      --  system.wch_jis%b
 332      --  system.wch_cnv%b
 333      --  system.wch_stw%s
 334      --  system.wch_stw%b
 335      --  ada.exceptions.last_chance_handler%s
 336      --  ada.exceptions.last_chance_handler%b
 337      --  system.address_image%s
 338      --  system.exception_table%s
 339      --  system.exception_table%b
 340      --  ada.io_exceptions%s
 341      --  ada.tags%s
 342      --  ada.streams%s
 343      --  ada.streams%b
 344      --  interfaces.c%s
 345      --  system.exceptions%s
 346      --  system.exceptions%b
 347      --  system.exceptions.machine%s
 348      --  system.finalization_root%s
 349      --  system.finalization_root%b
 350      --  ada.finalization%s
 351      --  ada.finalization%b
 352      --  system.storage_pools%s
 353      --  system.storage_pools%b
 354      --  system.finalization_masters%s
 355      --  system.storage_pools.subpools%s
 356      --  system.storage_pools.subpools.finalization%s
 357      --  system.storage_pools.subpools.finalization%b
 358      --  system.memory%s
 359      --  system.memory%b
 360      --  system.standard_library%b
 361      --  system.pool_global%s
 362      --  system.pool_global%b
 363      --  system.file_control_block%s
 364      --  system.file_io%s
 365      --  system.secondary_stack%s
 366      --  system.file_io%b
 367      --  system.storage_pools.subpools%b
 368      --  system.finalization_masters%b
 369      --  interfaces.c%b
 370      --  ada.tags%b
 371      --  system.soft_links%b
 372      --  system.os_lib%b
 373      --  system.secondary_stack%b
 374      --  system.address_image%b
 375      --  system.traceback%s
 376      --  ada.exceptions%b
 377      --  system.traceback%b
 378      --  ada.text_io%s
 379      --  ada.text_io%b
 380      --  hello%b
 381      --  END ELABORATION ORDER
 382
 383   end ada_main;
 384
 385 .. code-block:: ada
 386
 387   pragma Ada_95;
 388   --  The following source file name pragmas allow the generated file
 389   --  names to be unique for different main programs. They are needed
 390   --  since the package name will always be Ada_Main.
 391
 392   pragma Source_File_Name (ada_main, Spec_File_Name => "b~hello.ads");
 393   pragma Source_File_Name (ada_main, Body_File_Name => "b~hello.adb");
 394
 395   pragma Suppress (Overflow_Check);
 396   with Ada.Exceptions;
 397
 398   --  Generated package body for Ada_Main starts here
 399
 400   package body ada_main is
 401      pragma Warnings (Off);
 402
 403      --  These values are reference counter associated to units which have
 404      --  been elaborated. It is also used to avoid elaborating the
 405      --  same unit twice.
 406
 407      E72 : Short_Integer; pragma Import (Ada, E72, "system__os_lib_E");
 408      E13 : Short_Integer; pragma Import (Ada, E13, "system__soft_links_E");
 409      E23 : Short_Integer; pragma Import (Ada, E23, "system__exception_table_E");
 410      E46 : Short_Integer; pragma Import (Ada, E46, "ada__io_exceptions_E");
 411      E48 : Short_Integer; pragma Import (Ada, E48, "ada__tags_E");
 412      E45 : Short_Integer; pragma Import (Ada, E45, "ada__streams_E");
 413      E70 : Short_Integer; pragma Import (Ada, E70, "interfaces__c_E");
 414      E25 : Short_Integer; pragma Import (Ada, E25, "system__exceptions_E");
 415      E68 : Short_Integer; pragma Import (Ada, E68, "system__finalization_root_E");
 416      E66 : Short_Integer; pragma Import (Ada, E66, "ada__finalization_E");
 417      E85 : Short_Integer; pragma Import (Ada, E85, "system__storage_pools_E");
 418      E77 : Short_Integer; pragma Import (Ada, E77, "system__finalization_masters_E");
 419      E91 : Short_Integer; pragma Import (Ada, E91, "system__storage_pools__subpools_E");
 420      E87 : Short_Integer; pragma Import (Ada, E87, "system__pool_global_E");
 421      E75 : Short_Integer; pragma Import (Ada, E75, "system__file_control_block_E");
 422      E64 : Short_Integer; pragma Import (Ada, E64, "system__file_io_E");
 423      E17 : Short_Integer; pragma Import (Ada, E17, "system__secondary_stack_E");
 424      E06 : Short_Integer; pragma Import (Ada, E06, "ada__text_io_E");
 425
 426      Local_Priority_Specific_Dispatching : constant String := "";
 427      Local_Interrupt_States : constant String := "";
 428
 429      Is_Elaborated : Boolean := False;
 430
 431      procedure finalize_library is
 432      begin
 433         E06 := E06 - 1;
 434         declare
 435            procedure F1;
 436            pragma Import (Ada, F1, "ada__text_io__finalize_spec");
 437         begin
 438            F1;
 439         end;
 440         E77 := E77 - 1;
 441         E91 := E91 - 1;
 442         declare
 443            procedure F2;
 444            pragma Import (Ada, F2, "system__file_io__finalize_body");
 445         begin
 446            E64 := E64 - 1;
 447            F2;
 448         end;
 449         declare
 450            procedure F3;
 451            pragma Import (Ada, F3, "system__file_control_block__finalize_spec");
 452         begin
 453            E75 := E75 - 1;
 454            F3;
 455         end;
 456         E87 := E87 - 1;
 457         declare
 458            procedure F4;
 459            pragma Import (Ada, F4, "system__pool_global__finalize_spec");
 460         begin
 461            F4;
 462         end;
 463         declare
 464            procedure F5;
 465            pragma Import (Ada, F5, "system__storage_pools__subpools__finalize_spec");
 466         begin
 467            F5;
 468         end;
 469         declare
 470            procedure F6;
 471            pragma Import (Ada, F6, "system__finalization_masters__finalize_spec");
 472         begin
 473            F6;
 474         end;
 475         declare
 476            procedure Reraise_Library_Exception_If_Any;
 477            pragma Import (Ada, Reraise_Library_Exception_If_Any, "__gnat_reraise_library_exception_if_any");
 478         begin
 479            Reraise_Library_Exception_If_Any;
 480         end;
 481      end finalize_library;
 482
 483      -------------
 484      -- adainit --
 485      -------------
 486
 487      procedure adainit is
 488
 489         Main_Priority : Integer;
 490         pragma Import (C, Main_Priority, "__gl_main_priority");
 491         Time_Slice_Value : Integer;
 492         pragma Import (C, Time_Slice_Value, "__gl_time_slice_val");
 493         WC_Encoding : Character;
 494         pragma Import (C, WC_Encoding, "__gl_wc_encoding");
 495         Locking_Policy : Character;
 496         pragma Import (C, Locking_Policy, "__gl_locking_policy");
 497         Queuing_Policy : Character;
 498         pragma Import (C, Queuing_Policy, "__gl_queuing_policy");
 499         Task_Dispatching_Policy : Character;
 500         pragma Import (C, Task_Dispatching_Policy, "__gl_task_dispatching_policy");
 501         Priority_Specific_Dispatching : System.Address;
 502         pragma Import (C, Priority_Specific_Dispatching, "__gl_priority_specific_dispatching");
 503         Num_Specific_Dispatching : Integer;
 504         pragma Import (C, Num_Specific_Dispatching, "__gl_num_specific_dispatching");
 505         Main_CPU : Integer;
 506         pragma Import (C, Main_CPU, "__gl_main_cpu");
 507         Interrupt_States : System.Address;
 508         pragma Import (C, Interrupt_States, "__gl_interrupt_states");
 509         Num_Interrupt_States : Integer;
 510         pragma Import (C, Num_Interrupt_States, "__gl_num_interrupt_states");
 511         Unreserve_All_Interrupts : Integer;
 512         pragma Import (C, Unreserve_All_Interrupts, "__gl_unreserve_all_interrupts");
 513         Detect_Blocking : Integer;
 514         pragma Import (C, Detect_Blocking, "__gl_detect_blocking");
 515         Default_Stack_Size : Integer;
 516         pragma Import (C, Default_Stack_Size, "__gl_default_stack_size");
 517         Leap_Seconds_Support : Integer;
 518         pragma Import (C, Leap_Seconds_Support, "__gl_leap_seconds_support");
 519
 520         procedure Runtime_Initialize;
 521         pragma Import (C, Runtime_Initialize, "__gnat_runtime_initialize");
 522
 523         Finalize_Library_Objects : No_Param_Proc;
 524         pragma Import (C, Finalize_Library_Objects, "__gnat_finalize_library_objects");
 525
 526      --  Start of processing for adainit
 527
 528      begin
 529
 530         --  Record various information for this partition.  The values
 531         --  are derived by the binder from information stored in the ali
 532         --  files by the compiler.
 533
 534         if Is_Elaborated then
 535            return;
 536         end if;
 537         Is_Elaborated := True;
 538         Main_Priority := -1;
 539         Time_Slice_Value := -1;
 540         WC_Encoding := 'b';
 541         Locking_Policy := ' ';
 542         Queuing_Policy := ' ';
 543         Task_Dispatching_Policy := ' ';
 544         Priority_Specific_Dispatching :=
 545           Local_Priority_Specific_Dispatching'Address;
 546         Num_Specific_Dispatching := 0;
 547         Main_CPU := -1;
 548         Interrupt_States := Local_Interrupt_States'Address;
 549         Num_Interrupt_States := 0;
 550         Unreserve_All_Interrupts := 0;
 551         Detect_Blocking := 0;
 552         Default_Stack_Size := -1;
 553         Leap_Seconds_Support := 0;
 554
 555         Runtime_Initialize;
 556
 557         Finalize_Library_Objects := finalize_library'access;
 558
 559         --  Now we have the elaboration calls for all units in the partition.
 560         --  The Elab_Spec and Elab_Body attributes generate references to the
 561         --  implicit elaboration procedures generated by the compiler for
 562         --  each unit that requires elaboration. Increment a counter of
 563         --  reference for each unit.
 564
 565         System.Soft_Links'Elab_Spec;
 566         System.Exception_Table'Elab_Body;
 567         E23 := E23 + 1;
 568         Ada.Io_Exceptions'Elab_Spec;
 569         E46 := E46 + 1;
 570         Ada.Tags'Elab_Spec;
 571         Ada.Streams'Elab_Spec;
 572         E45 := E45 + 1;
 573         Interfaces.C'Elab_Spec;
 574         System.Exceptions'Elab_Spec;
 575         E25 := E25 + 1;
 576         System.Finalization_Root'Elab_Spec;
 577         E68 := E68 + 1;
 578         Ada.Finalization'Elab_Spec;
 579         E66 := E66 + 1;
 580         System.Storage_Pools'Elab_Spec;
 581         E85 := E85 + 1;
 582         System.Finalization_Masters'Elab_Spec;
 583         System.Storage_Pools.Subpools'Elab_Spec;
 584         System.Pool_Global'Elab_Spec;
 585         E87 := E87 + 1;
 586         System.File_Control_Block'Elab_Spec;
 587         E75 := E75 + 1;
 588         System.File_Io'Elab_Body;
 589         E64 := E64 + 1;
 590         E91 := E91 + 1;
 591         System.Finalization_Masters'Elab_Body;
 592         E77 := E77 + 1;
 593         E70 := E70 + 1;
 594         Ada.Tags'Elab_Body;
 595         E48 := E48 + 1;
 596         System.Soft_Links'Elab_Body;
 597         E13 := E13 + 1;
 598         System.Os_Lib'Elab_Body;
 599         E72 := E72 + 1;
 600         System.Secondary_Stack'Elab_Body;
 601         E17 := E17 + 1;
 602         Ada.Text_Io'Elab_Spec;
 603         Ada.Text_Io'Elab_Body;
 604         E06 := E06 + 1;
 605      end adainit;
 606
 607      --------------
 608      -- adafinal --
 609      --------------
 610
 611      procedure adafinal is
 612         procedure s_stalib_adafinal;
 613         pragma Import (C, s_stalib_adafinal, "system__standard_library__adafinal");
 614
 615         procedure Runtime_Finalize;
 616         pragma Import (C, Runtime_Finalize, "__gnat_runtime_finalize");
 617
 618      begin
 619         if not Is_Elaborated then
 620            return;
 621         end if;
 622         Is_Elaborated := False;
 623         Runtime_Finalize;
 624         s_stalib_adafinal;
 625      end adafinal;
 626
 627      --  We get to the main program of the partition by using
 628      --  pragma Import because if we try to with the unit and
 629      --  call it Ada style, then not only do we waste time
 630      --  recompiling it, but also, we don't really know the right
 631      --  switches (e.g.@: identifier character set) to be used
 632      --  to compile it.
 633
 634      procedure Ada_Main_Program;
 635      pragma Import (Ada, Ada_Main_Program, "_ada_hello");
 636
 637      ----------
 638      -- main --
 639      ----------
 640
 641      --  main is actually a function, as in the ANSI C standard,
 642      --  defined to return the exit status. The three parameters
 643      --  are the argument count, argument values and environment
 644      --  pointer.
 645
 646      function main
 647        (argc : Integer;
 648         argv : System.Address;
 649         envp : System.Address)
 650         return Integer
 651      is
 652         --  The initialize routine performs low level system
 653         --  initialization using a standard library routine which
 654         --  sets up signal handling and performs any other
 655         --  required setup. The routine can be found in file
 656         --  a-init.c.
 657
 658         procedure initialize;
 659         pragma Import (C, initialize, "__gnat_initialize");
 660
 661         --  The finalize routine performs low level system
 662         --  finalization using a standard library routine. The
 663         --  routine is found in file a-final.c and in the standard
 664         --  distribution is a dummy routine that does nothing, so
 665         --  really this is a hook for special user finalization.
 666
 667         procedure finalize;
 668         pragma Import (C, finalize, "__gnat_finalize");
 669
 670         --  The following is to initialize the SEH exceptions
 671
 672         SEH : aliased array (1 .. 2) of Integer;
 673
 674         Ensure_Reference : aliased System.Address := Ada_Main_Program_Name'Address;
 675         pragma Volatile (Ensure_Reference);
 676
 677      --  Start of processing for main
 678
 679      begin
 680         --  Save global variables
 681
 682         gnat_argc := argc;
 683         gnat_argv := argv;
 684         gnat_envp := envp;
 685
 686         --  Call low level system initialization
 687
 688         Initialize (SEH'Address);
 689
 690         --  Call our generated Ada initialization routine
 691
 692         adainit;
 693
 694         --  Now we call the main program of the partition
 695
 696         Ada_Main_Program;
 697
 698         --  Perform Ada finalization
 699
 700         adafinal;
 701
 702         --  Perform low level system finalization
 703
 704         Finalize;
 705
 706         --  Return the proper exit status
 707         return (gnat_exit_status);
 708      end;
 709
 710   --  This section is entirely comments, so it has no effect on the
 711   --  compilation of the Ada_Main package. It provides the list of
 712   --  object files and linker options, as well as some standard
 713   --  libraries needed for the link. The gnatlink utility parses
 714   --  this b~hello.adb file to read these comment lines to generate
 715   --  the appropriate command line arguments for the call to the
 716   --  system linker. The BEGIN/END lines are used for sentinels for
 717   --  this parsing operation.
 718
 719   --  The exact file names will of course depend on the environment,
 720   --  host/target and location of files on the host system.
 721
 722   -- BEGIN Object file/option list
 723      --   ./hello.o
 724      --   -L./
 725      --   -L/usr/local/gnat/lib/gcc-lib/i686-pc-linux-gnu/2.8.1/adalib/
 726      --   /usr/local/gnat/lib/gcc-lib/i686-pc-linux-gnu/2.8.1/adalib/libgnat.a
 727   -- END Object file/option list
 728
 729   end ada_main;
 730
 731
 732 The Ada code in the above example is exactly what is generated by the
 733 binder. We have added comments to more clearly indicate the function
 734 of each part of the generated `Ada_Main` package.
 735
 736 The code is standard Ada in all respects, and can be processed by any
 737 tools that handle Ada. In particular, it is possible to use the debugger
 738 in Ada mode to debug the generated `Ada_Main` package. For example,
 739 suppose that for reasons that you do not understand, your program is crashing
 740 during elaboration of the body of `Ada.Text_IO`. To locate this bug,
 741 you can place a breakpoint on the call:
 742
 743   .. code-block:: ada
 744
 745      Ada.Text_Io'Elab_Body;
 746
 747 and trace the elaboration routine for this package to find out where
 748 the problem might be (more usually of course you would be debugging
 749 elaboration code in your own application).
 750