X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2FnativeGen%2FPositionIndependentCode.hs;fp=compiler%2FnativeGen%2FPositionIndependentCode.hs;h=0000000000000000000000000000000000000000;hb=b04a210e26ca57242fd052f2aa91011a80b76299;hp=a1e11d8a34250d6f1ea288a065ea3c9894d026cc;hpb=77ed23d51b968505b3ad8541c075657ae94f0ea3;p=ghc-hetmet.git diff --git a/compiler/nativeGen/PositionIndependentCode.hs b/compiler/nativeGen/PositionIndependentCode.hs deleted file mode 100644 index a1e11d8..0000000 --- a/compiler/nativeGen/PositionIndependentCode.hs +++ /dev/null @@ -1,654 +0,0 @@ -{-# 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 Regs -import Instrs -import NCGMonad ( NatM, getNewRegNat, getNewLabelNat ) - -import StaticFlags ( opt_PIC, opt_Static ) -import BasicTypes - -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 IsData - --- 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