docs/users_guide/debugging.xml

   1 <?xml version="1.0" encoding="iso-8859-1"?>
   2 <sect1 id="options-debugging">
   3   <title>Debugging the compiler</title>
   4
   5   <indexterm><primary>debugging options (for GHC)</primary></indexterm>
   6
   7   <para>HACKER TERRITORY. HACKER TERRITORY.  (You were warned.)</para>
   8
   9   <sect2 id="dumping-output">
  10     <title>Dumping out compiler intermediate structures</title>
  11
  12     <indexterm><primary>dumping GHC intermediates</primary></indexterm>
  13     <indexterm><primary>intermediate passes, output</primary></indexterm>
  14
  15     <variablelist>
  16       <varlistentry>
  17         <term>
  18           <option>-ddump-</option><replaceable>pass</replaceable>
  19           <indexterm><primary><option>-ddump</option> options</primary></indexterm>
  20         </term>
  21         <listitem>
  22           <para>Make a debugging dump after pass
  23         <literal>&lt;pass&gt;</literal> (may be common enough to need
  24         a short form&hellip;).  You can get all of these at once
  25         (<emphasis>lots</emphasis> of output) by using
  26         <option>-v5</option>, or most of them with
  27         <option>-v4</option>.  Some of the most useful ones
  28         are:</para>
  29
  30           <variablelist>
  31             <varlistentry>
  32               <term>
  33                 <option>-ddump-parsed</option>:
  34                 <indexterm><primary><option>-ddump-parsed</option></primary></indexterm>
  35               </term>
  36               <listitem>
  37                 <para>parser output</para>
  38               </listitem>
  39             </varlistentry>
  40
  41             <varlistentry>
  42               <term>
  43                 <option>-ddump-rn</option>:
  44                 <indexterm><primary><option>-ddump-rn</option></primary></indexterm>
  45               </term>
  46               <listitem>
  47                 <para>renamer output</para>
  48               </listitem>
  49             </varlistentry>
  50
  51             <varlistentry>
  52               <term>
  53                 <option>-ddump-tc</option>:
  54                 <indexterm><primary><option>-ddump-tc</option></primary></indexterm>
  55               </term>
  56               <listitem>
  57                 <para>typechecker output</para>
  58               </listitem>
  59             </varlistentry>
  60
  61             <varlistentry>
  62               <term>
  63                 <option>-ddump-splices</option>:
  64                 <indexterm><primary><option>-ddump-splices</option></primary></indexterm>
  65               </term>
  66               <listitem>
  67                 <para>Dump Template Haskell expressions that we splice in,
  68                 and what Haskell code the expression evaluates to.</para>
  69               </listitem>
  70             </varlistentry>
  71
  72             <varlistentry>
  73               <term>
  74                 <option>-ddump-types</option>:
  75                 <indexterm><primary><option>-ddump-types</option></primary></indexterm>
  76               </term>
  77               <listitem>
  78                 <para>Dump a type signature for each value defined at
  79               the top level of the module.  The list is sorted
  80               alphabetically.  Using <option>-dppr-debug</option>
  81               dumps a type signature for all the imported and
  82               system-defined things as well; useful for debugging the
  83               compiler.</para>
  84               </listitem>
  85             </varlistentry>
  86
  87             <varlistentry>
  88               <term>
  89                 <option>-ddump-deriv</option>:
  90                 <indexterm><primary><option>-ddump-deriv</option></primary></indexterm>
  91               </term>
  92               <listitem>
  93                 <para>derived instances</para>
  94               </listitem>
  95             </varlistentry>
  96
  97             <varlistentry>
  98               <term>
  99                 <option>-ddump-ds</option>:
 100                 <indexterm><primary><option>-ddump-ds</option></primary></indexterm>
 101               </term>
 102               <listitem>
 103                 <para>desugarer output</para>
 104               </listitem>
 105             </varlistentry>
 106
 107             <varlistentry>
 108               <term>
 109                 <option>-ddump-spec</option>:
 110                 <indexterm><primary><option>-ddump-spec</option></primary></indexterm>
 111               </term>
 112               <listitem>
 113                 <para>output of specialisation pass</para>
 114               </listitem>
 115             </varlistentry>
 116
 117             <varlistentry>
 118               <term>
 119                 <option>-ddump-rules</option>:
 120                 <indexterm><primary><option>-ddump-rules</option></primary></indexterm>
 121               </term>
 122               <listitem>
 123                 <para>dumps all rewrite rules specified in this module;
 124                       see <xref linkend="controlling-rules"/>.
 125                 </para>
 126               </listitem>
 127             </varlistentry>
 128
 129             <varlistentry>
 130               <term>
 131                 <option>-ddump-rule-firings</option>:
 132                 <indexterm><primary><option>-ddump-rule-firings</option></primary></indexterm>
 133               </term>
 134               <listitem>
 135                 <para>dumps the names of all rules that fired in this module</para>
 136               </listitem>
 137             </varlistentry>
 138
 139             <varlistentry>
 140               <term>
 141                 <option>-ddump-rule-rewrites</option>:
 142                 <indexterm><primary><option>-ddump-rule-rewrites</option></primary></indexterm>
 143               </term>
 144               <listitem>
 145                 <para>dumps detailed information about all rules that fired in
 146                       this module
 147                 </para>
 148               </listitem>
 149             </varlistentry>
 150
 151             <varlistentry>
 152               <term>
 153                 <option>-ddump-vect</option>:
 154                 <indexterm><primary><option>-ddump-vect</option></primary></indexterm>
 155               </term>
 156               <listitem>
 157                 <para>dumps the output of the vectoriser.
 158                 </para>
 159               </listitem>
 160             </varlistentry>
 161
 162             <varlistentry>
 163               <term>
 164                 <option>-ddump-simpl</option>:
 165                 <indexterm><primary><option>-ddump-simpl</option></primary></indexterm>
 166               </term>
 167               <listitem>
 168                 <para>simplifier output (Core-to-Core passes)</para>
 169               </listitem>
 170             </varlistentry>
 171
 172             <varlistentry>
 173               <term>
 174                 <option>-ddump-inlinings</option>:
 175                 <indexterm><primary><option>-ddump-inlinings</option></primary></indexterm>
 176               </term>
 177               <listitem>
 178                 <para>inlining info from the simplifier</para>
 179               </listitem>
 180             </varlistentry>
 181
 182             <varlistentry>
 183               <term>
 184                 <option>-ddump-cpranal</option>:
 185                 <indexterm><primary><option>-ddump-cpranal</option></primary></indexterm>
 186               </term>
 187               <listitem>
 188                 <para>CPR analyser output</para>
 189               </listitem>
 190             </varlistentry>
 191
 192             <varlistentry>
 193               <term>
 194                 <option>-ddump-stranal</option>:
 195                 <indexterm><primary><option>-ddump-stranal</option></primary></indexterm>
 196               </term>
 197               <listitem>
 198                 <para>strictness analyser output</para>
 199               </listitem>
 200             </varlistentry>
 201
 202             <varlistentry>
 203               <term>
 204                 <option>-ddump-cse</option>:
 205                 <indexterm><primary><option>-ddump-cse</option></primary></indexterm>
 206               </term>
 207               <listitem>
 208                 <para>CSE pass output</para>
 209               </listitem>
 210             </varlistentry>
 211
 212             <varlistentry>
 213               <term>
 214                 <option>-ddump-worker-wrapper</option>:
 215                 <indexterm><primary><option>-ddump-worker-wrapper</option></primary></indexterm>
 216               </term>
 217               <listitem>
 218                 <para>worker/wrapper split output</para>
 219               </listitem>
 220             </varlistentry>
 221
 222             <varlistentry>
 223               <term>
 224                 <option>-ddump-occur-anal</option>:
 225                 <indexterm><primary><option>-ddump-occur-anal</option></primary></indexterm>
 226               </term>
 227               <listitem>
 228                 <para>`occurrence analysis' output</para>
 229               </listitem>
 230             </varlistentry>
 231
 232             <varlistentry>
 233               <term>
 234                 <option>-ddump-prep</option>:
 235                 <indexterm><primary><option>-ddump-prep</option></primary></indexterm>
 236               </term>
 237               <listitem>
 238                 <para>output of core preparation pass</para>
 239               </listitem>
 240             </varlistentry>
 241
 242             <varlistentry>
 243               <term>
 244                 <option>-ddump-stg</option>:
 245                 <indexterm><primary><option>-ddump-stg</option></primary></indexterm>
 246               </term>
 247               <listitem>
 248                 <para>output of STG-to-STG passes</para>
 249               </listitem>
 250             </varlistentry>
 251
 252             <varlistentry>
 253               <term>
 254                 <option>-ddump-flatC</option>:
 255                 <indexterm><primary><option>-ddump-flatC</option></primary></indexterm>
 256               </term>
 257               <listitem>
 258                 <para><emphasis>flattened</emphasis> Abstract&nbsp;C</para>
 259               </listitem>
 260             </varlistentry>
 261
 262             <varlistentry>
 263               <term>
 264                 <option>-ddump-cmm</option>:
 265                 <indexterm><primary><option>-ddump-cmm</option></primary></indexterm>
 266               </term>
 267               <listitem>
 268                 <para>Print the C-- code out.</para>
 269               </listitem>
 270             </varlistentry>
 271
 272             <varlistentry>
 273               <term>
 274                 <option>-ddump-opt-cmm</option>:
 275                 <indexterm><primary><option>-ddump-opt-cmm</option></primary></indexterm>
 276               </term>
 277               <listitem>
 278                 <para>Dump the results of C-- to C-- optimising passes.</para>
 279               </listitem>
 280             </varlistentry>
 281
 282             <varlistentry>
 283               <term>
 284                 <option>-ddump-asm</option>:
 285                 <indexterm><primary><option>-ddump-asm</option></primary></indexterm>
 286               </term>
 287               <listitem>
 288                 <para>assembly language from the native-code generator</para>
 289               </listitem>
 290             </varlistentry>
 291
 292             <varlistentry>
 293               <term>
 294                 <option>-ddump-bcos</option>:
 295                 <indexterm><primary><option>-ddump-bcos</option></primary></indexterm>
 296               </term>
 297               <listitem>
 298                 <para>byte code compiler output</para>
 299               </listitem>
 300             </varlistentry>
 301
 302             <varlistentry>
 303               <term>
 304                 <option>-ddump-foreign</option>:
 305                 <indexterm><primary><option>-ddump-foreign</option></primary></indexterm>
 306               </term>
 307               <listitem>
 308                 <para>dump foreign export stubs</para>
 309               </listitem>
 310             </varlistentry>
 311           </variablelist>
 312         </listitem>
 313       </varlistentry>
 314
 315       <varlistentry>
 316         <term>
 317           <option>-ddump-simpl-phases</option>:
 318           <indexterm><primary><option>-ddump-simpl-phases</option></primary></indexterm>
 319         </term>
 320         <listitem>
 321           <para>Show the output of each run of the simplifier.  Used when even
 322         <option>-dverbose-core2core</option> doesn't cut it.</para>
 323         </listitem>
 324       </varlistentry>
 325
 326       <varlistentry>
 327         <term>
 328           <option>-ddump-simpl-iterations</option>:
 329           <indexterm><primary><option>-ddump-simpl-iterations</option></primary></indexterm>
 330         </term>
 331         <listitem>
 332           <para>Show the output of each <emphasis>iteration</emphasis>
 333         of the simplifier (each run of the simplifier has a maximum
 334         number of iterations, normally 4).  This outputs even more information
 335         than <option>-ddump-simpl-phases</option>.</para>
 336         </listitem>
 337       </varlistentry>
 338
 339       <varlistentry>
 340         <term>
 341           <option>-ddump-simpl-stats</option>
 342           <indexterm><primary><option>-ddump-simpl-stats option</option></primary></indexterm>
 343         </term>
 344         <listitem>
 345           <para>Dump statistics about how many of each kind of
 346         transformation too place.  If you add
 347         <option>-dppr-debug</option> you get more detailed
 348         information.</para>
 349         </listitem>
 350       </varlistentry>
 351
 352       <varlistentry>
 353         <term>
 354           <option>-ddump-if-trace</option>
 355           <indexterm><primary><option>-ddump-if-trace</option></primary></indexterm>
 356         </term>
 357         <listitem>
 358           <para>Make the interface loader be *real* chatty about what it is
 359         upto.</para>
 360         </listitem>
 361       </varlistentry>
 362
 363       <varlistentry>
 364   <term>
 365           <option>-ddump-tc-trace</option>
 366           <indexterm><primary><option>-ddump-tc-trace</option></primary></indexterm>
 367         </term>
 368   <listitem>
 369     <para>Make the type checker be *real* chatty about what it is
 370   upto.</para>
 371   </listitem>
 372       </varlistentry>
 373
 374       <varlistentry>
 375   <term>
 376           <option>-ddump-vt-trace</option>
 377           <indexterm><primary><option>-ddump-tv-trace</option></primary></indexterm>
 378         </term>
 379   <listitem>
 380     <para>Make the vectoriser be *real* chatty about what it is
 381   upto.</para>
 382   </listitem>
 383       </varlistentry>
 384
 385       <varlistentry>
 386         <term>
 387           <option>-ddump-rn-trace</option>
 388           <indexterm><primary><option>-ddump-rn-trace</option></primary></indexterm>
 389         </term>
 390         <listitem>
 391           <para>Make the renamer be *real* chatty about what it is
 392         upto.</para>
 393         </listitem>
 394       </varlistentry>
 395
 396       <varlistentry>
 397         <term>
 398           <option>-ddump-rn-stats</option>
 399           <indexterm><primary><option>-dshow-rn-stats</option></primary></indexterm>
 400         </term>
 401         <listitem>
 402           <para>Print out summary of what kind of information the renamer
 403         had to bring in.</para>
 404         </listitem>
 405       </varlistentry>
 406
 407       <varlistentry>
 408         <term>
 409           <option>-dverbose-core2core</option>
 410           <indexterm><primary><option>-dverbose-core2core</option></primary></indexterm>
 411         </term>
 412         <term>
 413           <option>-dverbose-stg2stg</option>
 414           <indexterm><primary><option>-dverbose-stg2stg</option></primary></indexterm>
 415         </term>
 416         <listitem>
 417           <para>Show the output of the intermediate Core-to-Core and
 418         STG-to-STG passes, respectively.  (<emphasis>Lots</emphasis>
 419         of output!) So: when we're really desperate:</para>
 420
 421           <screen>
 422 % ghc -noC -O -ddump-simpl -dverbose-core2core -dcore-lint Foo.hs
 423 </screen>
 424
 425         </listitem>
 426       </varlistentry>
 427
 428       <varlistentry>
 429         <term>
 430           <option>-dshow-passes</option>
 431           <indexterm><primary><option>-dshow-passes</option></primary></indexterm>
 432         </term>
 433         <listitem>
 434           <para>Print out each pass name as it happens.</para>
 435         </listitem>
 436       </varlistentry>
 437
 438       <varlistentry>
 439         <term>
 440           <option>-dfaststring-stats</option>
 441           <indexterm><primary><option>-dfaststring-stats</option></primary></indexterm>
 442         </term>
 443         <listitem>
 444           <para>Show statistics for the usage of fast strings by the
 445           compiler.</para>
 446         </listitem>
 447       </varlistentry>
 448
 449       <varlistentry>
 450         <term>
 451           <option>-dppr-debug</option>
 452           <indexterm><primary><option>-dppr-debug</option></primary></indexterm>
 453         </term>
 454         <listitem>
 455           <para>Debugging output is in one of several
 456           &ldquo;styles.&rdquo; Take the printing of types, for
 457           example.  In the &ldquo;user&rdquo; style (the default), the
 458           compiler's internal ideas about types are presented in
 459           Haskell source-level syntax, insofar as possible.  In the
 460           &ldquo;debug&rdquo; style (which is the default for
 461           debugging output), the types are printed in with explicit
 462           foralls, and variables have their unique-id attached (so you
 463           can check for things that look the same but aren't).  This
 464           flag makes debugging output appear in the more verbose debug
 465           style.</para>
 466         </listitem>
 467       </varlistentry>
 468
 469       <varlistentry>
 470         <term>
 471           <option>-dsuppress-uniques</option>
 472           <indexterm><primary><option>-dsuppress-uniques</option></primary></indexterm>
 473         </term>
 474         <listitem>
 475           <para>Suppress the printing of uniques in debugging output. This may make
 476           the printout ambiguous (e.g. unclear where an occurrence of 'x' is bound), but
 477           it makes the output of two compiler runs have many fewer gratuitous differences,
 478             so you can realistically apply <command>diff</command>.  Once <command>diff</command>
 479           has shown you where to look, you can try again without <option>-dsuppress-uniques</option></para>
 480         </listitem>
 481       </varlistentry>
 482
 483       <varlistentry>
 484         <term>
 485           <option>-dsuppress-coercions</option>
 486           <indexterm><primary><option>-dsuppress-coercions</option></primary></indexterm>
 487         </term>
 488         <listitem>
 489           <para>Suppress the printing of coercions in Core dumps to make them
 490 shorter.</para>
 491         </listitem>
 492       </varlistentry>
 493
 494       <varlistentry>
 495         <term>
 496           <option>-dsuppress-module-prefixes</option>
 497           <indexterm><primary><option>-dsuppress-module-prefixes</option></primary></indexterm>
 498         </term>
 499         <listitem>
 500           <para>Suppress the printing of module qualification prefixes in Core dumps to make them easier to read.</para>
 501         </listitem>
 502       </varlistentry>
 503
 504       <varlistentry>
 505         <term>
 506           <option>-dppr-user-length</option>
 507           <indexterm><primary><option>-dppr-user-length</option></primary></indexterm>
 508         </term>
 509         <listitem>
 510           <para>In error messages, expressions are printed to a
 511           certain &ldquo;depth&rdquo;, with subexpressions beyond the
 512           depth replaced by ellipses.  This flag sets the
 513           depth.  Its default value is 5.</para>
 514         </listitem>
 515       </varlistentry>
 516
 517       <varlistentry>
 518         <term>
 519           <option>-dno-debug-output</option>
 520           <indexterm><primary><option>-dno-debug-output</option></primary></indexterm>
 521         </term>
 522         <listitem>
 523           <para>Suppress any unsolicited debugging output.  When GHC
 524             has been built with the <literal>DEBUG</literal> option it
 525             occasionally emits debug output of interest to developers.
 526             The extra output can confuse the testing framework and
 527             cause bogus test failures, so this flag is provided to
 528             turn it off.</para>
 529         </listitem>
 530       </varlistentry>
 531     </variablelist>
 532   </sect2>
 533
 534   <sect2 id="checking-consistency">
 535     <title>Checking for consistency</title>
 536
 537     <indexterm><primary>consistency checks</primary></indexterm>
 538     <indexterm><primary>lint</primary></indexterm>
 539
 540     <variablelist>
 541
 542       <varlistentry>
 543         <term>
 544           <option>-dcore-lint</option>
 545           <indexterm><primary><option>-dcore-lint</option></primary></indexterm>
 546         </term>
 547         <listitem>
 548           <para>Turn on heavyweight intra-pass sanity-checking within
 549           GHC, at Core level.  (It checks GHC's sanity, not yours.)</para>
 550         </listitem>
 551       </varlistentry>
 552
 553       <varlistentry>
 554         <term>
 555           <option>-dstg-lint</option>:
 556           <indexterm><primary><option>-dstg-lint</option></primary></indexterm>
 557         </term>
 558         <listitem>
 559           <para>Ditto for STG level. (NOTE: currently doesn't work).</para>
 560         </listitem>
 561       </varlistentry>
 562
 563       <varlistentry>
 564         <term>
 565           <option>-dcmm-lint</option>:
 566           <indexterm><primary><option>-dcmm-lint</option></primary></indexterm>
 567         </term>
 568         <listitem>
 569           <para>Ditto for C-- level.</para>
 570         </listitem>
 571       </varlistentry>
 572
 573     </variablelist>
 574   </sect2>
 575
 576   <sect2>
 577     <title>How to read Core syntax (from some <option>-ddump</option>
 578     flags)</title>
 579
 580     <indexterm><primary>reading Core syntax</primary></indexterm>
 581     <indexterm><primary>Core syntax, how to read</primary></indexterm>
 582
 583     <para>Let's do this by commenting an example.  It's from doing
 584     <option>-ddump-ds</option> on this code:
 585
 586 <programlisting>
 587 skip2 m = m : skip2 (m+2)
 588 </programlisting>
 589
 590     Before we jump in, a word about names of things.  Within GHC,
 591     variables, type constructors, etc., are identified by their
 592     &ldquo;Uniques.&rdquo; These are of the form `letter' plus
 593     `number' (both loosely interpreted).  The `letter' gives some idea
 594     of where the Unique came from; e.g., <literal>&lowbar;</literal>
 595     means &ldquo;built-in type variable&rdquo;; <literal>t</literal>
 596     means &ldquo;from the typechecker&rdquo;; <literal>s</literal>
 597     means &ldquo;from the simplifier&rdquo;; and so on.  The `number'
 598     is printed fairly compactly in a `base-62' format, which everyone
 599     hates except me (WDP).</para>
 600
 601     <para>Remember, everything has a &ldquo;Unique&rdquo; and it is
 602     usually printed out when debugging, in some form or another.  So
 603     here we go&hellip;</para>
 604
 605 <programlisting>
 606 Desugared:
 607 Main.skip2{-r1L6-} :: _forall_ a$_4 =&#62;{{Num a$_4}} -&#62; a$_4 -&#62; [a$_4]
 608
 609 --# `r1L6' is the Unique for Main.skip2;
 610 --# `_4' is the Unique for the type-variable (template) `a'
 611 --# `{{Num a$_4}}' is a dictionary argument
 612
 613 _NI_
 614
 615 --# `_NI_' means "no (pragmatic) information" yet; it will later
 616 --# evolve into the GHC_PRAGMA info that goes into interface files.
 617
 618 Main.skip2{-r1L6-} =
 619     /\ _4 -&#62; \ d.Num.t4Gt -&#62;
 620         let {
 621           {- CoRec -}
 622           +.t4Hg :: _4 -&#62; _4 -&#62; _4
 623           _NI_
 624           +.t4Hg = (+{-r3JH-} _4) d.Num.t4Gt
 625
 626           fromInt.t4GS :: Int{-2i-} -&#62; _4
 627           _NI_
 628           fromInt.t4GS = (fromInt{-r3JX-} _4) d.Num.t4Gt
 629
 630 --# The `+' class method (Unique: r3JH) selects the addition code
 631 --# from a `Num' dictionary (now an explicit lambda'd argument).
 632 --# Because Core is 2nd-order lambda-calculus, type applications
 633 --# and lambdas (/\) are explicit.  So `+' is first applied to a
 634 --# type (`_4'), then to a dictionary, yielding the actual addition
 635 --# function that we will use subsequently...
 636
 637 --# We play the exact same game with the (non-standard) class method
 638 --# `fromInt'.  Unsurprisingly, the type `Int' is wired into the
 639 --# compiler.
 640
 641           lit.t4Hb :: _4
 642           _NI_
 643           lit.t4Hb =
 644               let {
 645                 ds.d4Qz :: Int{-2i-}
 646                 _NI_
 647                 ds.d4Qz = I#! 2#
 648               } in  fromInt.t4GS ds.d4Qz
 649
 650 --# `I# 2#' is just the literal Int `2'; it reflects the fact that
 651 --# GHC defines `data Int = I# Int#', where Int# is the primitive
 652 --# unboxed type.  (see relevant info about unboxed types elsewhere...)
 653
 654 --# The `!' after `I#' indicates that this is a *saturated*
 655 --# application of the `I#' data constructor (i.e., not partially
 656 --# applied).
 657
 658           skip2.t3Ja :: _4 -&#62; [_4]
 659           _NI_
 660           skip2.t3Ja =
 661               \ m.r1H4 -&#62;
 662                   let { ds.d4QQ :: [_4]
 663                         _NI_
 664                         ds.d4QQ =
 665                     let {
 666                       ds.d4QY :: _4
 667                       _NI_
 668                       ds.d4QY = +.t4Hg m.r1H4 lit.t4Hb
 669                     } in  skip2.t3Ja ds.d4QY
 670                   } in
 671                   :! _4 m.r1H4 ds.d4QQ
 672
 673           {- end CoRec -}
 674         } in  skip2.t3Ja
 675 </programlisting>
 676
 677     <para>(&ldquo;It's just a simple functional language&rdquo; is an
 678     unregisterised trademark of Peyton Jones Enterprises, plc.)</para>
 679
 680   </sect2>
 681
 682   <sect2 id="unreg">
 683     <title>Unregisterised compilation</title>
 684     <indexterm><primary>unregisterised compilation</primary></indexterm>
 685
 686     <para>The term "unregisterised" really means "compile via vanilla
 687     C", disabling some of the platform-specific tricks that GHC
 688     normally uses to make programs go faster.  When compiling
 689     unregisterised, GHC simply generates a C file which is compiled
 690     via gcc.</para>
 691
 692     <para>Unregisterised compilation can be useful when porting GHC to
 693     a new machine, since it reduces the prerequisite tools to
 694     <command>gcc</command>, <command>as</command>, and
 695     <command>ld</command> and nothing more, and furthermore the amount
 696     of platform-specific code that needs to be written in order to get
 697     unregisterised compilation going is usually fairly small.</para>
 698
 699    <para>Unregisterised compilation cannot be selected at
 700    compile-time; you have to build GHC with the appropriate options
 701    set.  Consult the GHC Building Guide for details.</para>
 702   </sect2>
 703
 704 </sect1>
 705
 706 <!-- Emacs stuff:
 707      ;;; Local Variables: ***
 708      ;;; sgml-parent-document: ("users_guide.xml" "book" "chapter" "sect1") ***
 709      ;;; End: ***
 710  -->