More CPP removal: pprDynamicLinkerAsmLabel in CLabel
[ghc.git] / compiler / nativeGen / PIC.hs
index 74c8bb3..da83678 100644 (file)
@@ -63,8 +63,8 @@ import Reg
 import NCGMonad
 
 
-import Cmm
-import CLabel           ( CLabel, pprCLabel,
+import OldCmm
+import CLabel           ( CLabel, ForeignLabelSource(..), pprCLabel,
                           mkDynamicLinkerLabel, DynamicLinkerLabelInfo(..),
                           dynamicLinkerLabelInfo, mkPicBaseLabel,
                           labelDynamic, externallyVisibleCLabel )
@@ -83,6 +83,7 @@ import DynFlags
 import FastString
 
 
+
 --------------------------------------------------------------------------------
 -- 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
@@ -103,15 +104,17 @@ data ReferenceKind
         deriving(Eq)
 
 
-cmmMakeDynamicReference
+cmmMakeDynamicReference, 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 = cmmMakeDynamicReference'
   
-cmmMakeDynamicReference dflags addImport referenceKind lbl
+cmmMakeDynamicReference' dflags addImport referenceKind lbl
   | Just _ <- dynamicLinkerLabelInfo lbl
   = return $ CmmLit $ CmmLabel lbl   -- already processed it, pass through
 
@@ -192,16 +195,40 @@ data LabelAccessStyle
 howToAccessLabel 
        :: DynFlags -> Arch -> OS -> ReferenceKind -> CLabel -> LabelAccessStyle
 
+
 -- 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.
+-- In Windows speak, a "module" is a set of objects linked into the
+-- same Portable Exectuable (PE) file. (both .exe and .dll files are PEs).
+--
+-- If we're compiling a multi-module program then symbols from other modules
+-- are accessed by a symbol pointer named __imp_SYMBOL. At runtime we have the
+-- following.
+--
+--   (in the local module)
+--     __imp_SYMBOL: addr of SYMBOL
+--
+--   (in the other module)
+--     SYMBOL: the real function / data.
+--
+-- To access the function at SYMBOL from our local module, we just need to
+-- dereference the local __imp_SYMBOL.
+--
+-- If opt_Static is set then we assume that all our code will be linked
+-- into the same .exe file. In this case we always access symbols directly, 
+-- and never use __imp_SYMBOL.
 --
 howToAccessLabel dflags _ OSMinGW32 _ lbl
-       | labelDynamic (thisPackage dflags) lbl 
+
+       -- Assume all symbols will be in the same PE, so just access them directly.
+       | opt_Static
+       = AccessDirectly
+       
+       -- If the target symbol is in another PE we need to access it via the
+       --      appropriate __imp_SYMBOL pointer.
+       | labelDynamic dflags (thisPackage dflags) lbl  
        = AccessViaSymbolPtr
 
+       -- Target symbol is in the same PE as the caller, so just access it directly.
        | otherwise
        = AccessDirectly
 
@@ -216,7 +243,7 @@ howToAccessLabel dflags _ OSMinGW32 _ lbl
 --
 howToAccessLabel dflags arch OSDarwin DataReference lbl
        -- data access to a dynamic library goes via a symbol pointer
-       | labelDynamic (thisPackage dflags) lbl 
+       | labelDynamic dflags (thisPackage dflags) lbl 
        = AccessViaSymbolPtr
 
        -- when generating PIC code, all cross-module data references must
@@ -240,7 +267,7 @@ howToAccessLabel dflags arch OSDarwin JumpReference lbl
        -- stack alignment is only right for regular calls.
        -- Therefore, we have to go via a symbol pointer:
        | arch == ArchX86 || arch == ArchX86_64
-       , labelDynamic (thisPackage dflags) lbl
+       , labelDynamic dflags (thisPackage dflags) lbl
        = AccessViaSymbolPtr
            
 
@@ -249,7 +276,7 @@ howToAccessLabel dflags arch OSDarwin _ lbl
        -- not needed on x86_64 because Apple's new linker, ld64, generates
        -- them automatically.
        | arch /= ArchX86_64
-       , labelDynamic (thisPackage dflags) lbl
+       , labelDynamic dflags (thisPackage dflags) lbl
        = AccessViaStub
 
        | otherwise
@@ -266,37 +293,38 @@ howToAccessLabel dflags arch OSDarwin _ lbl
 -- from position independent code. It is also required from the main program
 -- when dynamic libraries containing Haskell code are used.
 
-howToAccessLabel _ ArchPPC_64 OSLinux kind _
-
-       -- ELF PPC64 (powerpc64-linux), AIX, MacOS 9, BeOS/PPC
-       | DataReference <- kind
-       = AccessViaSymbolPtr
-       
-       -- actually, .label instead of label
-       | otherwise
-       = AccessDirectly 
+howToAccessLabel _ ArchPPC_64 os kind _
+       | osElfTarget os
+       = if kind == DataReference
+           -- ELF PPC64 (powerpc64-linux), AIX, MacOS 9, BeOS/PPC
+            then AccessViaSymbolPtr
+           -- actually, .label instead of label
+            else AccessDirectly
 
-howToAccessLabel _ _ OSLinux _ _
+howToAccessLabel _ _ os _ _
        -- 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 
+       | osElfTarget os
+       , not opt_PIC && opt_Static 
        = AccessDirectly
 
-howToAccessLabel dflags arch OSLinux DataReference lbl
-       -- A dynamic label needs to be accessed via a symbol pointer.
-       | labelDynamic (thisPackage dflags) lbl 
-       = AccessViaSymbolPtr
-
-       -- 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).
-       | arch == ArchPPC
-       , opt_PIC
-       = AccessViaSymbolPtr
+howToAccessLabel dflags arch os DataReference lbl
+       | osElfTarget os
+       = case () of
+           -- A dynamic label needs to be accessed via a symbol pointer.
+          _ | labelDynamic dflags (thisPackage dflags) lbl 
+           -> AccessViaSymbolPtr
+
+           -- 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).
+           | arch == ArchPPC
+           , opt_PIC
+           -> AccessViaSymbolPtr
        
-       | otherwise 
-       = AccessDirectly
+           | otherwise 
+           -> AccessDirectly
 
 
        -- In most cases, we have to avoid symbol stubs on ELF, for the following reasons:
@@ -311,20 +339,21 @@ howToAccessLabel dflags arch OSLinux DataReference lbl
        -- (AccessDirectly, because we get an implicit symbol stub)
        -- and calling functions from PIC code on non-i386 platforms (via a symbol stub) 
 
-howToAccessLabel dflags arch OSLinux CallReference lbl
-       | labelDynamic (thisPackage dflags) lbl && not opt_PIC
+howToAccessLabel dflags arch os CallReference lbl
+       | osElfTarget os
+       , labelDynamic dflags (thisPackage dflags) lbl && not opt_PIC
        = AccessDirectly
 
-       | arch /= ArchX86
-       , labelDynamic (thisPackage dflags) lbl && opt_PIC
+       | osElfTarget os
+       , arch /= ArchX86
+       , labelDynamic dflags (thisPackage dflags) lbl && opt_PIC
        = AccessViaStub
 
-howToAccessLabel dflags _ OSLinux _ lbl
-       | labelDynamic (thisPackage dflags) lbl 
-       = AccessViaSymbolPtr
-
-       | otherwise 
-       = AccessDirectly
+howToAccessLabel dflags _ os _ lbl
+       | osElfTarget os
+       = if labelDynamic dflags (thisPackage dflags) lbl 
+           then AccessViaSymbolPtr
+           else AccessDirectly
 
 -- all other platforms
 howToAccessLabel _ _ _ _ _
@@ -344,7 +373,7 @@ picRelative :: Arch -> OS -> CLabel -> CmmLit
 
 -- 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
+-- of the current CmmDecl. 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
@@ -360,7 +389,8 @@ picRelative arch OSDarwin lbl
 -- 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 ArchPPC OSLinux lbl
+picRelative ArchPPC os lbl
+       | osElfTarget os
        = CmmLabelDiffOff lbl gotLabel 0
 
 
@@ -372,7 +402,7 @@ picRelative ArchPPC OSLinux lbl
 -- and a GotSymbolOffset label for other things.
 -- For reasons of tradition, the symbol offset label is written as a plain label.
 picRelative arch os lbl
-       | os == OSLinux || (os == OSDarwin && arch == ArchX86_64)
+       | osElfTarget os || (os == OSDarwin && arch == ArchX86_64)
        = let   result
                        | Just (SymbolPtr, lbl') <- dynamicLinkerLabelInfo lbl
                        = CmmLabel $ mkDynamicLinkerLabel GotSymbolPtr lbl'
@@ -397,9 +427,9 @@ asmSDoc d
        = Outputable.withPprStyleDoc 
                (Outputable.mkCodeStyle Outputable.AsmStyle) d
 
-pprCLabel_asm :: CLabel -> Doc
-pprCLabel_asm 
-       = asmSDoc (pprCLabel l)
+pprCLabel_asm :: Platform -> CLabel -> Doc
+pprCLabel_asm platform l
+       = asmSDoc (pprCLabel platform l)
 
 
 needImportedSymbols :: Arch -> OS -> Bool
@@ -409,12 +439,12 @@ needImportedSymbols arch os
        = True
        
        -- PowerPC Linux: -fPIC or -dynamic
-       | os    == OSLinux
+       | osElfTarget os
        , arch  == ArchPPC
        = opt_PIC || not opt_Static
 
        -- i386 (and others?): -dynamic but not -fPIC
-       | os    == OSLinux
+       | osElfTarget os
        , arch  /= ArchPPC_64
        = not opt_Static && not opt_PIC
 
@@ -426,8 +456,10 @@ needImportedSymbols arch os
 -- position-independent code.
 gotLabel :: CLabel
 gotLabel 
-       = mkForeignLabel -- HACK: it's not really foreign
-               (fsLit ".LCTOC1") Nothing False IsData
+       -- HACK: this label isn't really foreign
+       = mkForeignLabel 
+               (fsLit ".LCTOC1") 
+               Nothing ForeignLabelInThisPackage IsData
 
 
 
@@ -453,12 +485,14 @@ pprGotDeclaration _ OSDarwin
 -- 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 arch OSLinux
-       | arch  /= ArchPPC_64
+pprGotDeclaration arch os
+       | osElfTarget os
+       , arch  /= ArchPPC_64
        , not opt_PIC 
        = Pretty.empty
 
-       | arch  /= ArchPPC_64
+       | osElfTarget os
+       , arch  /= ArchPPC_64
        = vcat [
                ptext (sLit ".section \".got2\",\"aw\""),
                ptext (sLit ".LCTOC1 = .+32768") ]
@@ -475,21 +509,21 @@ pprGotDeclaration _ _
 -- Whenever you change something in this assembler output, make sure
 -- the splitter in driver/split/ghc-split.lprl recognizes the new output
 
-pprImportedSymbol :: Arch -> OS -> CLabel -> Doc
-pprImportedSymbol ArchPPC OSDarwin importedLbl
+pprImportedSymbol :: Platform -> CLabel -> Doc
+pprImportedSymbol platform@(Platform ArchPPC OSDarwin) importedLbl
        | 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 "L") <> pprCLabel_asm platform lbl <> ptext (sLit "$stub:"),
+                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
+                    ptext (sLit "\tlis r11,ha16(L") <> pprCLabel_asm platform lbl
                         <> ptext (sLit "$lazy_ptr)"),
-                    ptext (sLit "\tlwz r12,lo16(L") <> pprCLabel_asm lbl
+                    ptext (sLit "\tlwz r12,lo16(L") <> pprCLabel_asm platform lbl
                         <> ptext (sLit "$lazy_ptr)(r11)"),
                     ptext (sLit "\tmtctr r12"),
-                    ptext (sLit "\taddi r11,r11,lo16(L") <> pprCLabel_asm lbl
+                    ptext (sLit "\taddi r11,r11,lo16(L") <> pprCLabel_asm platform lbl
                         <> ptext (sLit "$lazy_ptr)"),
                     ptext (sLit "\tbctr")
             ]
@@ -498,51 +532,51 @@ pprImportedSymbol ArchPPC OSDarwin importedLbl
                 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 "L") <> pprCLabel_asm platform lbl <> ptext (sLit "$stub:"),
+                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
                     ptext (sLit "\tmflr r0"),
-                    ptext (sLit "\tbcl 20,31,L0$") <> pprCLabel_asm lbl,
-                ptext (sLit "L0$") <> pprCLabel_asm lbl <> char ':',
+                    ptext (sLit "\tbcl 20,31,L0$") <> pprCLabel_asm platform lbl,
+                ptext (sLit "L0$") <> pprCLabel_asm platform 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 "\taddis r11,r11,ha16(L") <> pprCLabel_asm platform lbl
+                        <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm platform 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 "\tlwzu r12,lo16(L") <> pprCLabel_asm platform lbl
+                        <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm platform 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 "L") <> pprCLabel_asm platform lbl <> ptext (sLit "$lazy_ptr:"),
+               ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
                ptext (sLit "\t.long dyld_stub_binding_helper")]
 
        | 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,
+               char 'L' <> pprCLabel_asm platform lbl <> ptext (sLit "$non_lazy_ptr:"),
+               ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
                ptext (sLit "\t.long\t0")]
 
        | otherwise 
        = empty
 
                
-pprImportedSymbol ArchX86 OSDarwin importedLbl
+pprImportedSymbol platform@(Platform ArchX86 OSDarwin) importedLbl
        | 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 "L") <> pprCLabel_asm platform lbl <> ptext (sLit "$stub:"),
+                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
+                    ptext (sLit "\tjmp *L") <> pprCLabel_asm platform lbl
                         <> ptext (sLit "$lazy_ptr"),
-                ptext (sLit "L") <> pprCLabel_asm lbl
+                ptext (sLit "L") <> pprCLabel_asm platform lbl
                     <> ptext (sLit "$stub_binder:"),
-                    ptext (sLit "\tpushl $L") <> pprCLabel_asm lbl
+                    ptext (sLit "\tpushl $L") <> pprCLabel_asm platform lbl
                         <> ptext (sLit "$lazy_ptr"),
                     ptext (sLit "\tjmp dyld_stub_binding_helper")
             ]
@@ -550,16 +584,16 @@ pprImportedSymbol ArchX86 OSDarwin importedLbl
             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 "L") <> pprCLabel_asm platform lbl <> ptext (sLit "$stub:"),
+                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
                     ptext (sLit "\tcall ___i686.get_pc_thunk.ax"),
                 ptext (sLit "1:"),
-                    ptext (sLit "\tmovl L") <> pprCLabel_asm lbl
+                    ptext (sLit "\tmovl L") <> pprCLabel_asm platform lbl
                         <> ptext (sLit "$lazy_ptr-1b(%eax),%edx"),
                     ptext (sLit "\tjmp *%edx"),
-                ptext (sLit "L") <> pprCLabel_asm lbl
+                ptext (sLit "L") <> pprCLabel_asm platform lbl
                     <> ptext (sLit "$stub_binder:"),
-                    ptext (sLit "\tlea L") <> pprCLabel_asm lbl
+                    ptext (sLit "\tlea L") <> pprCLabel_asm platform lbl
                         <> ptext (sLit "$lazy_ptr-1b(%eax),%eax"),
                     ptext (sLit "\tpushl %eax"),
                     ptext (sLit "\tjmp dyld_stub_binding_helper")
@@ -567,23 +601,23 @@ pprImportedSymbol ArchX86 OSDarwin importedLbl
          $+$ 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 "L") <> pprCLabel_asm platform lbl <> ptext (sLit "$lazy_ptr:"),
+                   ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
+                   ptext (sLit "\t.long L") <> pprCLabel_asm platform lbl
                     <> ptext (sLit "$stub_binder")]
 
        | 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,
+               char 'L' <> pprCLabel_asm platform lbl <> ptext (sLit "$non_lazy_ptr:"),
+               ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm platform lbl,
                ptext (sLit "\t.long\t0")]
 
        | otherwise 
        = empty
 
 
-pprImportedSymbol _ OSDarwin _
+pprImportedSymbol (Platform _ OSDarwin) _
        = empty
        
 
@@ -601,7 +635,7 @@ pprImportedSymbol _ OSDarwin _
 --    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.
+--    when not opt_PIC && not opt_Static.
 --
 -- 2) PowerPC Linux is just plain broken.
 --    While it's theoretically possible to use GOT offsets larger
@@ -616,25 +650,28 @@ pprImportedSymbol _ OSDarwin _
 -- the NCG will keep track of all DynamicLinkerLabels it uses
 -- and output each of them using pprImportedSymbol.
 
-pprImportedSymbol ArchPPC_64 OSLinux _
+pprImportedSymbol (Platform ArchPPC_64 os) _
+       | osElfTarget os
        = empty
 
-pprImportedSymbol _ OSLinux importedLbl
-       | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
-       = let   symbolSize = case wordWidth of
-                    W32 -> sLit "\t.long"
-                    W64 -> sLit "\t.quad"
-                    _ -> panic "Unknown wordRep in pprImportedSymbol"
+pprImportedSymbol platform@(Platform _ os) importedLbl
+       | osElfTarget os
+       = case dynamicLinkerLabelInfo importedLbl of
+           Just (SymbolPtr, lbl)
+             -> let symbolSize = case wordWidth of
+                        W32 -> sLit "\t.long"
+                        W64 -> sLit "\t.quad"
+                        _ -> panic "Unknown wordRep in pprImportedSymbol"
 
-         in vcat [
-               ptext (sLit ".section \".got2\", \"aw\""),
-               ptext (sLit ".LC_") <> pprCLabel_asm lbl <> char ':',
-               ptext symbolSize <+> pprCLabel_asm lbl ]
+                in vcat [
+                     ptext (sLit ".section \".got2\", \"aw\""),
+                     ptext (sLit ".LC_") <> pprCLabel_asm platform lbl <> char ':',
+                     ptext symbolSize <+> pprCLabel_asm platform lbl ]
 
-       -- PLT code stubs are generated automatically by the dynamic linker.
-       | otherwise = empty
+           -- PLT code stubs are generated automatically by the dynamic linker.
+           _ -> empty
 
-pprImportedSymbol _ _ _
+pprImportedSymbol _ _
        = panic "PIC.pprImportedSymbol: no match"
 
 --------------------------------------------------------------------------------
@@ -644,7 +681,7 @@ pprImportedSymbol _ _ _
 -- 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
+-- It is assumed that the first NatCmmDecl in the input list is a Proc
 -- and the rest are CmmDatas.
 
 -- Darwin is simple: just fetch the address of a local label.
@@ -672,17 +709,17 @@ pprImportedSymbol _ _ _
 
 initializePicBase_ppc 
        :: Arch -> OS -> Reg 
-       -> [NatCmmTop PPC.Instr] 
-       -> NatM [NatCmmTop PPC.Instr]
+       -> [NatCmmDecl CmmStatics PPC.Instr] 
+       -> NatM [NatCmmDecl CmmStatics PPC.Instr]
 
-initializePicBase_ppc ArchPPC OSLinux picReg
-    (CmmProc info lab params (ListGraph blocks) : statics)
+initializePicBase_ppc ArchPPC os picReg
+    (CmmProc info lab (ListGraph blocks) : statics)
+    | osElfTarget os
     = do
         gotOffLabel <- getNewLabelNat
         tmp <- getNewRegNat $ intSize wordWidth
         let 
-            gotOffset = CmmData Text [
-                            CmmDataLabel gotOffLabel,
+            gotOffset = CmmData Text $ Statics gotOffLabel [
                            CmmStaticLit (CmmLabelDiffOff gotLabel
                                                          mkPicBaseLabel
                                                          0)
@@ -701,11 +738,11 @@ initializePicBase_ppc ArchPPC OSLinux picReg
                                : PPC.ADD picReg picReg (PPC.RIReg tmp)
                                : insns)
 
-        return (CmmProc info lab params (ListGraph (b' : tail blocks)) : gotOffset : statics)
+        return (CmmProc info lab (ListGraph (b' : tail blocks)) : gotOffset : statics)
 
 initializePicBase_ppc ArchPPC OSDarwin picReg
-       (CmmProc info lab params (ListGraph blocks) : statics)
-       = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
+       (CmmProc info lab (ListGraph blocks) : statics)
+       = return (CmmProc info lab (ListGraph (b':tail blocks)) : statics)
 
        where   BasicBlock bID insns = head blocks
                b' = BasicBlock bID (PPC.FETCHPC picReg : insns)
@@ -724,18 +761,19 @@ initializePicBase_ppc _ _ _ _
 
 initializePicBase_x86
        :: Arch -> OS -> Reg 
-       -> [NatCmmTop X86.Instr] 
-       -> NatM [NatCmmTop X86.Instr]
+       -> [NatCmmDecl (Alignment, CmmStatics) X86.Instr] 
+       -> NatM [NatCmmDecl (Alignment, CmmStatics) X86.Instr]
 
-initializePicBase_x86 ArchX86 OSLinux picReg 
-       (CmmProc info lab params (ListGraph blocks) : statics)
-    = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
+initializePicBase_x86 ArchX86 os picReg 
+       (CmmProc info lab (ListGraph blocks) : statics)
+    | osElfTarget os
+    = return (CmmProc info lab (ListGraph (b':tail blocks)) : statics)
     where BasicBlock bID insns = head blocks
           b' = BasicBlock bID (X86.FETCHGOT picReg : insns)
 
 initializePicBase_x86 ArchX86 OSDarwin picReg
-       (CmmProc info lab params (ListGraph blocks) : statics)
-       = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
+       (CmmProc info lab (ListGraph blocks) : statics)
+       = return (CmmProc info lab (ListGraph (b':tail blocks)) : statics)
 
        where   BasicBlock bID insns = head blocks
                b' = BasicBlock bID (X86.FETCHPC picReg : insns)