Changes between Version 14 and Version 15 of Building/Solaris


Ignore:
Timestamp:
Feb 4, 2010 1:11:22 AM (6 years ago)
Author:
benl
Comment:

Remove workarounds for fixed bugs in old versions of GHC

Legend:

Unmodified
Added
Removed
Modified
  • Building/Solaris

    v14 v15  
    44= Building on Solaris =
    55
    6 These instructions have only been checked for GHC 6.12.1 on Solaris 10 on SPARC. It should mostly apply to later versions of GHC, Solaris 8 and later and perhaps Solaris on x86.
     6These instructions have only been checked for GHC 6.12.1 on Solaris 10 on SPARC. It should mostly apply to later versions of GHC, Solaris 8 and later and perhaps Solaris on x86. 
    77
    8 A common theme in these instructions is the issue that required tools and libraries are not part of the standard system set and the need for us to set various flags to tell the build system where to find them.
     8GHC versions 6.10.1 and earlier don't have a working SPARC native code generator, and have many small build issues with Solaris. Use GHC 6.12.1 or later.
    99
    1010== Installing GNU packages ==
     
    2121 || GNU readline 5 || ||
    2222 || GNU ncurses 5.5 || ||
    23  || Python 2.6.4 || ||
     23 || Python 2.6.4 || needed to run the testsuite with multiple threads ||
    2424 || GCC 4.1.2       || this exact version is needed ||
    2525
     
    3939= What can go wrong =
    4040
    41 The rest of this page lists problems with specific tool versions. If you stick to the versions in the above list then you shouldn't have to read further.
     41The rest of this page discusses problems with specific tool versions. If you stick to the versions in the above list then you shouldn't have to read further.
    4242
    4343== Only some GCC versions work ==
     
    4545 * GCC version 4.1.2 is known to work. Use this version if possible.
    4646
    47 On Solaris 10, `/usr/bin/gcc` is a version that uses Sun's code generator backend. This is completely unusable for GHC because GHC has to post-process (mangle) the assembly output of GCC. It expects the format and layout that the normal GCC uses.
     47On Solaris 10, `/usr/bin/gcc` is "GCC for Sun Systems (gccfss)". This is a version that uses Sun's code generator backend. This is completely unusable for GHC because GHC has to post-process (mangle) the assembly output of GCC. It expects the format and layout that the normal GCC uses.
    4848
    4949The version of `/usr/sfw/bin/gcc` on Solaris 10 is 3.4.x which has problems, see below.
     
    5858But such a gcc version is sufficient for most user programs in case you just installed a ghc binary distribution.
    5959
    60 == Using GMP from a non-standard location ==
    61 
    62 The gmp library is not a standard system library on Solaris. It can usually be installed from a third party binary package collection or built from source. Either way it will usually not be on the standard cpp include path or the standard static linker path, or the standard dynamic linker path.
    63 
    64 We can handle the first two aspects with these `./configure` flags `--with-gmp-includes` and `--with-gmp-libraries`.
    65 
    66 For example:
    67 
    68 {{{
    69 ./configure --with-gmp-includes=/opt/csw/include --with-gmp-libraries=/opt/csw/lib
    70 }}}
    71 
    72 However to actually run programs compiled by ghc (such as stage1) that use gmp from this location we need to link them in such a way that they will find the gmp lib at runtime. The best way is to use the `-R` linker flag to 'bake in' the right path.
    73 
    74 This can be specified in the `mk/build.mk` file by using:
    75 {{{
    76 SRC_HC_OPTS=-optl-R/opt/csw/lib
    77 }}}
    78 
    79 TODO: check this works, it was only tested with a bootstrapping ghc that always used the above flag, baked into the driver shell script. In that case only `GhcStage2HcOpts=-optl-R/opt/csw/lib` was needed.
    80 
    81 Additionally, the `--with-gmp-`* flags ensure that when using the resulting ghc, that it will be able to link programs to gmp. That is `ghc --make Hello.hs` will actually compile because it will pass `-L/opt/csw/lib` when linking it. However as before, while it links this does not ensure that the resulting program will run. We also need to tell the dynamic linker to look in the gmp lib dir. To get ghc to pass `-R` as well as `-L` we need to alter the registration information for the rts package.
    82 
    83 Note that this currently needs to be done after installation. See #2933 about integrating it into the build process.
    84 
    85 {{{
    86 ghc-pkg describe rts > rts.pkg
    87 vim rts.pkg
    88 ghc-pkg update rts.pkg
    89 }}}
    90 
    91 In the editing step you need to add the `-R/path/to/gmp/lib` to the `ld-options` field.
    92 
    93 Again, if you are building a relocatable binary package then you will want to avoid `-L` or `-R` linker flags being baked in and instead require that the end user set an appropriate `$LD_LIBRARY_PATH`.
    94 
    95 == Using readline from a non-standard location ==
    96 
    97 As with gmp, we need to tell `./configure` about the location of `readline`. Be careful here because it may look like you are building with readline support when in fact you are not.
    98 
    99 Using the `--with-gmp-includes=` `--with-gmp-libraries=` flags are enough to get the top level `./configure` script to believe that using readline will work, if you happen to have gmp and readline installed under the same prefix. However it is not enough for the Haskell readline package's configure script. Unfortunately that one gets run half way through the build process (after building stage1) and if it fails it does so silently and the readline feature is simply not used. This means you end up with a useless ghci. See #2970.
    100 
    101 So it is necessary to pass these flags to `./configure`:
    102 
    103 {{{
    104 ./configure --with-readline-includes=/opt/csw/include --with-readline-libraries=/opt/csw/lib
    105 }}}
    106 
    107 If you want to double-check that ghci really did get built with readline support before you install it then run:
    108 
    109 {{{
    110 ldd compiler/stage2/ghc-6.8.3
    111 }}}
    112 
    113 And check that it really does link to readline.
    11460
    11561== Split objects ==
    11662
    117 With the right toolchain this can work. It's been tested on Solaris 10 with ghc-6.8.3, gcc-4.1.2 and the system (not GNU) binutils (ie as, ld etc from /usr/ccs/bin).
     63With the right toolchain this can work. It was tested on Solaris 10 with ghc-6.8.3, gcc-4.1.2 and the system (not GNU) binutils (ie as, ld etc from /usr/ccs/bin).
    11864
    11965If you run into problems however turn it off by adding this to your `mk/build.mk`:
     
    12268}}}
    12369
    124 Note that to use split objects at the moment you need your gcc to default to the SPARC V9 ABI or to tell ghc to tell gcc to use the V9 ABI it when assembling (`-opta-mcpu=v9`) otherwise you'll hit bug #2872.
    125 
    126 == Putting it all together ==
    127 
    128 This example uses ghc-6.8.3 on Solaris 10, using gmp and other tools installed in `/opt/csw`. The gcc is 4.1.2 installed in `/opt/ghc-vanilla/4.1.2/bin`. The bootstrapping ghc is the binary from the ghc download page installed in `/opt/ghc-bin`.
    129 
    130 The `mk/build.mk` file is
    131 {{{
    132 SRC_HC_OPTS=-optl-R/opt/csw/lib
    133 SplitObjs=YES
    134 }}}
    135 
    136 The `$PATH`
    137 {{{
    138 export PATH=/opt/gcc-vanilla/4.1.2/bin:/opt/csw/bin:/usr/bin:/usr/ccs/bin
    139 }}}
    140 
    141 The `LD_LIBRARY_PATH`
    142 {{{
    143 export LD_LIBRARY_PATH=/opt/csw/lib
    144 }}}
    145 
    146 The `./configure` options
    147 {{{
    148 ./configure --prefix=/opt/ghc \
    149             --with-ghc=/opt/ghc-bin/bin/ghc \
    150             --with-gcc=/opt/gcc-vanilla/4.1.2/bin/gcc \
    151             --with-gmp-includes=/opt/csw/include \
    152             --with-gmp-libraries=/opt/csw/lib
    153             --with-readline-includes=/opt/csw/include \
    154             --with-readline-libraries=/opt/csw/lib
    155 }}}
    156 
    157 Remember of course that you must use GNU make, not the system make. The Solaris 10 `/usr/sfw/bin/gmake` should do. Any other GNU make that you install from a third party repository should also be ok.
    158 {{{
    159 gmake -j4
    160 }}}
    161 
    162 If you are lucky enough to have a box with lots of CPU cores then use them! Sadly the maximum number that it can actually use effectively is around 4. Hopefully the new build system in ghc-6.11 and later will be able to use more.
    163 
    164 It is worth checking at this point that ghc will run without `LD_LIBRARY_PATH` set:
    165 
    166 {{{
    167 unset LD_LIBRARY_PATH
    168 ldd compiler/stage2/ghc-6.8.3
    169 }}}
    170 
    171 This should report all libs as being found. (If you expect to use readline then check it is also linked to readline.)
    172 
    173 Now to install:
    174 
    175 {{{
    176 sudo gmake install
    177 }}}
    178 
    179 Remember that you will now need to modify the `rts` package for the newly installed ghc so that the programs it builds will be able to find the gmp lib at runtime. See the section above on using gmp from a non-standard location for more details.
    180 
    181 {{{
    182 export PATH=/opt/ghc/bin:$PATH
    183 ghc-pkg describe rts > rts.pkg
    184 vim rts.pkg     # add -R/opt/csw/lib to the ld-options field.
    185 ghc-pkg update rts.pkg
    186 }}}
    187 
    188 Now check that compiling and running a hello world program works:
    189 
    190 {{{
    191 $ unset LD_LIBRARY_PATH
    192 $ which ghc
    193 /opt/ghc/bin/ghc
    194 $ echo 'main = print "hello"' > Hello.hs
    195 $ ghc --make Hello.hs
    196 $ ./Hello
    197 "hello"
    198 }}}
    199 
    200 == TODO ==
    201 
    202  * link to expected testsuite results.