libphobos/libdruntime/rt/minfo.d

   1 /**
   2  * Written in the D programming language.
   3  * Module initialization routines.
   4  *
   5  * Copyright: Copyright Digital Mars 2000 - 2013.
   6  * License: Distributed under the
   7  *      $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0).
   8  *    (See accompanying file LICENSE)
   9  * Authors:   Walter Bright, Sean Kelly
  10  * Source: $(DRUNTIMESRC src/rt/_minfo.d)
  11  */
  12
  13 module rt.minfo;
  14
  15 import core.stdc.stdlib;  // alloca
  16 import core.stdc.string;  // memcpy
  17 import rt.sections;
  18
  19 enum
  20 {
  21     MIctorstart  = 0x1,   // we've started constructing it
  22     MIctordone   = 0x2,   // finished construction
  23     MIstandalone = 0x4,   // module ctor does not depend on other module
  24                         // ctors being done first
  25     MItlsctor    = 8,
  26     MItlsdtor    = 0x10,
  27     MIctor       = 0x20,
  28     MIdtor       = 0x40,
  29     MIxgetMembers = 0x80,
  30     MIictor      = 0x100,
  31     MIunitTest   = 0x200,
  32     MIimportedModules = 0x400,
  33     MIlocalClasses = 0x800,
  34     MIname       = 0x1000,
  35 }
  36
  37 /*****
  38  * A ModuleGroup is an unordered collection of modules.
  39  * There is exactly one for:
  40  *  1. all statically linked in D modules, either directely or as shared libraries
  41  *  2. each call to rt_loadLibrary()
  42  */
  43
  44 struct ModuleGroup
  45 {
  46     this(immutable(ModuleInfo*)[] modules) nothrow @nogc
  47     {
  48         _modules = modules;
  49     }
  50
  51     @property immutable(ModuleInfo*)[] modules() const nothrow @nogc
  52     {
  53         return _modules;
  54     }
  55
  56     // this function initializes the bookeeping necessary to create the
  57     // cycle path, and then creates it. It is a precondition that src and
  58     // target modules are involved in a cycle.
  59     //
  60     // The return value is malloc'd using C, so it must be freed after use.
  61     private size_t[] genCyclePath(size_t srcidx, size_t targetidx, int[][] edges)
  62     {
  63         import core.bitop : bt, btc, bts;
  64
  65         // set up all the arrays.
  66         size_t[] cyclePath = (cast(size_t*)malloc(size_t.sizeof * _modules.length * 2))[0 .. _modules.length * 2];
  67         size_t totalMods;
  68         int[] distance = (cast(int*)malloc(int.sizeof * _modules.length))[0 .. _modules.length];
  69         scope(exit)
  70             .free(distance.ptr);
  71
  72         // determine the shortest path between two modules. Uses dijkstra
  73         // without a priority queue. (we can be a bit slow here, in order to
  74         // get a better printout).
  75         void shortest(size_t start, size_t target)
  76         {
  77             // initial setup
  78             distance[] = int.max;
  79             int curdist = 0;
  80             distance[start] = 0;
  81             while (true)
  82             {
  83                 bool done = true;
  84                 foreach (i, x; distance)
  85                 {
  86                     if (x == curdist)
  87                     {
  88                         if (i == target)
  89                         {
  90                             done = true;
  91                             break;
  92                         }
  93                         foreach (n; edges[i])
  94                         {
  95                             if (distance[n] == int.max)
  96                             {
  97                                 distance[n] = curdist + 1;
  98                                 done = false;
  99                             }
 100                         }
 101                     }
 102                 }
 103                 if (done)
 104                     break;
 105                 ++curdist;
 106             }
 107             // it should be impossible to not get to target, this is just a
 108             // sanity check. Not an assert, because druntime is compiled in
 109             // release mode.
 110             if (distance[target] != curdist)
 111             {
 112                 throw new Error("internal error printing module cycle");
 113             }
 114
 115             // determine the path. This is tricky, because we have to
 116             // follow the edges in reverse to get back to the original. We
 117             // don't have a reverse mapping, so it takes a bit of looping.
 118             totalMods += curdist;
 119             auto subpath = cyclePath[totalMods - curdist .. totalMods];
 120             while (true)
 121             {
 122                 --curdist;
 123                 subpath[curdist] = target;
 124                 if (curdist == 0)
 125                     break;
 126             distloop:
 127                 // search for next (previous) module in cycle.
 128                 foreach (int m, d; distance)
 129                 {
 130                     if (d == curdist)
 131                     {
 132                         // determine if m can reach target
 133                         foreach (e; edges[m])
 134                         {
 135                             if (e == target)
 136                             {
 137                                 // recurse
 138                                 target = m;
 139                                 break distloop;
 140                             }
 141                         }
 142                     }
 143                 }
 144             }
 145         }
 146
 147         // first get to the target
 148         shortest(srcidx, targetidx);
 149         // now get back.
 150         shortest(targetidx, srcidx);
 151
 152         return cyclePath[0 .. totalMods];
 153     }
 154
 155     /******************************
 156      * Allocate and fill in _ctors[] and _tlsctors[].
 157      * Modules are inserted into the arrays in the order in which the constructors
 158      * need to be run.
 159      *
 160      * Params:
 161      *  cycleHandling - string indicating option for cycle handling
 162      * Throws:
 163      *  Exception if it fails.
 164      */
 165     void sortCtors(string cycleHandling)
 166     {
 167         import core.bitop : bts, btr, bt, BitRange;
 168         import rt.util.container.hashtab;
 169
 170         enum OnCycle
 171         {
 172             deprecate,
 173             abort,
 174             print,
 175             ignore
 176         }
 177
 178         auto onCycle = OnCycle.abort;
 179
 180         switch (cycleHandling) with(OnCycle)
 181         {
 182         case "deprecate":
 183             onCycle = deprecate;
 184             break;
 185         case "abort":
 186             onCycle = abort;
 187             break;
 188         case "print":
 189             onCycle = print;
 190             break;
 191         case "ignore":
 192             onCycle = ignore;
 193             break;
 194         case "":
 195             // no option passed
 196             break;
 197         default:
 198             // invalid cycle handling option.
 199             throw new Error("DRT invalid cycle handling option: " ~ cycleHandling);
 200         }
 201
 202         debug (printModuleDependencies)
 203         {
 204             import core.stdc.stdio : printf;
 205
 206             foreach (_m; _modules)
 207             {
 208                 printf("%s%s%s:", _m.name.ptr, (_m.flags & MIstandalone)
 209                         ? "+".ptr : "".ptr, (_m.flags & (MIctor | MIdtor)) ? "*".ptr : "".ptr);
 210                 foreach (_i; _m.importedModules)
 211                     printf(" %s", _i.name.ptr);
 212                 printf("\n");
 213             }
 214         }
 215
 216         immutable uint len = cast(uint) _modules.length;
 217         if (!len)
 218             return; // nothing to do.
 219
 220         // allocate some stack arrays that will be used throughout the process.
 221         immutable nwords = (len + 8 * size_t.sizeof - 1) / (8 * size_t.sizeof);
 222         immutable flagbytes = nwords * size_t.sizeof;
 223         auto ctorstart = cast(size_t*) malloc(flagbytes); // ctor/dtor seen
 224         auto ctordone = cast(size_t*) malloc(flagbytes); // ctor/dtor processed
 225         auto relevant = cast(size_t*) malloc(flagbytes); // has ctors/dtors
 226         scope (exit)
 227         {
 228             .free(ctorstart);
 229             .free(ctordone);
 230             .free(relevant);
 231         }
 232
 233         void clearFlags(size_t* flags)
 234         {
 235             memset(flags, 0, flagbytes);
 236         }
 237
 238
 239         // build the edges between each module. We may need this for printing,
 240         // and also allows avoiding keeping a hash around for module lookups.
 241         int[][] edges = (cast(int[]*)malloc((int[]).sizeof * _modules.length))[0 .. _modules.length];
 242         {
 243             HashTab!(immutable(ModuleInfo)*, int) modIndexes;
 244             foreach (i, m; _modules)
 245                 modIndexes[m] = cast(int) i;
 246
 247             auto reachable = cast(size_t*) malloc(flagbytes);
 248             scope(exit)
 249                 .free(reachable);
 250
 251             foreach (i, m; _modules)
 252             {
 253                 // use bit array to prevent duplicates
 254                 // https://issues.dlang.org/show_bug.cgi?id=16208
 255                 clearFlags(reachable);
 256                 // preallocate enough space to store all the indexes
 257                 int *edge = cast(int*)malloc(int.sizeof * _modules.length);
 258                 size_t nEdges = 0;
 259                 foreach (imp; m.importedModules)
 260                 {
 261                     if (imp is m) // self-import
 262                         continue;
 263                     if (auto impidx = imp in modIndexes)
 264                     {
 265                         if (!bts(reachable, *impidx))
 266                             edge[nEdges++] = *impidx;
 267                     }
 268                 }
 269                 // trim space to what is needed.
 270                 edges[i] = (cast(int*)realloc(edge, int.sizeof * nEdges))[0 .. nEdges];
 271             }
 272         }
 273
 274         // free all the edges after we are done
 275         scope(exit)
 276         {
 277             foreach (e; edges)
 278                 if (e.ptr)
 279                     .free(e.ptr);
 280             .free(edges.ptr);
 281         }
 282
 283         void buildCycleMessage(size_t sourceIdx, size_t cycleIdx, scope void delegate(string) sink)
 284         {
 285             version (Windows)
 286                 enum EOL = "\r\n";
 287             else
 288                 enum EOL = "\n";
 289
 290             sink("Cyclic dependency between module ");
 291             sink(_modules[sourceIdx].name);
 292             sink(" and ");
 293             sink(_modules[cycleIdx].name);
 294             sink(EOL);
 295             auto cyclePath = genCyclePath(sourceIdx, cycleIdx, edges);
 296             scope(exit) .free(cyclePath.ptr);
 297
 298             sink(_modules[sourceIdx].name);
 299             sink("* ->" ~ EOL);
 300             foreach (x; cyclePath[0 .. $ - 1])
 301             {
 302                 sink(_modules[x].name);
 303                 sink(bt(relevant, x) ? "* ->" ~ EOL : " ->" ~ EOL);
 304             }
 305             sink(_modules[sourceIdx].name);
 306             sink("*" ~ EOL);
 307         }
 308
 309         // find all the non-trivial dependencies (that is, dependencies that have a
 310         // ctor or dtor) of a given module.  Doing this, we can 'skip over' the
 311         // trivial modules to get at the non-trivial ones.
 312         //
 313         // If a cycle is detected, returns the index of the module that completes the cycle.
 314         // Returns: true for success, false for a deprecated cycle error
 315         bool findDeps(size_t idx, size_t* reachable)
 316         {
 317             static struct stackFrame
 318             {
 319                 size_t curMod;
 320                 size_t curDep;
 321             }
 322
 323             // initialize "stack"
 324             auto stack = cast(stackFrame*) malloc(stackFrame.sizeof * len);
 325             scope (exit)
 326                 .free(stack);
 327             auto stacktop = stack + len;
 328             auto sp = stack;
 329             sp.curMod = cast(int) idx;
 330             sp.curDep = 0;
 331
 332             // initialize reachable by flagging source module
 333             clearFlags(reachable);
 334             bts(reachable, idx);
 335
 336             for (;;)
 337             {
 338                 auto m = _modules[sp.curMod];
 339                 if (sp.curDep >= edges[sp.curMod].length)
 340                 {
 341                     // return
 342                     if (sp == stack) // finished the algorithm
 343                         break;
 344                     --sp;
 345                 }
 346                 else
 347                 {
 348                     auto midx = edges[sp.curMod][sp.curDep];
 349                     if (!bts(reachable, midx))
 350                     {
 351                         if (bt(relevant, midx))
 352                         {
 353                             // need to process this node, don't recurse.
 354                             if (bt(ctorstart, midx))
 355                             {
 356                                 // was already started, this is a cycle.
 357                                 final switch (onCycle) with(OnCycle)
 358                                 {
 359                                 case deprecate:
 360                                     // check with old algorithm
 361                                     if (sortCtorsOld(edges))
 362                                     {
 363                                         // unwind to print deprecation message.
 364                                         return false;   // deprecated cycle error
 365                                     }
 366                                     goto case abort; // fall through
 367                                 case abort:
 368
 369                                     string errmsg = "";
 370                                     buildCycleMessage(idx, midx, (string x) {errmsg ~= x;});
 371                                     throw new Error(errmsg, __FILE__, __LINE__);
 372                                 case ignore:
 373                                     break;
 374                                 case print:
 375                                     // print the message
 376                                     buildCycleMessage(idx, midx, (string x) {
 377                                                       import core.stdc.stdio : fprintf, stderr;
 378                                                       fprintf(stderr, "%.*s", cast(int) x.length, x.ptr);
 379                                                       });
 380                                     // continue on as if this is correct.
 381                                     break;
 382                                 }
 383                             }
 384                         }
 385                         else if (!bt(ctordone, midx))
 386                         {
 387                             // non-relevant, and hasn't been exhaustively processed, recurse.
 388                             if (++sp >= stacktop)
 389                             {
 390                                 // stack overflow, this shouldn't happen.
 391                                 import core.internal.abort : abort;
 392
 393                                 abort("stack overflow on dependency search");
 394                             }
 395                             sp.curMod = midx;
 396                             sp.curDep = 0;
 397                             continue;
 398                         }
 399                     }
 400                 }
 401
 402                 // next dependency
 403                 ++sp.curDep;
 404             }
 405             return true; // success
 406         }
 407
 408         // The list of constructors that will be returned by the sorting.
 409         immutable(ModuleInfo)** ctors;
 410         // current element being inserted into ctors list.
 411         size_t ctoridx = 0;
 412
 413         // This function will determine the order of construction/destruction and
 414         // check for cycles. If a cycle is found, the cycle path is transformed
 415         // into a string and thrown as an error.
 416         //
 417         // Each call into this function is given a module that has static
 418         // ctor/dtors that must be dealt with. It recurses only when it finds
 419         // dependencies that also have static ctor/dtors.
 420         // Returns: true for success, false for a deprecated cycle error
 421         bool processMod(size_t curidx)
 422         {
 423             immutable ModuleInfo* current = _modules[curidx];
 424
 425             // First, determine what modules are reachable.
 426             auto reachable = cast(size_t*) malloc(flagbytes);
 427             scope (exit)
 428                 .free(reachable);
 429             if (!findDeps(curidx, reachable))
 430                 return false;   // deprecated cycle error
 431
 432             // process the dependencies. First, we process all relevant ones
 433             bts(ctorstart, curidx);
 434             auto brange = BitRange(reachable, len);
 435             foreach (i; brange)
 436             {
 437                 // note, don't check for cycles here, because the config could have been set to ignore cycles.
 438                 // however, don't recurse if there is one, so still check for started ctor.
 439                 if (i != curidx && bt(relevant, i) && !bt(ctordone, i) && !bt(ctorstart, i))
 440                 {
 441                     if (!processMod(i))
 442                         return false; // deprecated cycle error
 443                 }
 444             }
 445
 446             // now mark this node, and all nodes reachable from this module as done.
 447             bts(ctordone, curidx);
 448             btr(ctorstart, curidx);
 449             foreach (i; brange)
 450             {
 451                 // Since relevant dependencies are already marked as done
 452                 // from recursion above (or are going to be handled up the call
 453                 // stack), no reason to check for relevance, that is a wasted
 454                 // op.
 455                 bts(ctordone, i);
 456             }
 457
 458             // add this module to the construction order list
 459             ctors[ctoridx++] = current;
 460             return true;
 461         }
 462
 463         // returns `false` if deprecated cycle error otherwise set `result`.
 464         bool doSort(size_t relevantFlags, ref immutable(ModuleInfo)*[] result)
 465         {
 466             clearFlags(relevant);
 467             clearFlags(ctorstart);
 468             clearFlags(ctordone);
 469
 470             // pre-allocate enough space to hold all modules.
 471             ctors = (cast(immutable(ModuleInfo)**).malloc(len * (void*).sizeof));
 472             ctoridx = 0;
 473             foreach (int idx, m; _modules)
 474             {
 475                 if (m.flags & relevantFlags)
 476                 {
 477                     if (m.flags & MIstandalone)
 478                     {
 479                         // can run at any time. Just run it first.
 480                         ctors[ctoridx++] = m;
 481                     }
 482                     else
 483                     {
 484                         bts(relevant, idx);
 485                     }
 486                 }
 487             }
 488
 489             // now run the algorithm in the relevant ones
 490             foreach (idx; BitRange(relevant, len))
 491             {
 492                 if (!bt(ctordone, idx))
 493                 {
 494                     if (!processMod(idx))
 495                         return false;
 496                 }
 497             }
 498
 499             if (ctoridx == 0)
 500             {
 501                 // no ctors in the list.
 502                 .free(ctors);
 503             }
 504             else
 505             {
 506                 ctors = cast(immutable(ModuleInfo)**).realloc(ctors, ctoridx * (void*).sizeof);
 507                 if (ctors is null)
 508                     assert(0);
 509                 result = ctors[0 .. ctoridx];
 510             }
 511             return true;
 512         }
 513
 514         // finally, do the sorting for both shared and tls ctors. If either returns false,
 515         // print the deprecation warning.
 516         if (!doSort(MIctor | MIdtor, _ctors) ||
 517             !doSort(MItlsctor | MItlsdtor, _tlsctors))
 518         {
 519             // print a warning
 520             import core.stdc.stdio : fprintf, stderr;
 521             fprintf(stderr, "Deprecation 16211 warning:\n"
 522                 ~ "A cycle has been detected in your program that was undetected prior to DMD\n"
 523                 ~ "2.072. This program will continue, but will not operate when using DMD 2.074\n"
 524                 ~ "to compile. Use runtime option --DRT-oncycle=print to see the cycle details.\n");
 525
 526         }
 527     }
 528
 529     /// ditto
 530     void sortCtors()
 531     {
 532         import rt.config : rt_configOption;
 533         sortCtors(rt_configOption("oncycle"));
 534     }
 535
 536     /******************************
 537      * This is the old ctor sorting algorithm that does not find all cycles.
 538      *
 539      * It is here to allow the deprecated behavior from the original algorithm
 540      * until people have fixed their code.
 541      *
 542      * If no cycles are found, the _ctors and _tlsctors are replaced with the
 543      * ones generated by this algorithm to preserve the old incorrect ordering
 544      * behavior.
 545      *
 546      * Params:
 547      *   edges - The module edges as found in the `importedModules` member of
 548      *          each ModuleInfo. Generated in sortCtors.
 549      * Returns:
 550      *   true if no cycle is found, false if one was.
 551      */
 552     bool sortCtorsOld(int[][] edges)
 553     {
 554         immutable len = edges.length;
 555         assert(len == _modules.length);
 556
 557         static struct StackRec
 558         {
 559             @property int mod()
 560             {
 561                 return _mods[_idx];
 562             }
 563
 564             int[] _mods;
 565             size_t         _idx;
 566         }
 567
 568         auto stack = (cast(StackRec*).calloc(len, StackRec.sizeof))[0 .. len];
 569         // TODO: reuse GCBits by moving it to rt.util.container or core.internal
 570         immutable nwords = (len + 8 * size_t.sizeof - 1) / (8 * size_t.sizeof);
 571         auto ctorstart = cast(size_t*).malloc(nwords * size_t.sizeof);
 572         auto ctordone = cast(size_t*).malloc(nwords * size_t.sizeof);
 573         int[] initialEdges = (cast(int *)malloc(int.sizeof * len))[0 .. len];
 574         if (!stack.ptr || ctorstart is null || ctordone is null || !initialEdges.ptr)
 575             assert(0);
 576         scope (exit)
 577         {
 578             .free(stack.ptr);
 579             .free(ctorstart);
 580             .free(ctordone);
 581             .free(initialEdges.ptr);
 582         }
 583
 584         // initialize the initial edges
 585         foreach (int i, ref v; initialEdges)
 586             v = i;
 587
 588         bool sort(ref immutable(ModuleInfo)*[] ctors, uint mask)
 589         {
 590             import core.bitop;
 591
 592             ctors = (cast(immutable(ModuleInfo)**).malloc(len * size_t.sizeof))[0 .. len];
 593             if (!ctors.ptr)
 594                 assert(0);
 595
 596             // clean flags
 597             memset(ctorstart, 0, nwords * size_t.sizeof);
 598             memset(ctordone, 0, nwords * size_t.sizeof);
 599             size_t stackidx = 0;
 600             size_t cidx;
 601
 602             int[] mods = initialEdges;
 603
 604             size_t idx;
 605             while (true)
 606             {
 607                 while (idx < mods.length)
 608                 {
 609                     auto m = mods[idx];
 610
 611                     if (bt(ctordone, m))
 612                     {
 613                         // this module has already been processed, skip
 614                         ++idx;
 615                         continue;
 616                     }
 617                     else if (bt(ctorstart, m))
 618                     {
 619                         /* Trace back to the begin of the cycle.
 620                          */
 621                         bool ctorInCycle;
 622                         size_t start = stackidx;
 623                         while (start--)
 624                         {
 625                             auto sm = stack[start].mod;
 626                             if (sm == m)
 627                                 break;
 628                             assert(sm >= 0);
 629                             if (bt(ctorstart, sm))
 630                                 ctorInCycle = true;
 631                         }
 632                         assert(stack[start].mod == m);
 633                         if (ctorInCycle)
 634                         {
 635                             return false;
 636                         }
 637                         else
 638                         {
 639                             /* This is also a cycle, but the import chain does not constrain
 640                              * the order of initialization, either because the imported
 641                              * modules have no ctors or the ctors are standalone.
 642                              */
 643                             ++idx;
 644                         }
 645                     }
 646                     else
 647                     {
 648                         auto curmod = _modules[m];
 649                         if (curmod.flags & mask)
 650                         {
 651                             if (curmod.flags & MIstandalone || !edges[m].length)
 652                             {   // trivial ctor => sort in
 653                                 ctors[cidx++] = curmod;
 654                                 bts(ctordone, m);
 655                             }
 656                             else
 657                             {   // non-trivial ctor => defer
 658                                 bts(ctorstart, m);
 659                             }
 660                         }
 661                         else    // no ctor => mark as visited
 662                         {
 663                             bts(ctordone, m);
 664                         }
 665
 666                         if (edges[m].length)
 667                         {
 668                             /* Internal runtime error, recursion exceeds number of modules.
 669                              */
 670                             (stackidx < len) || assert(0);
 671
 672                             // recurse
 673                             stack[stackidx++] = StackRec(mods, idx);
 674                             idx  = 0;
 675                             mods = edges[m];
 676                         }
 677                     }
 678                 }
 679
 680                 if (stackidx)
 681                 {   // pop old value from stack
 682                     --stackidx;
 683                     mods    = stack[stackidx]._mods;
 684                     idx     = stack[stackidx]._idx;
 685                     auto m  = mods[idx++];
 686                     if (bt(ctorstart, m) && !bts(ctordone, m))
 687                         ctors[cidx++] = _modules[m];
 688                 }
 689                 else // done
 690                     break;
 691             }
 692             // store final number and shrink array
 693             ctors = (cast(immutable(ModuleInfo)**).realloc(ctors.ptr, cidx * size_t.sizeof))[0 .. cidx];
 694             return true;
 695         }
 696
 697         /* Do two passes: ctor/dtor, tlsctor/tlsdtor
 698          */
 699         immutable(ModuleInfo)*[] _ctors2;
 700         immutable(ModuleInfo)*[] _tlsctors2;
 701         auto result = sort(_ctors2, MIctor | MIdtor) && sort(_tlsctors2, MItlsctor | MItlsdtor);
 702         if (result) // no cycle
 703         {
 704             // fall back to original ordering as part of the deprecation.
 705             if (_ctors.ptr)
 706                 .free(_ctors.ptr);
 707             _ctors = _ctors2;
 708             if (_tlsctors.ptr)
 709                 .free(_tlsctors.ptr);
 710             _tlsctors = _tlsctors2;
 711         }
 712         else
 713         {
 714             // free any allocated memory that will be forgotten
 715             if (_ctors2.ptr)
 716                 .free(_ctors2.ptr);
 717             if (_tlsctors2.ptr)
 718                 .free(_tlsctors2.ptr);
 719         }
 720         return result;
 721     }
 722
 723     void runCtors()
 724     {
 725         // run independent ctors
 726         runModuleFuncs!(m => m.ictor)(_modules);
 727         // sorted module ctors
 728         runModuleFuncs!(m => m.ctor)(_ctors);
 729     }
 730
 731     void runTlsCtors()
 732     {
 733         runModuleFuncs!(m => m.tlsctor)(_tlsctors);
 734     }
 735
 736     void runTlsDtors()
 737     {
 738         runModuleFuncsRev!(m => m.tlsdtor)(_tlsctors);
 739     }
 740
 741     void runDtors()
 742     {
 743         runModuleFuncsRev!(m => m.dtor)(_ctors);
 744     }
 745
 746     void free()
 747     {
 748         if (_ctors.ptr)
 749             .free(_ctors.ptr);
 750         _ctors = null;
 751         if (_tlsctors.ptr)
 752             .free(_tlsctors.ptr);
 753         _tlsctors = null;
 754         // _modules = null; // let the owner free it
 755     }
 756
 757 private:
 758     immutable(ModuleInfo*)[]  _modules;
 759     immutable(ModuleInfo)*[]    _ctors;
 760     immutable(ModuleInfo)*[] _tlsctors;
 761 }
 762
 763
 764 /********************************************
 765  * Iterate over all module infos.
 766  */
 767
 768 int moduleinfos_apply(scope int delegate(immutable(ModuleInfo*)) dg)
 769 {
 770     foreach (ref sg; SectionGroup)
 771     {
 772         foreach (m; sg.modules)
 773         {
 774             // TODO: Should null ModuleInfo be allowed?
 775             if (m !is null)
 776             {
 777                 if (auto res = dg(m))
 778                     return res;
 779             }
 780         }
 781     }
 782     return 0;
 783 }
 784
 785 /********************************************
 786  * Module constructor and destructor routines.
 787  */
 788
 789 extern (C)
 790 {
 791 void rt_moduleCtor()
 792 {
 793     foreach (ref sg; SectionGroup)
 794     {
 795         sg.moduleGroup.sortCtors();
 796         sg.moduleGroup.runCtors();
 797     }
 798 }
 799
 800 void rt_moduleTlsCtor()
 801 {
 802     foreach (ref sg; SectionGroup)
 803     {
 804         sg.moduleGroup.runTlsCtors();
 805     }
 806 }
 807
 808 void rt_moduleTlsDtor()
 809 {
 810     foreach_reverse (ref sg; SectionGroup)
 811     {
 812         sg.moduleGroup.runTlsDtors();
 813     }
 814 }
 815
 816 void rt_moduleDtor()
 817 {
 818     foreach_reverse (ref sg; SectionGroup)
 819     {
 820         sg.moduleGroup.runDtors();
 821         sg.moduleGroup.free();
 822     }
 823 }
 824
 825 version (Win32)
 826 {
 827     // Alternate names for backwards compatibility with older DLL code
 828     void _moduleCtor()
 829     {
 830         rt_moduleCtor();
 831     }
 832
 833     void _moduleDtor()
 834     {
 835         rt_moduleDtor();
 836     }
 837
 838     void _moduleTlsCtor()
 839     {
 840         rt_moduleTlsCtor();
 841     }
 842
 843     void _moduleTlsDtor()
 844     {
 845         rt_moduleTlsDtor();
 846     }
 847 }
 848 }
 849
 850 /********************************************
 851  */
 852
 853 void runModuleFuncs(alias getfp)(const(immutable(ModuleInfo)*)[] modules)
 854 {
 855     foreach (m; modules)
 856     {
 857         if (auto fp = getfp(m))
 858             (*fp)();
 859     }
 860 }
 861
 862 void runModuleFuncsRev(alias getfp)(const(immutable(ModuleInfo)*)[] modules)
 863 {
 864     foreach_reverse (m; modules)
 865     {
 866         if (auto fp = getfp(m))
 867             (*fp)();
 868     }
 869 }
 870
 871 unittest
 872 {
 873     static void assertThrown(T : Throwable, E)(lazy E expr, string msg)
 874     {
 875         try
 876             expr;
 877         catch (T)
 878             return;
 879         assert(0, msg);
 880     }
 881
 882     static void stub()
 883     {
 884     }
 885
 886     static struct UTModuleInfo
 887     {
 888         this(uint flags)
 889         {
 890             mi._flags = flags;
 891         }
 892
 893         void setImports(immutable(ModuleInfo)*[] imports...)
 894         {
 895             import core.bitop;
 896             assert(flags & MIimportedModules);
 897
 898             immutable nfuncs = popcnt(flags & (MItlsctor|MItlsdtor|MIctor|MIdtor|MIictor));
 899             immutable size = nfuncs * (void function()).sizeof +
 900                 size_t.sizeof + imports.length * (ModuleInfo*).sizeof;
 901             assert(size <= pad.sizeof);
 902
 903             pad[nfuncs] = imports.length;
 904             .memcpy(&pad[nfuncs+1], imports.ptr, imports.length * imports[0].sizeof);
 905         }
 906
 907         immutable ModuleInfo mi;
 908         size_t[8] pad;
 909         alias mi this;
 910     }
 911
 912     static UTModuleInfo mockMI(uint flags)
 913     {
 914         auto mi = UTModuleInfo(flags | MIimportedModules);
 915         auto p = cast(void function()*)&mi.pad;
 916         if (flags & MItlsctor) *p++ = &stub;
 917         if (flags & MItlsdtor) *p++ = &stub;
 918         if (flags & MIctor) *p++ = &stub;
 919         if (flags & MIdtor) *p++ = &stub;
 920         if (flags & MIictor) *p++ = &stub;
 921         *cast(size_t*)p++ = 0; // number of imported modules
 922         assert(cast(void*)p <= &mi + 1);
 923         return mi;
 924     }
 925
 926     static void checkExp2(string testname, bool shouldThrow, string oncycle,
 927         immutable(ModuleInfo*)[] modules,
 928         immutable(ModuleInfo*)[] dtors=null,
 929         immutable(ModuleInfo*)[] tlsdtors=null)
 930     {
 931         auto mgroup = ModuleGroup(modules);
 932         mgroup.sortCtors(oncycle);
 933
 934         // if we are expecting sort to throw, don't throw because of unexpected
 935         // success!
 936         if (!shouldThrow)
 937         {
 938             foreach (m; mgroup._modules)
 939                 assert(!(m.flags & (MIctorstart | MIctordone)), testname);
 940             assert(mgroup._ctors    == dtors, testname);
 941             assert(mgroup._tlsctors == tlsdtors, testname);
 942         }
 943     }
 944
 945     static void checkExp(string testname, bool shouldThrow,
 946         immutable(ModuleInfo*)[] modules,
 947         immutable(ModuleInfo*)[] dtors=null,
 948         immutable(ModuleInfo*)[] tlsdtors=null)
 949     {
 950         checkExp2(testname, shouldThrow, "abort", modules, dtors, tlsdtors);
 951     }
 952
 953
 954     {
 955         auto m0 = mockMI(0);
 956         auto m1 = mockMI(0);
 957         auto m2 = mockMI(0);
 958         checkExp("no ctors", false, [&m0.mi, &m1.mi, &m2.mi]);
 959     }
 960
 961     {
 962         auto m0 = mockMI(MIictor);
 963         auto m1 = mockMI(0);
 964         auto m2 = mockMI(MIictor);
 965         auto mgroup = ModuleGroup([&m0.mi, &m1.mi, &m2.mi]);
 966         checkExp("independent ctors", false, [&m0.mi, &m1.mi, &m2.mi]);
 967     }
 968
 969     {
 970         auto m0 = mockMI(MIstandalone | MIctor);
 971         auto m1 = mockMI(0);
 972         auto m2 = mockMI(0);
 973         auto mgroup = ModuleGroup([&m0.mi, &m1.mi, &m2.mi]);
 974         checkExp("standalone ctor", false, [&m0.mi, &m1.mi, &m2.mi], [&m0.mi]);
 975     }
 976
 977     {
 978         auto m0 = mockMI(MIstandalone | MIctor);
 979         auto m1 = mockMI(MIstandalone | MIctor);
 980         auto m2 = mockMI(0);
 981         m1.setImports(&m0.mi);
 982         checkExp("imported standalone => no dependency", false,
 983                  [&m0.mi, &m1.mi, &m2.mi], [&m0.mi, &m1.mi]);
 984     }
 985
 986     {
 987         auto m0 = mockMI(MIstandalone | MIctor);
 988         auto m1 = mockMI(MIstandalone | MIctor);
 989         auto m2 = mockMI(0);
 990         m0.setImports(&m1.mi);
 991         checkExp("imported standalone => no dependency (2)", false,
 992                 [&m0.mi, &m1.mi, &m2.mi], [&m0.mi, &m1.mi]);
 993     }
 994
 995     {
 996         auto m0 = mockMI(MIstandalone | MIctor);
 997         auto m1 = mockMI(MIstandalone | MIctor);
 998         auto m2 = mockMI(0);
 999         m0.setImports(&m1.mi);
1000         m1.setImports(&m0.mi);
1001         checkExp("standalone may have cycle", false,
1002                 [&m0.mi, &m1.mi, &m2.mi], [&m0.mi, &m1.mi]);
1003     }
1004
1005     {
1006         auto m0 = mockMI(MIctor);
1007         auto m1 = mockMI(MIctor);
1008         auto m2 = mockMI(0);
1009         m1.setImports(&m0.mi);
1010         checkExp("imported ctor => ordered ctors", false,
1011                 [&m0.mi, &m1.mi, &m2.mi], [&m0.mi, &m1.mi], []);
1012     }
1013
1014     {
1015         auto m0 = mockMI(MIctor);
1016         auto m1 = mockMI(MIctor);
1017         auto m2 = mockMI(0);
1018         m0.setImports(&m1.mi);
1019         checkExp("imported ctor => ordered ctors (2)", false,
1020                 [&m0.mi, &m1.mi, &m2.mi], [&m1.mi, &m0.mi], []);
1021     }
1022
1023     {
1024         auto m0 = mockMI(MIctor);
1025         auto m1 = mockMI(MIctor);
1026         auto m2 = mockMI(0);
1027         m0.setImports(&m1.mi);
1028         m1.setImports(&m0.mi);
1029         assertThrown!Throwable(checkExp("", true, [&m0.mi, &m1.mi, &m2.mi]),
1030                 "detects ctors cycles");
1031         assertThrown!Throwable(checkExp2("", true, "deprecate",
1032                                         [&m0.mi, &m1.mi, &m2.mi]),
1033                 "detects ctors cycles (dep)");
1034     }
1035
1036     {
1037         auto m0 = mockMI(MIctor);
1038         auto m1 = mockMI(MIctor);
1039         auto m2 = mockMI(0);
1040         m0.setImports(&m2.mi);
1041         m1.setImports(&m2.mi);
1042         m2.setImports(&m0.mi, &m1.mi);
1043         assertThrown!Throwable(checkExp("", true, [&m0.mi, &m1.mi, &m2.mi]),
1044                 "detects cycle with repeats");
1045     }
1046
1047     {
1048         auto m0 = mockMI(MIctor);
1049         auto m1 = mockMI(MIctor);
1050         auto m2 = mockMI(MItlsctor);
1051         m0.setImports(&m1.mi, &m2.mi);
1052         checkExp("imported ctor/tlsctor => ordered ctors/tlsctors", false,
1053                 [&m0.mi, &m1.mi, &m2.mi], [&m1.mi, &m0.mi], [&m2.mi]);
1054     }
1055
1056     {
1057         auto m0 = mockMI(MIctor | MItlsctor);
1058         auto m1 = mockMI(MIctor);
1059         auto m2 = mockMI(MItlsctor);
1060         m0.setImports(&m1.mi, &m2.mi);
1061         checkExp("imported ctor/tlsctor => ordered ctors/tlsctors (2)", false,
1062                 [&m0.mi, &m1.mi, &m2.mi], [&m1.mi, &m0.mi], [&m2.mi, &m0.mi]);
1063     }
1064
1065     {
1066         auto m0 = mockMI(MIctor);
1067         auto m1 = mockMI(MIctor);
1068         auto m2 = mockMI(MItlsctor);
1069         m0.setImports(&m1.mi, &m2.mi);
1070         m2.setImports(&m0.mi);
1071         checkExp("no cycle between ctors/tlsctors", false,
1072                 [&m0.mi, &m1.mi, &m2.mi], [&m1.mi, &m0.mi], [&m2.mi]);
1073     }
1074
1075     {
1076         auto m0 = mockMI(MItlsctor);
1077         auto m1 = mockMI(MIctor);
1078         auto m2 = mockMI(MItlsctor);
1079         m0.setImports(&m2.mi);
1080         m2.setImports(&m0.mi);
1081         assertThrown!Throwable(checkExp("", true, [&m0.mi, &m1.mi, &m2.mi]),
1082                 "detects tlsctors cycle");
1083         assertThrown!Throwable(checkExp2("", true, "deprecate",
1084                                          [&m0.mi, &m1.mi, &m2.mi]),
1085                 "detects tlsctors cycle (dep)");
1086     }
1087
1088     {
1089         auto m0 = mockMI(MItlsctor);
1090         auto m1 = mockMI(MIctor);
1091         auto m2 = mockMI(MItlsctor);
1092         m0.setImports(&m1.mi);
1093         m1.setImports(&m0.mi, &m2.mi);
1094         m2.setImports(&m1.mi);
1095         assertThrown!Throwable(checkExp("", true, [&m0.mi, &m1.mi, &m2.mi]),
1096                 "detects tlsctors cycle with repeats");
1097     }
1098
1099     {
1100         auto m0 = mockMI(MIctor);
1101         auto m1 = mockMI(MIstandalone | MIctor);
1102         auto m2 = mockMI(MIstandalone | MIctor);
1103         m0.setImports(&m1.mi);
1104         m1.setImports(&m2.mi);
1105         m2.setImports(&m0.mi);
1106         // NOTE: this is implementation dependent, sorted order shouldn't be tested.
1107         checkExp("closed ctors cycle", false, [&m0.mi, &m1.mi, &m2.mi],
1108                 [&m1.mi, &m2.mi, &m0.mi]);
1109         //checkExp("closed ctors cycle", false, [&m0.mi, &m1.mi, &m2.mi], [&m0.mi, &m1.mi, &m2.mi]);
1110     }
1111 }
1112
1113 version (CRuntime_Microsoft)
1114 {
1115     // Dummy so Win32 code can still call it
1116     extern(C) void _minit() { }
1117 }