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