gcc/m2/mc-boot/GM2Dependent.cc

   1 /* do not edit automatically generated by mc from M2Dependent.  */
   2 /* M2Dependent.mod implements the run time module dependencies.
   3
   4 Copyright (C) 2022-2024 Free Software Foundation, Inc.
   5 Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
   6
   7 This file is part of GNU Modula-2.
   8
   9 GNU Modula-2 is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GNU Modula-2 is distributed in the hope that it will be useful, but
  15 WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 General Public License for more details.
  18
  19 Under Section 7 of GPL version 3, you are granted additional
  20 permissions described in the GCC Runtime Library Exception, version
  21 3.1, as published by the Free Software Foundation.
  22
  23 You should have received a copy of the GNU General Public License and
  24 a copy of the GCC Runtime Library Exception along with this program;
  25 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  26 <http://www.gnu.org/licenses/>.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include <stdbool.h>
  31 #   if !defined (PROC_D)
  32 #      define PROC_D
  33        typedef void (*PROC_t) (void);
  34        typedef struct { PROC_t proc; } PROC;
  35 #   endif
  36
  37 #   if !defined (TRUE)
  38 #      define TRUE (1==1)
  39 #   endif
  40
  41 #   if !defined (FALSE)
  42 #      define FALSE (1==0)
  43 #   endif
  44
  45 #   include "GStorage.h"
  46 #if defined(__cplusplus)
  47 #   undef NULL
  48 #   define NULL 0
  49 #endif
  50 #define _M2Dependent_C
  51
  52 #include "GM2Dependent.h"
  53 #   include "Glibc.h"
  54 #   include "GASCII.h"
  55 #   include "GSYSTEM.h"
  56 #   include "GStorage.h"
  57 #   include "GStrLib.h"
  58
  59 typedef struct M2Dependent_ArgCVEnvP_p M2Dependent_ArgCVEnvP;
  60
  61 typedef struct M2Dependent_DependencyList_r M2Dependent_DependencyList;
  62
  63 typedef char *M2Dependent_PtrToChar;
  64
  65 typedef struct M2Dependent_ProcedureList_r M2Dependent_ProcedureList;
  66
  67 typedef struct M2Dependent__T2_r M2Dependent__T2;
  68
  69 typedef M2Dependent__T2 *M2Dependent_ModuleChain;
  70
  71 typedef struct M2Dependent__T3_r M2Dependent__T3;
  72
  73 typedef M2Dependent__T3 *M2Dependent_ProcedureChain;
  74
  75 typedef struct M2Dependent__T4_a M2Dependent__T4;
  76
  77 typedef enum {M2Dependent_unregistered, M2Dependent_unordered, M2Dependent_started, M2Dependent_ordered, M2Dependent_user} M2Dependent_DependencyState;
  78
  79 struct M2Dependent_DependencyList_r {
  80                                       PROC proc;
  81                                       bool forced;
  82                                       bool forc;
  83                                       bool appl;
  84                                       M2Dependent_DependencyState state;
  85                                     };
  86
  87 struct M2Dependent_ProcedureList_r {
  88                                      M2Dependent_ProcedureChain head;
  89                                      M2Dependent_ProcedureChain tail;
  90                                    };
  91
  92 struct M2Dependent__T3_r {
  93                            PROC p;
  94                            M2Dependent_ProcedureChain prev;
  95                            M2Dependent_ProcedureChain next;
  96                          };
  97
  98 struct M2Dependent__T4_a { M2Dependent_ModuleChain array[M2Dependent_user-M2Dependent_unregistered+1]; };
  99 struct M2Dependent__T2_r {
 100                            void * name;
 101                            void * libname;
 102                            M2Dependent_ArgCVEnvP init;
 103                            M2Dependent_ArgCVEnvP fini;
 104                            M2Dependent_DependencyList dependency;
 105                            M2Dependent_ModuleChain prev;
 106                            M2Dependent_ModuleChain next;
 107                          };
 108
 109 static M2Dependent__T4 Modules;
 110 static bool DynamicInitialization;
 111 static bool Initialized;
 112 static bool WarningTrace;
 113 static bool ModuleTrace;
 114 static bool HexTrace;
 115 static bool DependencyTrace;
 116 static bool PreTrace;
 117 static bool PostTrace;
 118 static bool ForceTrace;
 119 static M2Dependent_ProcedureList InitialProc;
 120 static M2Dependent_ProcedureList TerminateProc;
 121
 122 /*
 123    ConstructModules - resolve dependencies and then call each
 124                       module constructor in turn.
 125 */
 126
 127 extern "C" void M2Dependent_ConstructModules (void * applicationmodule, void * libname, void * overrideliborder, int argc, void * argv, void * envp);
 128
 129 /*
 130    DeconstructModules - resolve dependencies and then call each
 131                         module constructor in turn.
 132 */
 133
 134 extern "C" void M2Dependent_DeconstructModules (void * applicationmodule, void * libname, int argc, void * argv, void * envp);
 135
 136 /*
 137    RegisterModule - adds module name to the list of outstanding
 138                     modules which need to have their dependencies
 139                     explored to determine initialization order.
 140 */
 141
 142 extern "C" void M2Dependent_RegisterModule (void * modulename, void * libname, M2Dependent_ArgCVEnvP init, M2Dependent_ArgCVEnvP fini, PROC dependencies);
 143
 144 /*
 145    RequestDependant - used to specify that modulename is dependant upon
 146                       module dependantmodule.  It only takes effect
 147                       if we are using DynamicInitialization.
 148 */
 149
 150 extern "C" void M2Dependent_RequestDependant (void * modulename, void * libname, void * dependantmodule, void * dependantlibname);
 151
 152 /*
 153    InstallTerminationProcedure - installs a procedure, p, which will
 154                                  be called when the procedure
 155                                  ExecuteTerminationProcedures
 156                                  is invoked.  It returns TRUE if the
 157                                  procedure is installed.
 158 */
 159
 160 extern "C" bool M2Dependent_InstallTerminationProcedure (PROC p);
 161
 162 /*
 163    ExecuteInitialProcedures - executes the initial procedures installed by
 164                               InstallInitialProcedure.
 165 */
 166
 167 extern "C" void M2Dependent_ExecuteInitialProcedures (void);
 168
 169 /*
 170    InstallInitialProcedure - installs a procedure to be executed just
 171                              before the BEGIN code section of the
 172                              main program module.
 173 */
 174
 175 extern "C" bool M2Dependent_InstallInitialProcedure (PROC p);
 176
 177 /*
 178    ExecuteTerminationProcedures - calls each installed termination procedure
 179                                   in reverse order.
 180 */
 181
 182 extern "C" void M2Dependent_ExecuteTerminationProcedures (void);
 183
 184 /*
 185    InitDependencyList - initialize all fields of DependencyList.
 186 */
 187
 188 static void InitDependencyList (M2Dependent_DependencyList *depList, PROC proc, M2Dependent_DependencyState state);
 189
 190 /*
 191    CreateModule - creates a new module entry and returns the
 192                   ModuleChain.
 193 */
 194
 195 static M2Dependent_ModuleChain CreateModule (void * name, void * libname, M2Dependent_ArgCVEnvP init, M2Dependent_ArgCVEnvP fini, PROC dependencies);
 196
 197 /*
 198    AppendModule - append chain to end of the list.
 199 */
 200
 201 static void AppendModule (M2Dependent_ModuleChain *head, M2Dependent_ModuleChain chain);
 202
 203 /*
 204    RemoveModule - remove chain from double linked list head.
 205 */
 206
 207 static void RemoveModule (M2Dependent_ModuleChain *head, M2Dependent_ModuleChain chain);
 208
 209 /*
 210    onChain - returns TRUE if mptr is on the Modules[state] list.
 211 */
 212
 213 static bool onChain (M2Dependent_DependencyState state, M2Dependent_ModuleChain mptr);
 214
 215 /*
 216    max -
 217 */
 218
 219 static unsigned int max (unsigned int a, unsigned int b);
 220
 221 /*
 222    min -
 223 */
 224
 225 static unsigned int min (unsigned int a, unsigned int b);
 226
 227 /*
 228    LookupModuleN - lookup module from the state list.
 229                    The strings lengths are known.
 230 */
 231
 232 static M2Dependent_ModuleChain LookupModuleN (M2Dependent_DependencyState state, void * name, unsigned int namelen, void * libname, unsigned int libnamelen);
 233
 234 /*
 235    LookupModule - lookup and return the ModuleChain pointer containing
 236                   module name from a particular list.
 237 */
 238
 239 static M2Dependent_ModuleChain LookupModule (M2Dependent_DependencyState state, void * name, void * libname);
 240
 241 /*
 242    toCString - replace any character sequence
 243  into a newline.
 244 */
 245
 246 static void toCString (char *str, unsigned int _str_high);
 247
 248 /*
 249    strcmp - return 0 if both strings are equal.
 250             We cannot use Builtins.def during bootstrap.
 251 */
 252
 253 static int strcmp (M2Dependent_PtrToChar a, M2Dependent_PtrToChar b);
 254
 255 /*
 256    strncmp - return 0 if both strings are equal.
 257              We cannot use Builtins.def during bootstrap.
 258 */
 259
 260 static int strncmp (M2Dependent_PtrToChar a, M2Dependent_PtrToChar b, unsigned int n);
 261
 262 /*
 263    strlen - returns the length of string.
 264 */
 265
 266 static int strlen_ (M2Dependent_PtrToChar string);
 267
 268 /*
 269    traceprintf - wrap printf with a boolean flag.
 270 */
 271
 272 static void traceprintf (bool flag, const char *str_, unsigned int _str_high);
 273
 274 /*
 275    traceprintf2 - wrap printf with a boolean flag.
 276 */
 277
 278 static void traceprintf2 (bool flag, const char *str_, unsigned int _str_high, void * arg);
 279
 280 /*
 281    traceprintf3 - wrap printf with a boolean flag.
 282 */
 283
 284 static void traceprintf3 (bool flag, const char *str_, unsigned int _str_high, void * arg1, void * arg2);
 285
 286 /*
 287    moveTo - moves mptr to the new list determined by newstate.
 288             It updates the mptr state appropriately.
 289 */
 290
 291 static void moveTo (M2Dependent_DependencyState newstate, M2Dependent_ModuleChain mptr);
 292
 293 /*
 294    ResolveDependant -
 295 */
 296
 297 static void ResolveDependant (M2Dependent_ModuleChain mptr, void * currentmodule, void * libname);
 298
 299 /*
 300    PerformRequestDependant - the current modulename has a dependancy upon
 301                              dependantmodule.  If dependantmodule is NIL then
 302                              modulename has no further dependants and it can be
 303                              resolved.
 304 */
 305
 306 static void PerformRequestDependant (void * modulename, void * libname, void * dependantmodule, void * dependantlibname);
 307
 308 /*
 309    ResolveDependencies - resolve dependencies for currentmodule, libname.
 310 */
 311
 312 static void ResolveDependencies (void * currentmodule, void * libname);
 313
 314 /*
 315    DisplayModuleInfo - displays all module in the state.
 316 */
 317
 318 static void DisplayModuleInfo (M2Dependent_DependencyState state, const char *desc_, unsigned int _desc_high);
 319
 320 /*
 321    DumpModuleData -
 322 */
 323
 324 static void DumpModuleData (bool flag);
 325
 326 /*
 327    combine - dest := src + dest.  Places src at the front of list dest.
 328              Pre condition:  src, dest are lists.
 329              Post condition : dest := src + dest
 330                               src := NIL.
 331 */
 332
 333 static void combine (M2Dependent_DependencyState src, M2Dependent_DependencyState dest);
 334
 335 /*
 336    tracemodule -
 337 */
 338
 339 static void tracemodule (bool flag, void * modname, unsigned int modlen, void * libname, unsigned int liblen);
 340
 341 /*
 342    ForceModule -
 343 */
 344
 345 static void ForceModule (void * modname, unsigned int modlen, void * libname, unsigned int liblen);
 346
 347 /*
 348    ForceDependencies - if the user has specified a forced order then we override
 349                        the dynamic ordering with the preference.
 350 */
 351
 352 static void ForceDependencies (void * overrideliborder);
 353
 354 /*
 355    CheckApplication - check to see that the application is the last entry in the list.
 356                       This might happen if the application only imports FOR C modules.
 357 */
 358
 359 static void CheckApplication (void);
 360
 361 /*
 362    warning3 - write format arg1 arg2 to stderr.
 363 */
 364
 365 static void warning3 (const char *format_, unsigned int _format_high, void * arg1, void * arg2);
 366
 367 /*
 368    equal - return TRUE if C string cstr is equal to str.
 369 */
 370
 371 static bool equal (void * cstr, const char *str_, unsigned int _str_high);
 372
 373 /*
 374    SetupDebugFlags - By default assigns ModuleTrace, DependencyTrace,
 375                      DumpPostInit to FALSE.  It checks the environment
 376                      GCC_M2LINK_RTFLAG which can contain
 377                      "all,module,hex,pre,post,dep,force".  all turns them all on.
 378                      The flag meanings are as follows and flags the are in
 379                      execution order.
 380
 381                      module   generate trace info as the modules are registered.
 382                      hex      dump the modules ctor functions address in hex.
 383                      pre      generate a list of all modules seen prior to having
 384                               their dependancies resolved.
 385                      dep      display a trace as the modules are resolved.
 386                      post     generate a list of all modules seen after having
 387                               their dependancies resolved dynamically.
 388                      force    generate a list of all modules seen after having
 389                               their dependancies resolved and forced.
 390 */
 391
 392 static void SetupDebugFlags (void);
 393
 394 /*
 395    Init - initialize the debug flags and set all lists to NIL.
 396 */
 397
 398 static void Init (void);
 399
 400 /*
 401    CheckInitialized - checks to see if this module has been initialized
 402                       and if it has not it calls Init.  We need this
 403                       approach as this module is called by module ctors
 404                       before we reach main.
 405 */
 406
 407 static void CheckInitialized (void);
 408
 409 /*
 410    ExecuteReverse - execute the procedure associated with procptr
 411                     and then proceed to try and execute all previous
 412                     procedures in the chain.
 413 */
 414
 415 static void ExecuteReverse (M2Dependent_ProcedureChain procptr);
 416
 417 /*
 418    AppendProc - append proc to the end of the procedure list
 419                 defined by proclist.
 420 */
 421
 422 static bool AppendProc (M2Dependent_ProcedureList *proclist, PROC proc);
 423
 424 /*
 425    InitProcList - initialize the head and tail pointers to NIL.
 426 */
 427
 428 static void InitProcList (M2Dependent_ProcedureList *p);
 429
 430
 431 /*
 432    InitDependencyList - initialize all fields of DependencyList.
 433 */
 434
 435 static void InitDependencyList (M2Dependent_DependencyList *depList, PROC proc, M2Dependent_DependencyState state)
 436 {
 437   (*depList).proc = proc;
 438   (*depList).forced = false;
 439   (*depList).forc = false;
 440   (*depList).appl = false;
 441   (*depList).state = state;
 442 }
 443
 444
 445 /*
 446    CreateModule - creates a new module entry and returns the
 447                   ModuleChain.
 448 */
 449
 450 static M2Dependent_ModuleChain CreateModule (void * name, void * libname, M2Dependent_ArgCVEnvP init, M2Dependent_ArgCVEnvP fini, PROC dependencies)
 451 {
 452   M2Dependent_ModuleChain mptr;
 453
 454   Storage_ALLOCATE ((void **) &mptr, sizeof (M2Dependent__T2));
 455   mptr->name = name;
 456   mptr->libname = libname;
 457   mptr->init = init;
 458   mptr->fini = fini;
 459   InitDependencyList (&mptr->dependency, dependencies, M2Dependent_unregistered);
 460   mptr->prev = NULL;
 461   mptr->next = NULL;
 462   if (HexTrace)
 463     {
 464       libc_printf ((const char *) "   (init: %p  fini: %p", 22, init, fini);
 465       libc_printf ((const char *) "  dep: %p)", 10, dependencies);
 466     }
 467   return mptr;
 468   /* static analysis guarentees a RETURN statement will be used before here.  */
 469   __builtin_unreachable ();
 470 }
 471
 472
 473 /*
 474    AppendModule - append chain to end of the list.
 475 */
 476
 477 static void AppendModule (M2Dependent_ModuleChain *head, M2Dependent_ModuleChain chain)
 478 {
 479   if ((*head) == NULL)
 480     {
 481       (*head) = chain;
 482       chain->prev = chain;
 483       chain->next = chain;
 484     }
 485   else
 486     {
 487       chain->next = (*head);  /* Add Item to the end of list.  */
 488       chain->prev = (*head)->prev;  /* Add Item to the end of list.  */
 489       (*head)->prev->next = chain;
 490       (*head)->prev = chain;
 491     }
 492 }
 493
 494
 495 /*
 496    RemoveModule - remove chain from double linked list head.
 497 */
 498
 499 static void RemoveModule (M2Dependent_ModuleChain *head, M2Dependent_ModuleChain chain)
 500 {
 501   if ((chain->next == (*head)) && (chain == (*head)))
 502     {
 503       (*head) = NULL;
 504     }
 505   else
 506     {
 507       if ((*head) == chain)
 508         {
 509           (*head) = (*head)->next;
 510         }
 511       chain->prev->next = chain->next;
 512       chain->next->prev = chain->prev;
 513     }
 514 }
 515
 516
 517 /*
 518    onChain - returns TRUE if mptr is on the Modules[state] list.
 519 */
 520
 521 static bool onChain (M2Dependent_DependencyState state, M2Dependent_ModuleChain mptr)
 522 {
 523   M2Dependent_ModuleChain ptr;
 524
 525   if (Modules.array[state-M2Dependent_unregistered] != NULL)
 526     {
 527       ptr = Modules.array[state-M2Dependent_unregistered];
 528       do {
 529         if (ptr == mptr)
 530           {
 531             return true;
 532           }
 533         ptr = ptr->next;
 534       } while (! (ptr == Modules.array[state-M2Dependent_unregistered]));
 535     }
 536   return false;
 537   /* static analysis guarentees a RETURN statement will be used before here.  */
 538   __builtin_unreachable ();
 539 }
 540
 541
 542 /*
 543    max -
 544 */
 545
 546 static unsigned int max (unsigned int a, unsigned int b)
 547 {
 548   if (a > b)
 549     {
 550       return a;
 551     }
 552   else
 553     {
 554       return b;
 555     }
 556   /* static analysis guarentees a RETURN statement will be used before here.  */
 557   __builtin_unreachable ();
 558 }
 559
 560
 561 /*
 562    min -
 563 */
 564
 565 static unsigned int min (unsigned int a, unsigned int b)
 566 {
 567   if (a < b)
 568     {
 569       return a;
 570     }
 571   else
 572     {
 573       return b;
 574     }
 575   /* static analysis guarentees a RETURN statement will be used before here.  */
 576   __builtin_unreachable ();
 577 }
 578
 579
 580 /*
 581    LookupModuleN - lookup module from the state list.
 582                    The strings lengths are known.
 583 */
 584
 585 static M2Dependent_ModuleChain LookupModuleN (M2Dependent_DependencyState state, void * name, unsigned int namelen, void * libname, unsigned int libnamelen)
 586 {
 587   M2Dependent_ModuleChain ptr;
 588
 589   if (Modules.array[state-M2Dependent_unregistered] != NULL)
 590     {
 591       ptr = Modules.array[state-M2Dependent_unregistered];
 592       do {
 593         if (((strncmp (reinterpret_cast <M2Dependent_PtrToChar> (ptr->name), reinterpret_cast <M2Dependent_PtrToChar> (name), max (namelen, static_cast<unsigned int> (strlen_ (reinterpret_cast <M2Dependent_PtrToChar> (ptr->name)))))) == 0) && ((strncmp (reinterpret_cast <M2Dependent_PtrToChar> (ptr->libname), reinterpret_cast <M2Dependent_PtrToChar> (libname), max (libnamelen, static_cast<unsigned int> (strlen_ (reinterpret_cast <M2Dependent_PtrToChar> (ptr->libname)))))) == 0))
 594           {
 595             return ptr;
 596           }
 597         ptr = ptr->next;
 598       } while (! (ptr == Modules.array[state-M2Dependent_unregistered]));
 599     }
 600   return NULL;
 601   /* static analysis guarentees a RETURN statement will be used before here.  */
 602   __builtin_unreachable ();
 603 }
 604
 605
 606 /*
 607    LookupModule - lookup and return the ModuleChain pointer containing
 608                   module name from a particular list.
 609 */
 610
 611 static M2Dependent_ModuleChain LookupModule (M2Dependent_DependencyState state, void * name, void * libname)
 612 {
 613   return LookupModuleN (state, name, static_cast<unsigned int> (strlen_ (reinterpret_cast <M2Dependent_PtrToChar> (name))), libname, static_cast<unsigned int> (strlen_ (reinterpret_cast <M2Dependent_PtrToChar> (libname))));
 614   /* static analysis guarentees a RETURN statement will be used before here.  */
 615   __builtin_unreachable ();
 616 }
 617
 618
 619 /*
 620    toCString - replace any character sequence
 621  into a newline.
 622 */
 623
 624 static void toCString (char *str, unsigned int _str_high)
 625 {
 626   unsigned int high;
 627   unsigned int i;
 628   unsigned int j;
 629
 630   i = 0;
 631   high = _str_high;
 632   while (i < high)
 633     {
 634       if ((i < high) && (str[i] == '\\'))
 635         {
 636           if (str[i+1] == 'n')
 637             {
 638               const_cast<char *>(str)[i] = ASCII_nl;
 639               j = i+1;
 640               while (j < high)
 641                 {
 642                   const_cast<char *>(str)[j] = str[j+1];
 643                   j += 1;
 644                 }
 645             }
 646         }
 647       i += 1;
 648     }
 649 }
 650
 651
 652 /*
 653    strcmp - return 0 if both strings are equal.
 654             We cannot use Builtins.def during bootstrap.
 655 */
 656
 657 static int strcmp (M2Dependent_PtrToChar a, M2Dependent_PtrToChar b)
 658 {
 659   if ((a != NULL) && (b != NULL))
 660     {
 661       /* avoid gcc warning by using compound statement even if not strictly necessary.  */
 662       if (a == b)
 663         {
 664           return 0;
 665         }
 666       else
 667         {
 668           while ((*a) == (*b))
 669             {
 670               if ((*a) == ASCII_nul)
 671                 {
 672                   return 0;
 673                 }
 674               a += 1;
 675               b += 1;
 676             }
 677         }
 678     }
 679   return 1;
 680   /* static analysis guarentees a RETURN statement will be used before here.  */
 681   __builtin_unreachable ();
 682 }
 683
 684
 685 /*
 686    strncmp - return 0 if both strings are equal.
 687              We cannot use Builtins.def during bootstrap.
 688 */
 689
 690 static int strncmp (M2Dependent_PtrToChar a, M2Dependent_PtrToChar b, unsigned int n)
 691 {
 692   if (n == 0)
 693     {
 694       return 0;
 695     }
 696   else if ((a != NULL) && (b != NULL))
 697     {
 698       /* avoid dangling else.  */
 699       if (a == b)
 700         {
 701           return 0;
 702         }
 703       else
 704         {
 705           while (((*a) == (*b)) && (n > 0))
 706             {
 707               if (((*a) == ASCII_nul) || (n == 1))
 708                 {
 709                   return 0;
 710                 }
 711               a += 1;
 712               b += 1;
 713               n -= 1;
 714             }
 715         }
 716     }
 717   return 1;
 718   /* static analysis guarentees a RETURN statement will be used before here.  */
 719   __builtin_unreachable ();
 720 }
 721
 722
 723 /*
 724    strlen - returns the length of string.
 725 */
 726
 727 static int strlen_ (M2Dependent_PtrToChar string)
 728 {
 729   int count;
 730
 731   if (string == NULL)
 732     {
 733       return 0;
 734     }
 735   else
 736     {
 737       count = 0;
 738       while ((*string) != ASCII_nul)
 739         {
 740           string += 1;
 741           count += 1;
 742         }
 743       return count;
 744     }
 745   /* static analysis guarentees a RETURN statement will be used before here.  */
 746   __builtin_unreachable ();
 747 }
 748
 749
 750 /*
 751    traceprintf - wrap printf with a boolean flag.
 752 */
 753
 754 static void traceprintf (bool flag, const char *str_, unsigned int _str_high)
 755 {
 756   char str[_str_high+1];
 757
 758   /* make a local copy of each unbounded array.  */
 759   memcpy (str, str_, _str_high+1);
 760
 761   if (flag)
 762     {
 763       toCString ((char *) str, _str_high);
 764       libc_printf ((const char *) str, _str_high);
 765     }
 766 }
 767
 768
 769 /*
 770    traceprintf2 - wrap printf with a boolean flag.
 771 */
 772
 773 static void traceprintf2 (bool flag, const char *str_, unsigned int _str_high, void * arg)
 774 {
 775   char ch;
 776   char str[_str_high+1];
 777
 778   /* make a local copy of each unbounded array.  */
 779   memcpy (str, str_, _str_high+1);
 780
 781   if (flag)
 782     {
 783       toCString ((char *) str, _str_high);
 784       if (arg == NULL)
 785         {
 786           ch = (char) 0;
 787           arg = &ch;
 788         }
 789       libc_printf ((const char *) str, _str_high, arg);
 790     }
 791 }
 792
 793
 794 /*
 795    traceprintf3 - wrap printf with a boolean flag.
 796 */
 797
 798 static void traceprintf3 (bool flag, const char *str_, unsigned int _str_high, void * arg1, void * arg2)
 799 {
 800   char ch;
 801   char str[_str_high+1];
 802
 803   /* make a local copy of each unbounded array.  */
 804   memcpy (str, str_, _str_high+1);
 805
 806   if (flag)
 807     {
 808       toCString ((char *) str, _str_high);
 809       if (arg1 == NULL)
 810         {
 811           ch = (char) 0;
 812           arg1 = &ch;
 813         }
 814       if (arg2 == NULL)
 815         {
 816           ch = (char) 0;
 817           arg2 = &ch;
 818         }
 819       libc_printf ((const char *) str, _str_high, arg1, arg2);
 820     }
 821 }
 822
 823
 824 /*
 825    moveTo - moves mptr to the new list determined by newstate.
 826             It updates the mptr state appropriately.
 827 */
 828
 829 static void moveTo (M2Dependent_DependencyState newstate, M2Dependent_ModuleChain mptr)
 830 {
 831   if (onChain (mptr->dependency.state, mptr))
 832     {
 833       RemoveModule (&Modules.array[mptr->dependency.state-M2Dependent_unregistered], mptr);
 834     }
 835   mptr->dependency.state = newstate;
 836   AppendModule (&Modules.array[mptr->dependency.state-M2Dependent_unregistered], mptr);
 837 }
 838
 839
 840 /*
 841    ResolveDependant -
 842 */
 843
 844 static void ResolveDependant (M2Dependent_ModuleChain mptr, void * currentmodule, void * libname)
 845 {
 846   if (mptr == NULL)
 847     {
 848       traceprintf3 (DependencyTrace, (const char *) "   module %s [%s] has not been registered via a global constructor\\n", 68, currentmodule, libname);
 849     }
 850   else
 851     {
 852       if (onChain (M2Dependent_started, mptr))
 853         {
 854           traceprintf (DependencyTrace, (const char *) "   processing...\\n", 18);
 855         }
 856       else
 857         {
 858           moveTo (M2Dependent_started, mptr);
 859           traceprintf3 (DependencyTrace, (const char *) "   starting: %s [%s]\\n", 22, currentmodule, libname);
 860           (*mptr->dependency.proc.proc) ();  /* Invoke and process the dependency graph.  */
 861           traceprintf3 (DependencyTrace, (const char *) "   finished: %s [%s]\\n", 22, currentmodule, libname);  /* Invoke and process the dependency graph.  */
 862           moveTo (M2Dependent_ordered, mptr);
 863         }
 864     }
 865 }
 866
 867
 868 /*
 869    PerformRequestDependant - the current modulename has a dependancy upon
 870                              dependantmodule.  If dependantmodule is NIL then
 871                              modulename has no further dependants and it can be
 872                              resolved.
 873 */
 874
 875 static void PerformRequestDependant (void * modulename, void * libname, void * dependantmodule, void * dependantlibname)
 876 {
 877   M2Dependent_ModuleChain mptr;
 878
 879   traceprintf3 (DependencyTrace, (const char *) "  module %s [%s]", 16, modulename, libname);
 880   if (dependantmodule == NULL)
 881     {
 882       /* avoid dangling else.  */
 883       traceprintf (DependencyTrace, (const char *) " has finished its import graph\\n", 32);
 884       mptr = LookupModule (M2Dependent_unordered, modulename, libname);
 885       if (mptr != NULL)
 886         {
 887           traceprintf3 (DependencyTrace, (const char *) "  module %s [%s] is now ordered\\n", 33, modulename, libname);
 888           moveTo (M2Dependent_ordered, mptr);
 889         }
 890     }
 891   else
 892     {
 893       traceprintf3 (DependencyTrace, (const char *) " imports from %s [%s]\\n", 23, dependantmodule, dependantlibname);
 894       mptr = LookupModule (M2Dependent_ordered, dependantmodule, dependantlibname);
 895       if (mptr == NULL)
 896         {
 897           traceprintf3 (DependencyTrace, (const char *) "  module %s [%s] is not ordered\\n", 33, dependantmodule, dependantlibname);
 898           mptr = LookupModule (M2Dependent_unordered, dependantmodule, dependantlibname);
 899           if (mptr == NULL)
 900             {
 901               traceprintf3 (DependencyTrace, (const char *) "  module %s [%s] is not unordered\\n", 35, dependantmodule, dependantlibname);
 902               mptr = LookupModule (M2Dependent_started, dependantmodule, dependantlibname);
 903               if (mptr == NULL)
 904                 {
 905                   traceprintf3 (DependencyTrace, (const char *) "  module %s [%s] has not started\\n", 34, dependantmodule, dependantlibname);
 906                   traceprintf3 (DependencyTrace, (const char *) "  module %s [%s] attempting to import from", 42, modulename, libname);
 907                   traceprintf3 (DependencyTrace, (const char *) " %s [%s] which has not registered itself via a constructor\\n", 60, dependantmodule, dependantlibname);
 908                 }
 909               else
 910                 {
 911                   traceprintf3 (DependencyTrace, (const char *) "  module %s [%s] has registered itself and has started\\n", 56, dependantmodule, dependantlibname);
 912                 }
 913             }
 914           else
 915             {
 916               traceprintf3 (DependencyTrace, (const char *) "  module %s [%s] resolving\\n", 28, dependantmodule, dependantlibname);
 917               ResolveDependant (mptr, dependantmodule, dependantlibname);
 918             }
 919         }
 920       else
 921         {
 922           traceprintf3 (DependencyTrace, (const char *) "  module %s [%s]", 16, modulename, libname);
 923           traceprintf3 (DependencyTrace, (const char *) " dependant %s [%s] is ordered\\n", 31, dependantmodule, dependantlibname);
 924         }
 925     }
 926 }
 927
 928
 929 /*
 930    ResolveDependencies - resolve dependencies for currentmodule, libname.
 931 */
 932
 933 static void ResolveDependencies (void * currentmodule, void * libname)
 934 {
 935   M2Dependent_ModuleChain mptr;
 936
 937   mptr = LookupModule (M2Dependent_unordered, currentmodule, libname);
 938   while (mptr != NULL)
 939     {
 940       traceprintf3 (DependencyTrace, (const char *) "   attempting to resolve the dependants for %s [%s]\\n", 53, currentmodule, libname);
 941       ResolveDependant (mptr, currentmodule, libname);
 942       mptr = Modules.array[M2Dependent_unordered-M2Dependent_unregistered];
 943     }
 944 }
 945
 946
 947 /*
 948    DisplayModuleInfo - displays all module in the state.
 949 */
 950
 951 static void DisplayModuleInfo (M2Dependent_DependencyState state, const char *desc_, unsigned int _desc_high)
 952 {
 953   M2Dependent_ModuleChain mptr;
 954   unsigned int count;
 955   char desc[_desc_high+1];
 956
 957   /* make a local copy of each unbounded array.  */
 958   memcpy (desc, desc_, _desc_high+1);
 959
 960   if (Modules.array[state-M2Dependent_unregistered] != NULL)
 961     {
 962       libc_printf ((const char *) "%s modules\\n", 12, const_cast<void*> (static_cast<const void*>(desc)));
 963       mptr = Modules.array[state-M2Dependent_unregistered];
 964       count = 0;
 965       do {
 966         if (mptr->name == NULL)
 967           {
 968             libc_printf ((const char *) "  %d  %s []", 11, count, mptr->name);
 969           }
 970         else
 971           {
 972             libc_printf ((const char *) "  %d  %s [%s]", 13, count, mptr->name, mptr->libname);
 973           }
 974         count += 1;
 975         if (mptr->dependency.appl)
 976           {
 977             libc_printf ((const char *) " application", 12);
 978           }
 979         if (mptr->dependency.forc)
 980           {
 981             libc_printf ((const char *) " for C", 6);
 982           }
 983         if (mptr->dependency.forced)
 984           {
 985             libc_printf ((const char *) " forced ordering", 16);
 986           }
 987         libc_printf ((const char *) "\\n", 2);
 988         mptr = mptr->next;
 989       } while (! (mptr == Modules.array[state-M2Dependent_unregistered]));
 990     }
 991 }
 992
 993
 994 /*
 995    DumpModuleData -
 996 */
 997
 998 static void DumpModuleData (bool flag)
 999 {
1000   if (flag)
1001     {
1002       DisplayModuleInfo (M2Dependent_unregistered, (const char *) "unregistered", 12);
1003       DisplayModuleInfo (M2Dependent_unordered, (const char *) "unordered", 9);
1004       DisplayModuleInfo (M2Dependent_started, (const char *) "started", 7);
1005       DisplayModuleInfo (M2Dependent_ordered, (const char *) "ordered", 7);
1006     }
1007 }
1008
1009
1010 /*
1011    combine - dest := src + dest.  Places src at the front of list dest.
1012              Pre condition:  src, dest are lists.
1013              Post condition : dest := src + dest
1014                               src := NIL.
1015 */
1016
1017 static void combine (M2Dependent_DependencyState src, M2Dependent_DependencyState dest)
1018 {
1019   M2Dependent_ModuleChain last;
1020
1021   while (Modules.array[src-M2Dependent_unregistered] != NULL)
1022     {
1023       last = Modules.array[src-M2Dependent_unregistered]->prev;
1024       moveTo (M2Dependent_ordered, last);
1025       Modules.array[dest-M2Dependent_unregistered] = last;  /* New item is at the head.  */
1026     }
1027 }
1028
1029
1030 /*
1031    tracemodule -
1032 */
1033
1034 static void tracemodule (bool flag, void * modname, unsigned int modlen, void * libname, unsigned int liblen)
1035 {
1036   typedef struct tracemodule__T5_a tracemodule__T5;
1037
1038   struct tracemodule__T5_a { char array[100+1]; };
1039   tracemodule__T5 buffer;
1040   unsigned int len;
1041
1042   if (flag)
1043     {
1044       len = min (modlen, sizeof (buffer)-1);
1045       libc_strncpy (&buffer, modname, len);
1046       buffer.array[len] = (char) 0;
1047       libc_printf ((const char *) "%s ", 3, &buffer);
1048       len = min (liblen, sizeof (buffer)-1);
1049       libc_strncpy (&buffer, libname, len);
1050       buffer.array[len] = (char) 0;
1051       libc_printf ((const char *) " [%s]", 5, &buffer);
1052     }
1053 }
1054
1055
1056 /*
1057    ForceModule -
1058 */
1059
1060 static void ForceModule (void * modname, unsigned int modlen, void * libname, unsigned int liblen)
1061 {
1062   M2Dependent_ModuleChain mptr;
1063
1064   traceprintf (ForceTrace, (const char *) "forcing module: ", 16);
1065   tracemodule (ForceTrace, modname, modlen, libname, liblen);
1066   traceprintf (ForceTrace, (const char *) "\\n", 2);
1067   mptr = LookupModuleN (M2Dependent_ordered, modname, modlen, libname, liblen);
1068   if (mptr != NULL)
1069     {
1070       mptr->dependency.forced = true;
1071       moveTo (M2Dependent_user, mptr);
1072     }
1073 }
1074
1075
1076 /*
1077    ForceDependencies - if the user has specified a forced order then we override
1078                        the dynamic ordering with the preference.
1079 */
1080
1081 static void ForceDependencies (void * overrideliborder)
1082 {
1083   unsigned int len;
1084   unsigned int modlen;
1085   unsigned int liblen;
1086   M2Dependent_PtrToChar modname;
1087   M2Dependent_PtrToChar libname;
1088   M2Dependent_PtrToChar pc;
1089   M2Dependent_PtrToChar start;
1090
1091   if (overrideliborder != NULL)
1092     {
1093       traceprintf2 (ForceTrace, (const char *) "user forcing order: %s\\n", 24, overrideliborder);
1094       pc = static_cast<M2Dependent_PtrToChar> (overrideliborder);
1095       start = pc;
1096       len = 0;
1097       modname = NULL;
1098       modlen = 0;
1099       libname = NULL;
1100       liblen = 0;
1101       while ((*pc) != ASCII_nul)
1102         {
1103           switch ((*pc))
1104             {
1105               case ':':
1106                 libname = start;
1107                 liblen = len;
1108                 len = 0;
1109                 pc += 1;
1110                 start = pc;
1111                 break;
1112
1113               case ',':
1114                 modname = start;
1115                 modlen = len;
1116                 ForceModule (reinterpret_cast <void *> (modname), modlen, reinterpret_cast <void *> (libname), liblen);
1117                 libname = NULL;
1118                 liblen = 0;
1119                 modlen = 0;
1120                 len = 0;
1121                 pc += 1;
1122                 start = pc;
1123                 break;
1124
1125
1126               default:
1127                 pc += 1;
1128                 len += 1;
1129                 break;
1130             }
1131         }
1132       if (start != pc)
1133         {
1134           ForceModule (reinterpret_cast <void *> (start), len, reinterpret_cast <void *> (libname), liblen);
1135         }
1136       combine (M2Dependent_user, M2Dependent_ordered);
1137     }
1138 }
1139
1140
1141 /*
1142    CheckApplication - check to see that the application is the last entry in the list.
1143                       This might happen if the application only imports FOR C modules.
1144 */
1145
1146 static void CheckApplication (void)
1147 {
1148   M2Dependent_ModuleChain mptr;
1149   M2Dependent_ModuleChain appl;
1150
1151   mptr = Modules.array[M2Dependent_ordered-M2Dependent_unregistered];
1152   if (mptr != NULL)
1153     {
1154       appl = NULL;
1155       do {
1156         if (mptr->dependency.appl)
1157           {
1158             appl = mptr;
1159           }
1160         else
1161           {
1162             mptr = mptr->next;
1163           }
1164       } while (! ((appl != NULL) || (mptr == Modules.array[M2Dependent_ordered-M2Dependent_unregistered])));
1165       if (appl != NULL)
1166         {
1167           RemoveModule (&Modules.array[M2Dependent_ordered-M2Dependent_unregistered], appl);
1168           AppendModule (&Modules.array[M2Dependent_ordered-M2Dependent_unregistered], appl);
1169         }
1170     }
1171 }
1172
1173
1174 /*
1175    warning3 - write format arg1 arg2 to stderr.
1176 */
1177
1178 static void warning3 (const char *format_, unsigned int _format_high, void * arg1, void * arg2)
1179 {
1180   typedef struct warning3__T6_a warning3__T6;
1181
1182   struct warning3__T6_a { char array[4096+1]; };
1183   warning3__T6 buffer;
1184   int len;
1185   char format[_format_high+1];
1186
1187   /* make a local copy of each unbounded array.  */
1188   memcpy (format, format_, _format_high+1);
1189
1190   if (WarningTrace)
1191     {
1192       len = libc_snprintf (&buffer, static_cast<size_t> (sizeof (buffer)), (const char *) "warning: ", 9);
1193       libc_write (2, &buffer, static_cast<size_t> (len));
1194       len = libc_snprintf (&buffer, static_cast<size_t> (sizeof (buffer)), (const char *) format, _format_high, arg1, arg2);
1195       libc_write (2, &buffer, static_cast<size_t> (len));
1196     }
1197 }
1198
1199
1200 /*
1201    equal - return TRUE if C string cstr is equal to str.
1202 */
1203
1204 static bool equal (void * cstr, const char *str_, unsigned int _str_high)
1205 {
1206   char str[_str_high+1];
1207
1208   /* make a local copy of each unbounded array.  */
1209   memcpy (str, str_, _str_high+1);
1210
1211   return (strncmp (reinterpret_cast <M2Dependent_PtrToChar> (cstr), reinterpret_cast <M2Dependent_PtrToChar> (const_cast<void*> (static_cast<const void*>(str))), StrLib_StrLen ((const char *) str, _str_high))) == 0;
1212   /* static analysis guarentees a RETURN statement will be used before here.  */
1213   __builtin_unreachable ();
1214 }
1215
1216
1217 /*
1218    SetupDebugFlags - By default assigns ModuleTrace, DependencyTrace,
1219                      DumpPostInit to FALSE.  It checks the environment
1220                      GCC_M2LINK_RTFLAG which can contain
1221                      "all,module,hex,pre,post,dep,force".  all turns them all on.
1222                      The flag meanings are as follows and flags the are in
1223                      execution order.
1224
1225                      module   generate trace info as the modules are registered.
1226                      hex      dump the modules ctor functions address in hex.
1227                      pre      generate a list of all modules seen prior to having
1228                               their dependancies resolved.
1229                      dep      display a trace as the modules are resolved.
1230                      post     generate a list of all modules seen after having
1231                               their dependancies resolved dynamically.
1232                      force    generate a list of all modules seen after having
1233                               their dependancies resolved and forced.
1234 */
1235
1236 static void SetupDebugFlags (void)
1237 {
1238   typedef char *SetupDebugFlags__T1;
1239
1240   SetupDebugFlags__T1 pc;
1241
1242   ModuleTrace = false;
1243   DependencyTrace = false;
1244   PostTrace = false;
1245   PreTrace = false;
1246   ForceTrace = false;
1247   HexTrace = false;
1248   WarningTrace = false;
1249   pc = static_cast<SetupDebugFlags__T1> (libc_getenv (const_cast<void*> (static_cast<const void*>("GCC_M2LINK_RTFLAG"))));
1250   while ((pc != NULL) && ((*pc) != ASCII_nul))
1251     {
1252       if (equal (reinterpret_cast <void *> (pc), (const char *) "all", 3))
1253         {
1254           ModuleTrace = true;
1255           DependencyTrace = true;
1256           PreTrace = true;
1257           PostTrace = true;
1258           ForceTrace = true;
1259           HexTrace = true;
1260           WarningTrace = true;
1261           pc += 3;
1262         }
1263       else if (equal (reinterpret_cast <void *> (pc), (const char *) "module", 6))
1264         {
1265           /* avoid dangling else.  */
1266           ModuleTrace = true;
1267           pc += 6;
1268         }
1269       else if (equal (reinterpret_cast <void *> (pc), (const char *) "warning", 7))
1270         {
1271           /* avoid dangling else.  */
1272           WarningTrace = true;
1273           pc += 7;
1274         }
1275       else if (equal (reinterpret_cast <void *> (pc), (const char *) "hex", 3))
1276         {
1277           /* avoid dangling else.  */
1278           HexTrace = true;
1279           pc += 3;
1280         }
1281       else if (equal (reinterpret_cast <void *> (pc), (const char *) "dep", 3))
1282         {
1283           /* avoid dangling else.  */
1284           DependencyTrace = true;
1285           pc += 3;
1286         }
1287       else if (equal (reinterpret_cast <void *> (pc), (const char *) "pre", 3))
1288         {
1289           /* avoid dangling else.  */
1290           PreTrace = true;
1291           pc += 3;
1292         }
1293       else if (equal (reinterpret_cast <void *> (pc), (const char *) "post", 4))
1294         {
1295           /* avoid dangling else.  */
1296           PostTrace = true;
1297           pc += 4;
1298         }
1299       else if (equal (reinterpret_cast <void *> (pc), (const char *) "force", 5))
1300         {
1301           /* avoid dangling else.  */
1302           ForceTrace = true;
1303           pc += 5;
1304         }
1305       else
1306         {
1307           /* avoid dangling else.  */
1308           pc += 1;
1309         }
1310     }
1311 }
1312
1313
1314 /*
1315    Init - initialize the debug flags and set all lists to NIL.
1316 */
1317
1318 static void Init (void)
1319 {
1320   M2Dependent_DependencyState state;
1321
1322   InitProcList (&InitialProc);
1323   InitProcList (&TerminateProc);
1324   SetupDebugFlags ();
1325   for (state=M2Dependent_unregistered; state<=M2Dependent_user; state= static_cast<M2Dependent_DependencyState>(static_cast<int>(state+1)))
1326     {
1327       Modules.array[state-M2Dependent_unregistered] = NULL;
1328     }
1329   DynamicInitialization = false;
1330 }
1331
1332
1333 /*
1334    CheckInitialized - checks to see if this module has been initialized
1335                       and if it has not it calls Init.  We need this
1336                       approach as this module is called by module ctors
1337                       before we reach main.
1338 */
1339
1340 static void CheckInitialized (void)
1341 {
1342   if (! Initialized)
1343     {
1344       Initialized = true;
1345       Init ();
1346     }
1347 }
1348
1349
1350 /*
1351    ExecuteReverse - execute the procedure associated with procptr
1352                     and then proceed to try and execute all previous
1353                     procedures in the chain.
1354 */
1355
1356 static void ExecuteReverse (M2Dependent_ProcedureChain procptr)
1357 {
1358   while (procptr != NULL)
1359     {
1360       (*procptr->p.proc) ();  /* Invoke the procedure.  */
1361       procptr = procptr->prev;  /* Invoke the procedure.  */
1362     }
1363 }
1364
1365
1366 /*
1367    AppendProc - append proc to the end of the procedure list
1368                 defined by proclist.
1369 */
1370
1371 static bool AppendProc (M2Dependent_ProcedureList *proclist, PROC proc)
1372 {
1373   M2Dependent_ProcedureChain pdes;
1374
1375   Storage_ALLOCATE ((void **) &pdes, sizeof (M2Dependent__T3));
1376   pdes->p = proc;
1377   pdes->prev = (*proclist).tail;
1378   pdes->next = NULL;
1379   if ((*proclist).head == NULL)
1380     {
1381       (*proclist).head = pdes;
1382     }
1383   (*proclist).tail = pdes;
1384   return true;
1385   /* static analysis guarentees a RETURN statement will be used before here.  */
1386   __builtin_unreachable ();
1387 }
1388
1389
1390 /*
1391    InitProcList - initialize the head and tail pointers to NIL.
1392 */
1393
1394 static void InitProcList (M2Dependent_ProcedureList *p)
1395 {
1396   (*p).head = NULL;
1397   (*p).tail = NULL;
1398 }
1399
1400
1401 /*
1402    ConstructModules - resolve dependencies and then call each
1403                       module constructor in turn.
1404 */
1405
1406 extern "C" void M2Dependent_ConstructModules (void * applicationmodule, void * libname, void * overrideliborder, int argc, void * argv, void * envp)
1407 {
1408   M2Dependent_ModuleChain mptr;
1409
1410   CheckInitialized ();
1411   DynamicInitialization = true;  /* This procedure is only called if we desire dynamic initialization.  */
1412   traceprintf3 (ModuleTrace, (const char *) "application module: %s [%s]\\n", 29, applicationmodule, libname);  /* This procedure is only called if we desire dynamic initialization.  */
1413   mptr = LookupModule (M2Dependent_unordered, applicationmodule, libname);
1414   if (mptr != NULL)
1415     {
1416       mptr->dependency.appl = true;
1417     }
1418   traceprintf (PreTrace, (const char *) "Pre resolving dependents\\n", 26);
1419   DumpModuleData (PreTrace);
1420   ResolveDependencies (applicationmodule, libname);
1421   traceprintf (PreTrace, (const char *) "Post resolving dependents\\n", 27);
1422   DumpModuleData (PostTrace);
1423   ForceDependencies (overrideliborder);
1424   traceprintf (ForceTrace, (const char *) "After user forcing ordering\\n", 29);
1425   DumpModuleData (ForceTrace);
1426   CheckApplication ();
1427   traceprintf (ForceTrace, (const char *) "After runtime forces application to the end\\n", 45);
1428   DumpModuleData (ForceTrace);
1429   if (Modules.array[M2Dependent_ordered-M2Dependent_unregistered] == NULL)
1430     {
1431       traceprintf3 (ModuleTrace, (const char *) "  module: %s [%s] has not registered itself using a global constructor\\n", 72, applicationmodule, libname);
1432       traceprintf2 (ModuleTrace, (const char *) "  hint try compile and linking using: gm2 %s.mod\\n", 50, applicationmodule);
1433       traceprintf2 (ModuleTrace, (const char *) "  or try using: gm2 -fscaffold-static %s.mod\\n", 46, applicationmodule);
1434     }
1435   else
1436     {
1437       mptr = Modules.array[M2Dependent_ordered-M2Dependent_unregistered];
1438       do {
1439         if (mptr->dependency.forc)
1440           {
1441             traceprintf3 (ModuleTrace, (const char *) "initializing module: %s [%s] for C\\n", 36, mptr->name, mptr->libname);
1442           }
1443         else
1444           {
1445             traceprintf3 (ModuleTrace, (const char *) "initializing module: %s [%s]\\n", 30, mptr->name, mptr->libname);
1446           }
1447         if (mptr->dependency.appl)
1448           {
1449             traceprintf3 (ModuleTrace, (const char *) "application module: %s [%s]\\n", 29, mptr->name, mptr->libname);
1450             traceprintf (ModuleTrace, (const char *) "  calling ExecuteInitialProcedures\\n", 36);
1451             M2Dependent_ExecuteInitialProcedures ();
1452             traceprintf (ModuleTrace, (const char *) "  calling application module\\n", 30);
1453           }
1454         (*mptr->init.proc) (argc, argv, envp);
1455         mptr = mptr->next;
1456       } while (! (mptr == Modules.array[M2Dependent_ordered-M2Dependent_unregistered]));
1457     }
1458 }
1459
1460
1461 /*
1462    DeconstructModules - resolve dependencies and then call each
1463                         module constructor in turn.
1464 */
1465
1466 extern "C" void M2Dependent_DeconstructModules (void * applicationmodule, void * libname, int argc, void * argv, void * envp)
1467 {
1468   M2Dependent_ModuleChain mptr;
1469
1470   traceprintf3 (ModuleTrace, (const char *) "application module finishing: %s [%s]\\n", 39, applicationmodule, libname);
1471   if (Modules.array[M2Dependent_ordered-M2Dependent_unregistered] == NULL)
1472     {
1473       traceprintf (ModuleTrace, (const char *) "  no ordered modules found during finishing\\n", 45);
1474     }
1475   else
1476     {
1477       traceprintf (ModuleTrace, (const char *) "ExecuteTerminationProcedures\\n", 30);
1478       M2Dependent_ExecuteTerminationProcedures ();
1479       traceprintf (ModuleTrace, (const char *) "terminating modules in sequence\\n", 33);
1480       mptr = Modules.array[M2Dependent_ordered-M2Dependent_unregistered]->prev;
1481       do {
1482         if (mptr->dependency.forc)
1483           {
1484             traceprintf3 (ModuleTrace, (const char *) "finalizing module: %s [%s] for C\\n", 34, mptr->name, mptr->libname);
1485           }
1486         else
1487           {
1488             traceprintf3 (ModuleTrace, (const char *) "finalizing module: %s [%s]\\n", 28, mptr->name, mptr->libname);
1489           }
1490         (*mptr->fini.proc) (argc, argv, envp);
1491         mptr = mptr->prev;
1492       } while (! (mptr == Modules.array[M2Dependent_ordered-M2Dependent_unregistered]->prev));
1493     }
1494 }
1495
1496
1497 /*
1498    RegisterModule - adds module name to the list of outstanding
1499                     modules which need to have their dependencies
1500                     explored to determine initialization order.
1501 */
1502
1503 extern "C" void M2Dependent_RegisterModule (void * modulename, void * libname, M2Dependent_ArgCVEnvP init, M2Dependent_ArgCVEnvP fini, PROC dependencies)
1504 {
1505   M2Dependent_ModuleChain mptr;
1506
1507   CheckInitialized ();
1508   mptr = LookupModule (M2Dependent_unordered, modulename, libname);
1509   if (mptr == NULL)
1510     {
1511       traceprintf3 (ModuleTrace, (const char *) "module: %s [%s] registering", 27, modulename, libname);
1512       moveTo (M2Dependent_unordered, CreateModule (modulename, libname, init, fini, dependencies));
1513       traceprintf (ModuleTrace, (const char *) "\\n", 2);
1514     }
1515   else
1516     {
1517       warning3 ((const char *) "module: %s [%s] (ignoring duplicate registration)\\n", 51, modulename, libname);
1518     }
1519 }
1520
1521
1522 /*
1523    RequestDependant - used to specify that modulename is dependant upon
1524                       module dependantmodule.  It only takes effect
1525                       if we are using DynamicInitialization.
1526 */
1527
1528 extern "C" void M2Dependent_RequestDependant (void * modulename, void * libname, void * dependantmodule, void * dependantlibname)
1529 {
1530   CheckInitialized ();
1531   PerformRequestDependant (modulename, libname, dependantmodule, dependantlibname);
1532 }
1533
1534
1535 /*
1536    InstallTerminationProcedure - installs a procedure, p, which will
1537                                  be called when the procedure
1538                                  ExecuteTerminationProcedures
1539                                  is invoked.  It returns TRUE if the
1540                                  procedure is installed.
1541 */
1542
1543 extern "C" bool M2Dependent_InstallTerminationProcedure (PROC p)
1544 {
1545   return AppendProc (&TerminateProc, p);
1546   /* static analysis guarentees a RETURN statement will be used before here.  */
1547   __builtin_unreachable ();
1548 }
1549
1550
1551 /*
1552    ExecuteInitialProcedures - executes the initial procedures installed by
1553                               InstallInitialProcedure.
1554 */
1555
1556 extern "C" void M2Dependent_ExecuteInitialProcedures (void)
1557 {
1558   ExecuteReverse (InitialProc.tail);
1559 }
1560
1561
1562 /*
1563    InstallInitialProcedure - installs a procedure to be executed just
1564                              before the BEGIN code section of the
1565                              main program module.
1566 */
1567
1568 extern "C" bool M2Dependent_InstallInitialProcedure (PROC p)
1569 {
1570   return AppendProc (&InitialProc, p);
1571   /* static analysis guarentees a RETURN statement will be used before here.  */
1572   __builtin_unreachable ();
1573 }
1574
1575
1576 /*
1577    ExecuteTerminationProcedures - calls each installed termination procedure
1578                                   in reverse order.
1579 */
1580
1581 extern "C" void M2Dependent_ExecuteTerminationProcedures (void)
1582 {
1583   ExecuteReverse (TerminateProc.tail);
1584 }
1585
1586 extern "C" void _M2_M2Dependent_init (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
1587 {
1588   CheckInitialized ();
1589 }
1590
1591 extern "C" void _M2_M2Dependent_fini (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
1592 {
1593 }