ghc/interpreter/link.c

   1
   2 /* --------------------------------------------------------------------------
   3  * Load symbols required from the Prelude
   4  *
   5  * The Hugs 98 system is Copyright (c) Mark P Jones, Alastair Reid, the
   6  * Yale Haskell Group, and the Oregon Graduate Institute of Science and
   7  * Technology, 1994-1999, All rights reserved.  It is distributed as
   8  * free software under the license in the file "License", which is
   9  * included in the distribution.
  10  *
  11  * $RCSfile: link.c,v $
  12  * $Revision: 1.27 $
  13  * $Date: 2000/01/07 17:49:29 $
  14  * ------------------------------------------------------------------------*/
  15
  16 #include "prelude.h"
  17 #include "storage.h"
  18 #include "backend.h"
  19 #include "connect.h"
  20 #include "errors.h"
  21 #include "Assembler.h" /* for asmPrimOps and AsmReps */
  22
  23 #include "link.h"
  24
  25
  26 Type typeArrow;                         /* Function spaces                 */
  27
  28 Type typeChar;
  29 Type typeInt;
  30 Type typeInteger;
  31 Type typeWord;
  32 Type typeAddr;
  33 Type typePrimArray;
  34 Type typePrimByteArray;
  35 Type typeRef;
  36 Type typePrimMutableArray;
  37 Type typePrimMutableByteArray;
  38 Type typeFloat;
  39 Type typeDouble;
  40 Type typeStable;
  41 Type typeThreadId;
  42 Type typeMVar;
  43 #ifdef PROVIDE_WEAK
  44 Type typeWeak;
  45 #endif
  46 #ifdef PROVIDE_FOREIGN
  47 Type typeForeign;
  48 #endif
  49
  50 Type typeList;
  51 Type typeUnit;
  52 Type typeString;
  53 Type typeBool;
  54 Type typeST;
  55 Type typeIO;
  56 Type typeException;
  57
  58 Class classEq;                          /* `standard' classes              */
  59 Class classOrd;
  60 Class classShow;
  61 Class classRead;
  62 Class classIx;
  63 Class classEnum;
  64 Class classBounded;
  65
  66 Class classReal;                        /* `numeric' classes               */
  67 Class classIntegral;
  68 Class classRealFrac;
  69 Class classRealFloat;
  70 Class classFractional;
  71 Class classFloating;
  72 Class classNum;
  73 Class classMonad;                       /* Monads and monads with a zero   */
  74
  75 List stdDefaults;                       /* standard default values         */
  76
  77 Name nameTrue;
  78 Name nameFalse;            /* primitive boolean constructors  */
  79 Name nameNil;
  80 Name nameCons;             /* primitive list constructors     */
  81 Name nameUnit;                          /* primitive Unit type constructor */
  82
  83 Name nameEq;
  84 Name nameFromInt;
  85 Name nameFromDouble;       /* coercion of numerics            */
  86 Name nameFromInteger;
  87 Name nameReturn;
  88 Name nameBind;             /* for translating monad comps     */
  89 Name nameZero;                          /* for monads with a zero          */
  90
  91 Name nameId;
  92 Name nameRunIO;
  93 Name namePrint;
  94
  95 Name nameOtherwise;
  96 Name nameUndefined;                     /* generic undefined value         */
  97 #if NPLUSK
  98 Name namePmSub;
  99 #endif
 100 Name namePMFail;
 101 Name nameEqChar;
 102 Name namePmInt;
 103 Name namePmInteger;
 104 Name namePmDouble;
 105 Name namePmLe;
 106 Name namePmSubtract;
 107 Name namePmFromInteger;
 108 Name nameMkIO;
 109 Name nameUnpackString;
 110 Name nameError;
 111 Name nameInd;
 112 Name nameCreateAdjThunk;
 113
 114 Name nameAnd;
 115 Name nameCompAux;
 116 Name nameRangeSize;
 117 Name nameComp;
 118 Name nameShowField;
 119 Name nameApp;
 120 Name nameShowParen;
 121 Name nameReadParen;
 122 Name nameLex;
 123 Name nameReadField;
 124 Name nameFlip;
 125
 126 Name namePrimSeq;
 127 Name namePrimCatch;
 128 Name namePrimRaise;
 129 Name namePrimTakeMVar;
 130
 131 Name nameFromTo;
 132 Name nameFromThen;
 133 Name nameFrom;
 134 Name nameFromThenTo;
 135 Name nameNegate;
 136
 137 /* these names are required before we've had a chance to do the right thing */
 138 Name nameSel;
 139 Name nameUnsafeUnpackCString;
 140
 141 /* constructors used during translation and codegen */
 142 Name nameMkC;                           /* Char#        -> Char           */
 143 Name nameMkI;                           /* Int#         -> Int            */
 144 Name nameMkInteger;                     /* Integer#     -> Integer        */
 145 Name nameMkW;                           /* Word#        -> Word           */
 146 Name nameMkA;                           /* Addr#        -> Addr            */
 147 Name nameMkF;                           /* Float#       -> Float           */
 148 Name nameMkD;                           /* Double#      -> Double          */
 149 Name nameMkPrimArray;
 150 Name nameMkPrimByteArray;
 151 Name nameMkRef;
 152 Name nameMkPrimMutableArray;
 153 Name nameMkPrimMutableByteArray;
 154 Name nameMkStable;                      /* StablePtr# a -> StablePtr a     */
 155 Name nameMkThreadId;                    /* ThreadId#    -> ThreadId        */
 156 Name nameMkPrimMVar;                    /* MVar# a      -> MVar a          */
 157 #ifdef PROVIDE_WEAK
 158 Name nameMkWeak;                        /* Weak# a      -> Weak a          */
 159 #endif
 160 #ifdef PROVIDE_FOREIGN
 161 Name nameMkForeign;                     /* ForeignObj#  -> ForeignObj      */
 162 #endif
 163
 164
 165
 166 Name nameMinBnd;
 167 Name nameMaxBnd;
 168 Name nameCompare;
 169 Name nameShowsPrec;
 170 Name nameIndex;
 171 Name nameReadsPrec;
 172 Name nameRange;
 173 Name nameEQ;
 174 Name nameInRange;
 175 Name nameGt;
 176 Name nameLe;
 177 Name namePlus;
 178 Name nameMult;
 179 Name nameMFail;
 180 Type typeOrdering;
 181 Module modulePrelude;
 182 Name nameMap;
 183 Name nameMinus;
 184
 185
 186 /* --------------------------------------------------------------------------
 187  * Frequently used type skeletons:
 188  * ------------------------------------------------------------------------*/
 189
 190 Type  arrow;                     /* mkOffset(0) -> mkOffset(1)      */
 191 Type  boundPair;                 /* (mkOffset(0),mkOffset(0))       */
 192 Type  listof;                    /* [ mkOffset(0) ]                 */
 193 Type  typeVarToVar;              /* mkOffset(0) -> mkOffset(0)      */
 194
 195 Cell  predNum;                   /* Num (mkOffset(0))               */
 196 Cell  predFractional;            /* Fractional (mkOffset(0))        */
 197 Cell  predIntegral;              /* Integral (mkOffset(0))          */
 198 Kind  starToStar;                /* Type -> Type                    */
 199 Cell  predMonad;                 /* Monad (mkOffset(0))             */
 200 Type  typeProgIO;                /* IO a                            */
 201
 202
 203 /* --------------------------------------------------------------------------
 204  *
 205  * ------------------------------------------------------------------------*/
 206
 207 static Tycon linkTycon ( String s );
 208 static Tycon linkClass ( String s );
 209 static Name  linkName  ( String s );
 210 static Name  predefinePrim ( String s );
 211
 212
 213 static Tycon linkTycon( String s )
 214 {
 215     Tycon tc = findTycon(findText(s));
 216     if (nonNull(tc)) {
 217         return tc;
 218     }
 219     ERRMSG(0) "Prelude does not define standard type \"%s\"", s
 220     EEND;
 221 }
 222
 223 static Class linkClass( String s )
 224 {
 225     Class cc = findClass(findText(s));
 226     if (nonNull(cc)) {
 227         return cc;
 228     }
 229     ERRMSG(0) "Prelude does not define standard class \"%s\"", s
 230     EEND;
 231 }
 232
 233 static Name linkName( String s )
 234 {
 235     Name n = findName(findText(s));
 236     if (nonNull(n)) {
 237         return n;
 238     }
 239     ERRMSG(0) "Prelude does not define standard name \"%s\"", s
 240     EEND;
 241 }
 242
 243 static Name predefinePrim ( String s )
 244 {
 245     Name nm;
 246     Text t = findText(s);
 247     nm = findName(t);
 248     if (nonNull(nm)) {
 249        //fprintf(stderr, "predefinePrim: %s already exists\n", s );
 250     } else {
 251        nm = newName(t,NIL);
 252        name(nm).defn=PREDEFINED;
 253     }
 254     return nm;
 255 }
 256
 257
 258 /* --------------------------------------------------------------------------
 259  *
 260  * ------------------------------------------------------------------------*/
 261
 262 /* In standalone mode, linkPreludeTC, linkPreludeCM and linkPreludeNames
 263    are called, in that order, during static analysis of Prelude.hs.
 264    In combined mode such an analysis does not happen.  Instead these
 265    calls will be made as a result of a call link(POSTPREL).
 266
 267    linkPreludeTC, linkPreludeCM and linkPreludeNames are needed in both
 268    standalone and combined modes.
 269 */
 270
 271
 272 Void linkPreludeTC(void) {              /* Hook to tycons and classes in   */
 273     static Bool initialised = FALSE;    /* prelude when first loaded       */
 274     if (!initialised) {
 275         Int i;
 276         initialised = TRUE;
 277         setCurrModule(modulePrelude);
 278
 279         typeChar                 = linkTycon("Char");
 280         typeInt                  = linkTycon("Int");
 281         typeInteger              = linkTycon("Integer");
 282         typeWord                 = linkTycon("Word");
 283         typeAddr                 = linkTycon("Addr");
 284         typePrimArray            = linkTycon("PrimArray");
 285         typePrimByteArray        = linkTycon("PrimByteArray");
 286         typeRef                  = linkTycon("STRef");
 287         typePrimMutableArray     = linkTycon("PrimMutableArray");
 288         typePrimMutableByteArray = linkTycon("PrimMutableByteArray");
 289         typeFloat                = linkTycon("Float");
 290         typeDouble               = linkTycon("Double");
 291         typeStable               = linkTycon("StablePtr");
 292 #       ifdef PROVIDE_WEAK
 293         typeWeak                 = linkTycon("Weak");
 294 #       endif
 295 #       ifdef PROVIDE_FOREIGN
 296         typeForeign              = linkTycon("ForeignObj");
 297 #       endif
 298         typeThreadId             = linkTycon("ThreadId");
 299         typeMVar                 = linkTycon("MVar");
 300         typeBool                 = linkTycon("Bool");
 301         typeST                   = linkTycon("ST");
 302         typeIO                   = linkTycon("IO");
 303         typeException            = linkTycon("Exception");
 304         typeString               = linkTycon("String");
 305         typeOrdering             = linkTycon("Ordering");
 306
 307         classEq                  = linkClass("Eq");
 308         classOrd                 = linkClass("Ord");
 309         classIx                  = linkClass("Ix");
 310         classEnum                = linkClass("Enum");
 311         classShow                = linkClass("Show");
 312         classRead                = linkClass("Read");
 313         classBounded             = linkClass("Bounded");
 314         classReal                = linkClass("Real");
 315         classIntegral            = linkClass("Integral");
 316         classRealFrac            = linkClass("RealFrac");
 317         classRealFloat           = linkClass("RealFloat");
 318         classFractional          = linkClass("Fractional");
 319         classFloating            = linkClass("Floating");
 320         classNum                 = linkClass("Num");
 321         classMonad               = linkClass("Monad");
 322
 323         stdDefaults              = NIL;
 324         stdDefaults              = cons(typeDouble,stdDefaults);
 325 #       if DEFAULT_BIGNUM
 326         stdDefaults              = cons(typeInteger,stdDefaults);
 327 #       else
 328         stdDefaults              = cons(typeInt,stdDefaults);
 329 #       endif
 330
 331         predNum                  = ap(classNum,aVar);
 332         predFractional           = ap(classFractional,aVar);
 333         predIntegral             = ap(classIntegral,aVar);
 334         predMonad                = ap(classMonad,aVar);
 335         typeProgIO               = ap(typeIO,aVar);
 336
 337         nameMkC                  = addPrimCfunREP(findText("C#"),1,0,CHAR_REP);
 338         nameMkI                  = addPrimCfunREP(findText("I#"),1,0,INT_REP);
 339         nameMkW                  = addPrimCfunREP(findText("W#"),1,0,WORD_REP);
 340         nameMkA                  = addPrimCfunREP(findText("A#"),1,0,ADDR_REP);
 341         nameMkF                  = addPrimCfunREP(findText("F#"),1,0,FLOAT_REP);
 342         nameMkD                  = addPrimCfunREP(findText("D#"),1,0,DOUBLE_REP);
 343         nameMkStable             = addPrimCfunREP(findText("Stable#"),1,0,STABLE_REP);
 344         nameMkThreadId           = addPrimCfunREP(findText("ThreadId#"),1,0,THREADID_REP);
 345
 346 #       ifdef PROVIDE_FOREIGN
 347         nameMkForeign            = addPrimCfunREP(findText("Foreign#"),1,0,0);
 348 #       endif
 349 #       ifdef PROVIDE_WEAK
 350         nameMkWeak               = addPrimCfunREP(findText("Weak#"),1,0,0);
 351 #       endif
 352         nameMkPrimArray          = addPrimCfunREP(findText("PrimArray#"),1,0,0);
 353         nameMkPrimByteArray      = addPrimCfunREP(findText("PrimByteArray#"),1,0,0);
 354         nameMkRef                = addPrimCfunREP(findText("STRef#"),1,0,0);
 355         nameMkPrimMutableArray   = addPrimCfunREP(findText("PrimMutableArray#"),1,0,0);
 356         nameMkPrimMutableByteArray = addPrimCfunREP(findText("PrimMutableByteArray#"),1,0,0);
 357         nameMkPrimMVar           = addPrimCfunREP(findText("MVar#"),1,0,0);
 358         nameMkInteger            = addPrimCfunREP(findText("Integer#"),1,0,0);
 359
 360         name(namePrimSeq).type   = primType(MONAD_Id, "ab", "b");
 361         name(namePrimCatch).type = primType(MONAD_Id, "aH", "a");
 362         name(namePrimRaise).type = primType(MONAD_Id, "E", "a");
 363
 364         /* This is a lie.  For a more accurate type of primTakeMVar
 365            see ghc/interpreter/lib/Prelude.hs.
 366         */
 367         name(namePrimTakeMVar).type = primType(MONAD_Id, "rbc", "d");
 368
 369         for (i=2; i<=NUM_DTUPLES; i++) {/* Add derived instances of tuples */
 370             addTupInst(classEq,i);
 371             addTupInst(classOrd,i);
 372             addTupInst(classIx,i);
 373             addTupInst(classShow,i);
 374             addTupInst(classRead,i);
 375             addTupInst(classBounded,i);
 376         }
 377     }
 378 }
 379
 380 Void linkPreludeCM(void) {              /* Hook to cfuns and mfuns in      */
 381     static Bool initialised = FALSE;    /* prelude when first loaded       */
 382     if (!initialised) {
 383         Int i;
 384         initialised = TRUE;
 385
 386         setCurrModule(modulePrelude);
 387
 388         /* constructors */
 389         nameFalse        = linkName("False");
 390         nameTrue         = linkName("True");
 391
 392         /* members */
 393         nameEq           = linkName("==");
 394         nameFromInt      = linkName("fromInt");
 395         nameFromInteger  = linkName("fromInteger");
 396         nameFromDouble   = linkName("fromDouble");
 397         nameReturn       = linkName("return");
 398         nameBind         = linkName(">>=");
 399         nameLe           = linkName("<=");
 400         nameGt           = linkName(">");
 401         nameShowsPrec    = linkName("showsPrec");
 402         nameReadsPrec    = linkName("readsPrec");
 403         nameEQ           = linkName("EQ");
 404         nameCompare      = linkName("compare");
 405         nameMinBnd       = linkName("minBound");
 406         nameMaxBnd       = linkName("maxBound");
 407         nameRange        = linkName("range");
 408         nameIndex        = linkName("index");
 409         namePlus         = linkName("+");
 410         nameMult         = linkName("*");
 411         nameRangeSize    = linkName("rangeSize");
 412         nameInRange      = linkName("inRange");
 413         nameMinus        = linkName("-");
 414         /* These come before calls to implementPrim */
 415         for(i=0; i<NUM_TUPLES; ++i) {
 416             implementTuple(i);
 417         }
 418     }
 419 }
 420
 421 Void linkPreludeNames(void) {           /* Hook to names defined in Prelude */
 422     static Bool initialised = FALSE;
 423     if (!initialised) {
 424         Int i;
 425         initialised = TRUE;
 426
 427         setCurrModule(modulePrelude);
 428
 429         /* primops */
 430         nameMkIO           = linkName("primMkIO");
 431         for (i=0; asmPrimOps[i].name; ++i) {
 432             Text t = findText(asmPrimOps[i].name);
 433             Name n = findName(t);
 434             if (isNull(n)) {
 435                 n = newName(t,NIL);
 436             }
 437             name(n).line   = 0;
 438             name(n).defn   = NIL;
 439             name(n).type   = primType(asmPrimOps[i].monad,
 440                                       asmPrimOps[i].args,
 441                                       asmPrimOps[i].results);
 442             name(n).arity  = strlen(asmPrimOps[i].args);
 443             name(n).primop = &(asmPrimOps[i]);
 444             implementPrim(n);
 445         }
 446
 447         /* static(tidyInfix)                        */
 448         nameNegate         = linkName("negate");
 449         /* user interface                           */
 450         nameRunIO          = linkName("primRunIO_hugs_toplevel");
 451         namePrint          = linkName("print");
 452         /* desugar                                  */
 453         nameOtherwise      = linkName("otherwise");
 454         nameUndefined      = linkName("undefined");
 455         /* pmc                                      */
 456 #       if NPLUSK
 457         namePmSub          = linkName("primPmSub");
 458 #       endif
 459         /* translator                               */
 460         nameEqChar         = linkName("primEqChar");
 461         nameCreateAdjThunk = linkName("primCreateAdjThunk");
 462         namePmInt          = linkName("primPmInt");
 463         namePmInteger      = linkName("primPmInteger");
 464         namePmDouble       = linkName("primPmDouble");
 465
 466         namePmFromInteger = linkName("primPmFromInteger");
 467         namePmSubtract    = linkName("primPmSubtract");
 468         namePmLe          = linkName("primPmLe");
 469
 470         implementCfun ( nameCons, NIL );
 471         implementCfun ( nameNil, NIL );
 472         implementCfun ( nameUnit, NIL );
 473     }
 474 }
 475
 476
 477 /* --------------------------------------------------------------------------
 478  *
 479  * ------------------------------------------------------------------------*/
 480
 481 /* ToDo: fix pFun (or eliminate its use) */
 482 #define pFun(n,s) n = predefinePrim(s)
 483
 484 Void linkControl(what)
 485 Int what; {
 486     Int i;
 487     switch (what) {
 488         case RESET   :
 489         case MARK    :
 490                        break;
 491
 492         case POSTPREL:
 493 #if 1
 494           fprintf(stderr, "linkControl(POSTPREL)\n");
 495 #endif
 496           break;
 497
 498         case PREPREL :
 499
 500            if (combined) {
 501
 502                modulePrelude = findFakeModule(textPrelude);
 503                module(modulePrelude).objectExtraNames
 504                   = singleton(findText("libHS_cbits"));
 505
 506                nameMkC = addWiredInBoxingTycon("PrelBase","Char",  "C#",1,0,CHAR_REP  );
 507                nameMkI = addWiredInBoxingTycon("PrelBase","Int",   "I#",1,0,INT_REP   );
 508                nameMkW = addWiredInBoxingTycon("PrelAddr","Word",  "W#",1,0,WORD_REP  );
 509                nameMkA = addWiredInBoxingTycon("PrelAddr","Addr",  "A#",1,0,ADDR_REP  );
 510                nameMkF = addWiredInBoxingTycon("PrelFloat","Float", "F#",1,0,FLOAT_REP );
 511                nameMkD = addWiredInBoxingTycon("PrelFloat","Double","D#",1,0,DOUBLE_REP);
 512                nameMkInteger
 513                        = addWiredInBoxingTycon("PrelNum","Integer","Integer#",1,0,0);
 514                nameMkPrimByteArray
 515                        = addWiredInBoxingTycon("PrelGHC","ByteArray","PrimByteArray#",1,0,0);
 516
 517                for (i=0; i<NUM_TUPLES; ++i) {
 518                    addTupleTycon(i);
 519                }
 520                addWiredInEnumTycon("PrelBase","Bool",
 521                                    doubleton(findText("False"),findText("True")));
 522
 523                //nameMkThreadId
 524                //        = addWiredInBoxingTycon("PrelConc","ThreadId","ThreadId#"
 525                //                                ,1,0,THREADID_REP);
 526
 527                setCurrModule(modulePrelude);
 528
 529                typeArrow = addPrimTycon(findText("(->)"),
 530                                         pair(STAR,pair(STAR,STAR)),
 531                                         2,DATATYPE,NIL);
 532            } else {
 533
 534                modulePrelude = newModule(textPrelude);
 535                setCurrModule(modulePrelude);
 536
 537                for (i=0; i<NUM_TUPLES; ++i) {
 538                    addTupleTycon(i);
 539                }
 540                setCurrModule(modulePrelude);
 541
 542                typeArrow = addPrimTycon(findText("(->)"),
 543                                         pair(STAR,pair(STAR,STAR)),
 544                                         2,DATATYPE,NIL);
 545
 546                /* newtype and USE_NEWTYPE_FOR_DICTS     */
 547                pFun(nameId,             "id");
 548
 549                /* desugaring                            */
 550                pFun(nameInd,            "_indirect");
 551                name(nameInd).number = DFUNNAME;
 552
 553                /* pmc                                   */
 554                pFun(nameSel,            "_SEL");
 555
 556                /* strict constructors                   */
 557                pFun(nameFlip,           "flip"     );
 558
 559                /* parser                                */
 560                pFun(nameFromTo,         "enumFromTo");
 561                pFun(nameFromThenTo,     "enumFromThenTo");
 562                pFun(nameFrom,           "enumFrom");
 563                pFun(nameFromThen,       "enumFromThen");
 564
 565                /* deriving                              */
 566                pFun(nameApp,            "++");
 567                pFun(nameReadField,      "readField");
 568                pFun(nameReadParen,      "readParen");
 569                pFun(nameShowField,      "showField");
 570                pFun(nameShowParen,      "showParen");
 571                pFun(nameLex,            "lex");
 572                pFun(nameComp,           ".");
 573                pFun(nameAnd,            "&&");
 574                pFun(nameCompAux,        "primCompAux");
 575                pFun(nameMap,            "map");
 576
 577                /* implementTagToCon                     */
 578                pFun(namePMFail,         "primPmFail");
 579                pFun(nameError,          "error");
 580                pFun(nameUnpackString,   "primUnpackString");
 581
 582                /* hooks for handwritten bytecode */
 583                pFun(namePrimSeq,        "primSeq");
 584                pFun(namePrimCatch,      "primCatch");
 585                pFun(namePrimRaise,      "primRaise");
 586                pFun(namePrimTakeMVar,   "primTakeMVar");
 587                {
 588                   StgVar vv = mkStgVar(NIL,NIL);
 589                   Name n = namePrimSeq;
 590                   name(n).line = 0;
 591                   name(n).arity = 1;
 592                   name(n).type = NIL;
 593                   vv = mkStgVar(NIL,NIL);
 594                   stgVarInfo(vv) = mkPtr ( asm_BCO_seq() );
 595                   name(n).stgVar = vv;
 596                   stgGlobals=cons(pair(n,vv),stgGlobals);
 597                   namePrimSeq = n;
 598                }
 599                {
 600                   StgVar vv = mkStgVar(NIL,NIL);
 601                   Name n = namePrimCatch;
 602                   name(n).line = 0;
 603                   name(n).arity = 2;
 604                   name(n).type = NIL;
 605                   stgVarInfo(vv) = mkPtr ( asm_BCO_catch() );
 606                   name(n).stgVar = vv;
 607                   stgGlobals=cons(pair(n,vv),stgGlobals);
 608                }
 609                {
 610                   StgVar vv = mkStgVar(NIL,NIL);
 611                   Name n = namePrimRaise;
 612                   name(n).line = 0;
 613                   name(n).arity = 1;
 614                   name(n).type = NIL;
 615                   stgVarInfo(vv) = mkPtr ( asm_BCO_raise() );
 616                   name(n).stgVar = vv;
 617                   stgGlobals=cons(pair(n,vv),stgGlobals);
 618                }
 619                {
 620                   StgVar vv = mkStgVar(NIL,NIL);
 621                   Name n = namePrimTakeMVar;
 622                   name(n).line = 0;
 623                   name(n).arity = 2;
 624                   name(n).type = NIL;
 625                   stgVarInfo(vv) = mkPtr ( asm_BCO_takeMVar() );
 626                   name(n).stgVar = vv;
 627                   stgGlobals=cons(pair(n,vv),stgGlobals);
 628                }
 629            }
 630            break;
 631     }
 632 }
 633 #undef pFun
 634
 635
 636 /*-------------------------------------------------------------------------*/