path: root/compiler/nativeGen/PositionIndependentCode.hs

{-# OPTIONS -w #-}
-- The above warning supression flag is a temporary kludge.
-- While working on this module you are encouraged to remove it and fix
-- any warnings in the module. See
--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
-- for details

module PositionIndependentCode (
        cmmMakeDynamicReference,
        ReferenceKind(..),
        needImportedSymbols,
        pprImportedSymbol,
        pprGotDeclaration,
        initializePicBase
     ) where

#include "HsVersions.h"

{-
  This module handles generation of position independent code and
  dynamic-linking related issues for the native code generator.
  
  Things outside this module which are related to this:
  
  + module CLabel
    - PIC base label (pretty printed as local label 1)
    - DynamicLinkerLabels - several kinds:
        CodeStub, SymbolPtr, GotSymbolPtr, GotSymbolOffset
    - labelDynamic predicate
  + module Cmm
    - The GlobalReg datatype has a PicBaseReg constructor
    - The CmmLit datatype has a CmmLabelDiffOff constructor
  + codeGen & RTS
    - When tablesNextToCode, no absolute addresses are stored in info tables
      any more. Instead, offsets from the info label are used.
    - For Win32 only, SRTs might contain addresses of __imp_ symbol pointers
      because Win32 doesn't support external references in data sections.
      TODO: make sure this still works, it might be bitrotted
  + NCG
    - The cmmToCmm pass in AsmCodeGen calls cmmMakeDynamicReference for all
      labels.
    - nativeCodeGen calls pprImportedSymbol and pprGotDeclaration to output
      all the necessary stuff for imported symbols.
    - The NCG monad keeps track of a list of imported symbols.
    - MachCodeGen invokes initializePicBase to generate code to initialize
      the PIC base register when needed.
    - MachCodeGen calls cmmMakeDynamicReference whenever it uses a CLabel
      that wasn't in the original Cmm code (e.g. floating point literals).
  + The Mangler
    - The mangler converts absolure refs to relative refs in info tables
    - Symbol pointers, stub code and PIC calculations that are generated
      by GCC are left intact by the mangler (so far only on ppc-darwin
      and ppc-linux).
-}

#include "nativeGen/NCG.h"

import Cmm
import CLabel           ( CLabel, pprCLabel,
                          mkDynamicLinkerLabel, DynamicLinkerLabelInfo(..),
                          dynamicLinkerLabelInfo, mkPicBaseLabel,
                          labelDynamic, externallyVisibleCLabel )

#if linux_TARGET_OS
import CLabel           ( mkForeignLabel )
#endif

import MachRegs
import MachInstrs
import NCGMonad         ( NatM, getNewRegNat, getNewLabelNat )

import StaticFlags	( opt_PIC, opt_Static )

import Pretty
import qualified Outputable

import Panic            ( panic )
import DynFlags
import FastString


-- The most important function here is cmmMakeDynamicReference.

-- It gets called by the cmmToCmm pass for every CmmLabel in the Cmm
-- code. It does The Right Thing(tm) to convert the CmmLabel into a
-- position-independent, dynamic-linking-aware reference to the thing
-- in question.
-- Note that this also has to be called from MachCodeGen in order to
-- access static data like floating point literals (labels that were
-- created after the cmmToCmm pass).
-- The function must run in a monad that can keep track of imported symbols
-- A function for recording an imported symbol must be passed in:
-- - addImportCmmOpt for the CmmOptM monad
-- - addImportNat for the NatM monad.

data ReferenceKind = DataReference
                   | CallReference
                   | JumpReference
                   deriving(Eq)

cmmMakeDynamicReference
  :: Monad m => DynFlags
             -> (CLabel -> m ())  -- a monad & a function
                                  -- used for recording imported symbols
             -> ReferenceKind     -- whether this is the target of a jump
             -> CLabel            -- the label
             -> m CmmExpr
  
cmmMakeDynamicReference dflags addImport referenceKind lbl
  | Just _ <- dynamicLinkerLabelInfo lbl
  = return $ CmmLit $ CmmLabel lbl   -- already processed it, pass through
  | otherwise = case howToAccessLabel dflags referenceKind lbl of
        AccessViaStub -> do
              let stub = mkDynamicLinkerLabel CodeStub lbl
              addImport stub
              return $ CmmLit $ CmmLabel stub
        AccessViaSymbolPtr -> do
              let symbolPtr = mkDynamicLinkerLabel SymbolPtr lbl
              addImport symbolPtr
              return $ CmmLoad (cmmMakePicReference symbolPtr) bWord
        AccessDirectly -> case referenceKind of
                -- for data, we might have to make some calculations:
              DataReference -> return $ cmmMakePicReference lbl  
                -- all currently supported processors support
                -- PC-relative branch and call instructions,
                -- so just jump there if it's a call or a jump
              _ -> return $ CmmLit $ CmmLabel lbl
  
-- -------------------------------------------------------------------
  
-- Create a position independent reference to a label.
-- (but do not bother with dynamic linking).
-- We calculate the label's address by adding some (platform-dependent)
-- offset to our base register; this offset is calculated by
-- the function picRelative in the platform-dependent part below.

cmmMakePicReference :: CLabel -> CmmExpr
  
#if !mingw32_TARGET_OS
        -- Windows doesn't need PIC,
        -- everything gets relocated at runtime

cmmMakePicReference lbl
    | (opt_PIC || not opt_Static) && absoluteLabel lbl = CmmMachOp (MO_Add wordWidth) [
            CmmReg (CmmGlobal PicBaseReg),
            CmmLit $ picRelative lbl
        ]
    where
        absoluteLabel lbl = case dynamicLinkerLabelInfo lbl of
                                Just (GotSymbolPtr, _) -> False
                                Just (GotSymbolOffset, _) -> False
                                _ -> True

#endif
cmmMakePicReference lbl = CmmLit $ CmmLabel lbl

-- ===================================================================
-- Platform dependent stuff
-- ===================================================================

-- Knowledge about how special dynamic linker labels like symbol
-- pointers, code stubs and GOT offsets look like is located in the
-- module CLabel.

-- -------------------------------------------------------------------

-- We have to decide which labels need to be accessed
-- indirectly or via a piece of stub code.

data LabelAccessStyle = AccessViaStub
                      | AccessViaSymbolPtr
                      | AccessDirectly

howToAccessLabel :: DynFlags -> ReferenceKind -> CLabel -> LabelAccessStyle

#if mingw32_TARGET_OS
-- Windows
-- 
-- We need to use access *exactly* those things that
-- are imported from a DLL via an __imp_* label.
-- There are no stubs for imported code.

howToAccessLabel dflags _ lbl | labelDynamic (thisPackage dflags) lbl = AccessViaSymbolPtr
			      | otherwise        = AccessDirectly
#elif darwin_TARGET_OS
-- Mach-O (Darwin, Mac OS X)
--
-- Indirect access is required in the following cases:
--  * things imported from a dynamic library
--  * (not on x86_64) data from a different module, if we're generating PIC code
-- It is always possible to access something indirectly,
-- even when it's not necessary.

howToAccessLabel dflags DataReference lbl
      -- data access to a dynamic library goes via a symbol pointer
    | labelDynamic (thisPackage dflags) lbl = AccessViaSymbolPtr
    
#if !x86_64_TARGET_ARCH
      -- when generating PIC code, all cross-module data references must
      -- must go via a symbol pointer, too, because the assembler
      -- cannot generate code for a label difference where one
      -- label is undefined. Doesn't apply t x86_64.
      -- Unfortunately, we don't know whether it's cross-module,
      -- so we do it for all externally visible labels.
      -- This is a slight waste of time and space, but otherwise
      -- we'd need to pass the current Module all the way in to
      -- this function.
    | opt_PIC && externallyVisibleCLabel lbl = AccessViaSymbolPtr
#endif
    | otherwise = AccessDirectly


#if i386_TARGET_ARCH || x86_64_TARGET_ARCH
    -- dyld code stubs don't work for tailcalls because the
    -- stack alignment is only right for regular calls.
    -- Therefore, we have to go via a symbol pointer:
howToAccessLabel dflags JumpReference lbl
    | labelDynamic (thisPackage dflags) lbl
    = AccessViaSymbolPtr
#endif

howToAccessLabel dflags _ lbl
#if !x86_64_TARGET_ARCH
    -- Code stubs are the usual method of choice for imported code;
    -- not needed on x86_64 because Apple's new linker, ld64, generates
    -- them automatically.
    | labelDynamic (thisPackage dflags) lbl
    = AccessViaStub
#endif
    | otherwise
    = AccessDirectly


#elif linux_TARGET_OS && powerpc64_TARGET_ARCH
-- ELF PPC64 (powerpc64-linux), AIX, MacOS 9, BeOS/PPC

howToAccessLabel _ DataReference lbl = AccessViaSymbolPtr
howToAccessLabel _ _ lbl = AccessDirectly -- actually, .label instead of label

#elif linux_TARGET_OS
-- ELF (Linux)
--
-- ELF tries to pretend to the main application code that dynamic linking does 
-- not exist. While this may sound convenient, it tends to mess things up in
-- very bad ways, so we have to be careful when we generate code for the main
-- program (-dynamic but no -fPIC).
--
-- Indirect access is required for references to imported symbols
-- from position independent code. It is also required from the main program
-- when dynamic libraries containing Haskell code are used.

howToAccessLabel _ _ lbl
	-- no PIC -> the dynamic linker does everything for us;
	--           if we don't dynamically link to Haskell code,
	--           it actually manages to do so without messing thins up.
    | not opt_PIC && opt_Static = AccessDirectly
   
howToAccessLabel dflags DataReference lbl
    	-- A dynamic label needs to be accessed via a symbol pointer.
    | labelDynamic (thisPackage dflags) lbl = AccessViaSymbolPtr
#if powerpc_TARGET_ARCH
 	-- For PowerPC32 -fPIC, we have to access even static data
	-- via a symbol pointer (see below for an explanation why
	-- PowerPC32 Linux is especially broken).
    | opt_PIC = AccessViaSymbolPtr
#endif
    | otherwise = AccessDirectly


-- In most cases, we have to avoid symbol stubs on ELF, for the following reasons:
-- * on i386, the position-independent symbol stubs in the Procedure Linkage Table
--   require the address of the GOT to be loaded into register %ebx on entry.
-- * The linker will take any reference to the symbol stub as a hint that
--   the label in question is a code label. When linking executables, this
--   will cause the linker to replace even data references to the label with
--   references to the symbol stub.

-- This leaves calling a (foreign) function from non-PIC code
-- (AccessDirectly, because we get an implicit symbol stub)
-- and calling functions from PIC code on non-i386 platforms (via a symbol stub) 

howToAccessLabel dflags CallReference lbl
    | labelDynamic (thisPackage dflags) lbl && not opt_PIC
    = AccessDirectly
#if !i386_TARGET_ARCH
    | labelDynamic (thisPackage dflags) lbl && opt_PIC
    = AccessViaStub
#endif

howToAccessLabel dflags _ lbl
    | labelDynamic (thisPackage dflags) lbl = AccessViaSymbolPtr
    | otherwise = AccessDirectly
#else
--
-- all other platforms
--
howToAccessLabel _ _ _
        | not opt_PIC = AccessDirectly
        | otherwise   = panic "howToAccessLabel: PIC not defined for this platform"
#endif

-- -------------------------------------------------------------------

-- What do we have to add to our 'PIC base register' in order to
-- get the address of a label?

picRelative :: CLabel -> CmmLit
#if darwin_TARGET_OS && !x86_64_TARGET_ARCH
-- Darwin, but not x86_64:
-- The PIC base register points to the PIC base label at the beginning
-- of the current CmmTop. We just have to use a label difference to
-- get the offset.
-- We have already made sure that all labels that are not from the current
-- module are accessed indirectly ('as' can't calculate differences between
-- undefined labels).

picRelative lbl
  = CmmLabelDiffOff lbl mkPicBaseLabel 0

#elif powerpc_TARGET_ARCH && linux_TARGET_OS
-- PowerPC Linux:
-- The PIC base register points to our fake GOT. Use a label difference
-- to get the offset.
-- We have made sure that *everything* is accessed indirectly, so this
-- is only used for offsets from the GOT to symbol pointers inside the
-- GOT.
picRelative lbl
  = CmmLabelDiffOff lbl gotLabel 0

#elif linux_TARGET_OS || (darwin_TARGET_OS && x86_64_TARGET_ARCH)
-- Most Linux versions:
-- The PIC base register points to the GOT. Use foo@got for symbol
-- pointers, and foo@gotoff for everything else.
-- Linux and Darwin on x86_64:
-- The PIC base register is %rip, we use foo@gotpcrel for symbol pointers,
-- and a GotSymbolOffset label for other things.
-- For reasons of tradition, the symbol offset label is written as a plain label.

picRelative lbl
  | Just (SymbolPtr, lbl') <- dynamicLinkerLabelInfo lbl
  = CmmLabel $ mkDynamicLinkerLabel GotSymbolPtr lbl'
  | otherwise
  = CmmLabel $ mkDynamicLinkerLabel GotSymbolOffset lbl

#else
picRelative lbl = panic "PositionIndependentCode.picRelative"
#endif

-- -------------------------------------------------------------------

-- What do we have to add to every assembly file we generate?

-- utility function for pretty-printing asm-labels,
-- copied from PprMach
asmSDoc d = Outputable.withPprStyleDoc (
	      Outputable.mkCodeStyle Outputable.AsmStyle) d
pprCLabel_asm l = asmSDoc (pprCLabel l)


#if darwin_TARGET_OS && !x86_64_TARGET_ARCH

needImportedSymbols = True

-- We don't need to declare any offset tables.
-- However, for PIC on x86, we need a small helper function.
#if i386_TARGET_ARCH
pprGotDeclaration
    | opt_PIC
    = vcat [
        ptext (sLit ".section __TEXT,__textcoal_nt,coalesced,no_toc"),
        ptext (sLit ".weak_definition ___i686.get_pc_thunk.ax"),
        ptext (sLit ".private_extern ___i686.get_pc_thunk.ax"),
        ptext (sLit "___i686.get_pc_thunk.ax:"),
            ptext (sLit "\tmovl (%esp), %eax"),
            ptext (sLit "\tret")
    ]
    | otherwise = Pretty.empty
#else
pprGotDeclaration = Pretty.empty
#endif

-- On Darwin, we have to generate our own stub code for lazy binding..
-- For each processor architecture, there are two versions, one for PIC
-- and one for non-PIC.
--
-- Whenever you change something in this assembler output, make sure
-- the splitter in driver/split/ghc-split.lprl recognizes the new output
pprImportedSymbol importedLbl
#if powerpc_TARGET_ARCH
    | Just (CodeStub, lbl) <- dynamicLinkerLabelInfo importedLbl
    = case opt_PIC of
        False ->
            vcat [
                ptext (sLit ".symbol_stub"),
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
                    ptext (sLit "\tlis r11,ha16(L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr)"),
                    ptext (sLit "\tlwz r12,lo16(L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr)(r11)"),
                    ptext (sLit "\tmtctr r12"),
                    ptext (sLit "\taddi r11,r11,lo16(L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr)"),
                    ptext (sLit "\tbctr")
            ]
        True ->
            vcat [
                ptext (sLit ".section __TEXT,__picsymbolstub1,")
                  <> ptext (sLit "symbol_stubs,pure_instructions,32"),
                ptext (sLit "\t.align 2"),
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
                    ptext (sLit "\tmflr r0"),
                    ptext (sLit "\tbcl 20,31,L0$") <> pprCLabel_asm lbl,
                ptext (sLit "L0$") <> pprCLabel_asm lbl <> char ':',
                    ptext (sLit "\tmflr r11"),
                    ptext (sLit "\taddis r11,r11,ha16(L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm lbl <> char ')',
                    ptext (sLit "\tmtlr r0"),
                    ptext (sLit "\tlwzu r12,lo16(L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm lbl
                        <> ptext (sLit ")(r11)"),
                    ptext (sLit "\tmtctr r12"),
                    ptext (sLit "\tbctr")
            ]
    $+$ vcat [
        ptext (sLit ".lazy_symbol_pointer"),
        ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$lazy_ptr:"),
            ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
            ptext (sLit "\t.long dyld_stub_binding_helper")
    ]
#elif i386_TARGET_ARCH
    | Just (CodeStub, lbl) <- dynamicLinkerLabelInfo importedLbl
    = case opt_PIC of
        False ->
            vcat [
                ptext (sLit ".symbol_stub"),
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
                    ptext (sLit "\tjmp *L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr"),
                ptext (sLit "L") <> pprCLabel_asm lbl
                    <> ptext (sLit "$stub_binder:"),
                    ptext (sLit "\tpushl $L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr"),
                    ptext (sLit "\tjmp dyld_stub_binding_helper")
            ]
        True ->
            vcat [
                ptext (sLit ".section __TEXT,__picsymbolstub2,")
                    <> ptext (sLit "symbol_stubs,pure_instructions,25"),
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
                    ptext (sLit "\tcall ___i686.get_pc_thunk.ax"),
                ptext (sLit "1:"),
                    ptext (sLit "\tmovl L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr-1b(%eax),%edx"),
                    ptext (sLit "\tjmp *%edx"),
                ptext (sLit "L") <> pprCLabel_asm lbl
                    <> ptext (sLit "$stub_binder:"),
                    ptext (sLit "\tlea L") <> pprCLabel_asm lbl
                        <> ptext (sLit "$lazy_ptr-1b(%eax),%eax"),
                    ptext (sLit "\tpushl %eax"),
                    ptext (sLit "\tjmp dyld_stub_binding_helper")
            ]
    $+$ vcat [        ptext (sLit ".section __DATA, __la_sym_ptr")
                    <> (if opt_PIC then int 2 else int 3)
                    <> ptext (sLit ",lazy_symbol_pointers"),
        ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$lazy_ptr:"),
            ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
            ptext (sLit "\t.long L") <> pprCLabel_asm lbl
                    <> ptext (sLit "$stub_binder")
    ]
#endif
-- We also have to declare our symbol pointers ourselves:
    | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
    = vcat [
        ptext (sLit ".non_lazy_symbol_pointer"),
        char 'L' <> pprCLabel_asm lbl <> ptext (sLit "$non_lazy_ptr:"),
	    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
            ptext (sLit "\t.long\t0")
    ]

    | otherwise = empty

#elif linux_TARGET_OS && !powerpc64_TARGET_ARCH

-- ELF / Linux
--
-- In theory, we don't need to generate any stubs or symbol pointers
-- by hand for Linux.
--
-- Reality differs from this in two areas.
--
-- 1) If we just use a dynamically imported symbol directly in a read-only
--    section of the main executable (as GCC does), ld generates R_*_COPY
--    relocations, which are fundamentally incompatible with reversed info
--    tables. Therefore, we need a table of imported addresses in a writable
--    section.
--    The "official" GOT mechanism (label@got) isn't intended to be used
--    in position dependent code, so we have to create our own "fake GOT"
--    when not opt_PCI && not opt_Static.
--
-- 2) PowerPC Linux is just plain broken.
--    While it's theoretically possible to use GOT offsets larger
--    than 16 bit, the standard crt*.o files don't, which leads to
--    linker errors as soon as the GOT size exceeds 16 bit.
--    Also, the assembler doesn't support @gotoff labels.
--    In order to be able to use a larger GOT, we have to circumvent the
--    entire GOT mechanism and do it ourselves (this is also what GCC does).


-- When needImportedSymbols is defined,
-- the NCG will keep track of all DynamicLinkerLabels it uses
-- and output each of them using pprImportedSymbol.
#if powerpc_TARGET_ARCH
    -- PowerPC Linux: -fPIC or -dynamic
needImportedSymbols = opt_PIC || not opt_Static
#else
    -- i386 (and others?): -dynamic but not -fPIC
needImportedSymbols = not opt_Static && not opt_PIC
#endif

-- gotLabel
-- The label used to refer to our "fake GOT" from
-- position-independent code.
gotLabel = mkForeignLabel -- HACK: it's not really foreign
                           (fsLit ".LCTOC1") Nothing False

-- pprGotDeclaration
-- Output whatever needs to be output once per .s file.
-- The .LCTOC1 label is defined to point 32768 bytes into the table,
-- to make the most of the PPC's 16-bit displacements.
-- Only needed for PIC.

pprGotDeclaration
    | not opt_PIC = Pretty.empty
    | otherwise = vcat [
        ptext (sLit ".section \".got2\",\"aw\""),
        ptext (sLit ".LCTOC1 = .+32768")
    ]

-- We generate one .long/.quad literal for every symbol we import;
-- the dynamic linker will relocate those addresses.

pprImportedSymbol importedLbl
    | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
    = vcat [
        ptext (sLit ".section \".got2\", \"aw\""),
        ptext (sLit ".LC_") <> pprCLabel_asm lbl <> char ':',
        ptext symbolSize <+> pprCLabel_asm lbl
    ]

-- PLT code stubs are generated automatically by the dynamic linker.
    | otherwise = empty
    where
      symbolSize = case wordWidth of
		     W32 -> sLit "\t.long"
		     W64 -> sLit "\t.quad"
		     _ -> panic "Unknown wordRep in pprImportedSymbol"

#else

-- For all other currently supported platforms, we don't need to do
-- anything at all.

needImportedSymbols = False
pprGotDeclaration = Pretty.empty
pprImportedSymbol _ = empty
#endif

-- -------------------------------------------------------------------

-- Generate code to calculate the address that should be put in the
-- PIC base register.
-- This is called by MachCodeGen for every CmmProc that accessed the
-- PIC base register. It adds the appropriate instructions to the
-- top of the CmmProc.

-- It is assumed that the first NatCmmTop in the input list is a Proc
-- and the rest are CmmDatas.

initializePicBase :: Reg -> [NatCmmTop] -> NatM [NatCmmTop]

#if darwin_TARGET_OS

-- Darwin is simple: just fetch the address of a local label.
-- The FETCHPC pseudo-instruction is expanded to multiple instructions
-- during pretty-printing so that we don't have to deal with the
-- local label:

-- PowerPC version:
--          bcl 20,31,1f.
--      1:  mflr picReg

-- i386 version:
--          call 1f
--      1:  popl %picReg

initializePicBase picReg (CmmProc info lab params (ListGraph blocks) : statics)
    = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
    where BasicBlock bID insns = head blocks
          b' = BasicBlock bID (FETCHPC picReg : insns)

#elif powerpc_TARGET_ARCH && linux_TARGET_OS

-- Get a pointer to our own fake GOT, which is defined on a per-module basis.
-- This is exactly how GCC does it, and it's quite horrible:
-- We first fetch the address of a local label (mkPicBaseLabel).
-- Then we add a 16-bit offset to that to get the address of a .long that we
-- define in .text space right next to the proc. This .long literal contains
-- the (32-bit) offset from our local label to our global offset table
-- (.LCTOC1 aka gotOffLabel).
initializePicBase picReg
    (CmmProc info lab params (ListGraph blocks) : statics)
    = do
        gotOffLabel <- getNewLabelNat
        tmp <- getNewRegNat $ intSize wordWidth
        let 
            gotOffset = CmmData Text [
                            CmmDataLabel gotOffLabel,
			    CmmStaticLit (CmmLabelDiffOff gotLabel
                        	                          mkPicBaseLabel
				                          0)
                        ]
            offsetToOffset = ImmConstantDiff (ImmCLbl gotOffLabel)
                                             (ImmCLbl mkPicBaseLabel)
            BasicBlock bID insns = head blocks
            b' = BasicBlock bID (FETCHPC picReg
                               : LD wordSize tmp
                                    (AddrRegImm picReg offsetToOffset)
                               : ADD picReg picReg (RIReg tmp)
                               : insns)
        return (CmmProc info lab params (ListGraph (b' : tail blocks)) : gotOffset : statics)
#elif i386_TARGET_ARCH && linux_TARGET_OS

-- We cheat a bit here by defining a pseudo-instruction named FETCHGOT
-- which pretty-prints as:
--              call 1f
-- 1:           popl %picReg
--              addl __GLOBAL_OFFSET_TABLE__+.-1b, %picReg
-- (See PprMach.lhs)

initializePicBase picReg (CmmProc info lab params (ListGraph blocks) : statics)
    = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
    where BasicBlock bID insns = head blocks
          b' = BasicBlock bID (FETCHGOT picReg : insns)

#else
initializePicBase picReg proc = panic "initializePicBase"

-- mingw32_TARGET_OS: not needed, won't be called
#endif