Follow vreg/hreg patch in x86 NCG
[ghc-hetmet.git] / compiler / nativeGen / PIC.hs
1 {-
2   This module handles generation of position independent code and
3   dynamic-linking related issues for the native code generator.
4
5   This depends both the architecture and OS, so we define it here
6   instead of in one of the architecture specific modules.
7   
8   Things outside this module which are related to this:
9   
10   + module CLabel
11     - PIC base label (pretty printed as local label 1)
12     - DynamicLinkerLabels - several kinds:
13         CodeStub, SymbolPtr, GotSymbolPtr, GotSymbolOffset
14     - labelDynamic predicate
15   + module Cmm
16     - The GlobalReg datatype has a PicBaseReg constructor
17     - The CmmLit datatype has a CmmLabelDiffOff constructor
18   + codeGen & RTS
19     - When tablesNextToCode, no absolute addresses are stored in info tables
20       any more. Instead, offsets from the info label are used.
21     - For Win32 only, SRTs might contain addresses of __imp_ symbol pointers
22       because Win32 doesn't support external references in data sections.
23       TODO: make sure this still works, it might be bitrotted
24   + NCG
25     - The cmmToCmm pass in AsmCodeGen calls cmmMakeDynamicReference for all
26       labels.
27     - nativeCodeGen calls pprImportedSymbol and pprGotDeclaration to output
28       all the necessary stuff for imported symbols.
29     - The NCG monad keeps track of a list of imported symbols.
30     - MachCodeGen invokes initializePicBase to generate code to initialize
31       the PIC base register when needed.
32     - MachCodeGen calls cmmMakeDynamicReference whenever it uses a CLabel
33       that wasn't in the original Cmm code (e.g. floating point literals).
34   + The Mangler
35     - The mangler converts absolure refs to relative refs in info tables
36     - Symbol pointers, stub code and PIC calculations that are generated
37       by GCC are left intact by the mangler (so far only on ppc-darwin
38       and ppc-linux).
39 -}
40
41 module PIC (
42         cmmMakeDynamicReference,
43         ReferenceKind(..),
44         needImportedSymbols,
45         pprImportedSymbol,
46         pprGotDeclaration,
47
48         initializePicBase_ppc,
49         initializePicBase_x86
50 )
51
52 where
53
54 import qualified PPC.Instr      as PPC
55 import qualified PPC.Regs       as PPC
56
57 import qualified X86.Instr      as X86
58
59 import Platform
60 import Instruction
61 import Size
62 import Reg
63 import NCGMonad
64
65
66 import Cmm
67 import CLabel           ( CLabel, pprCLabel,
68                           mkDynamicLinkerLabel, DynamicLinkerLabelInfo(..),
69                           dynamicLinkerLabelInfo, mkPicBaseLabel,
70                           labelDynamic, externallyVisibleCLabel )
71
72 import CLabel           ( mkForeignLabel )
73
74
75 import StaticFlags      ( opt_PIC, opt_Static )
76 import BasicTypes
77
78 import Pretty
79 import qualified Outputable
80
81 import Panic            ( panic )
82 import DynFlags
83 import FastString
84
85
86 --------------------------------------------------------------------------------
87 -- It gets called by the cmmToCmm pass for every CmmLabel in the Cmm
88 -- code. It does The Right Thing(tm) to convert the CmmLabel into a
89 -- position-independent, dynamic-linking-aware reference to the thing
90 -- in question.
91 -- Note that this also has to be called from MachCodeGen in order to
92 -- access static data like floating point literals (labels that were
93 -- created after the cmmToCmm pass).
94 -- The function must run in a monad that can keep track of imported symbols
95 -- A function for recording an imported symbol must be passed in:
96 -- - addImportCmmOpt for the CmmOptM monad
97 -- - addImportNat for the NatM monad.
98
99 data ReferenceKind 
100         = DataReference
101         | CallReference
102         | JumpReference
103         deriving(Eq)
104
105
106 cmmMakeDynamicReference
107   :: Monad m => DynFlags
108              -> (CLabel -> m ())  -- a monad & a function
109                                   -- used for recording imported symbols
110              -> ReferenceKind     -- whether this is the target of a jump
111              -> CLabel            -- the label
112              -> m CmmExpr
113   
114 cmmMakeDynamicReference dflags addImport referenceKind lbl
115   | Just _ <- dynamicLinkerLabelInfo lbl
116   = return $ CmmLit $ CmmLabel lbl   -- already processed it, pass through
117
118   | otherwise 
119   = case howToAccessLabel 
120                 dflags 
121                 (platformArch $ targetPlatform dflags)
122                 (platformOS   $ targetPlatform dflags)
123                 referenceKind lbl of
124
125         AccessViaStub -> do
126               let stub = mkDynamicLinkerLabel CodeStub lbl
127               addImport stub
128               return $ CmmLit $ CmmLabel stub
129
130         AccessViaSymbolPtr -> do
131               let symbolPtr = mkDynamicLinkerLabel SymbolPtr lbl
132               addImport symbolPtr
133               return $ CmmLoad (cmmMakePicReference dflags symbolPtr) bWord
134
135         AccessDirectly -> case referenceKind of
136                 -- for data, we might have to make some calculations:
137               DataReference -> return $ cmmMakePicReference dflags lbl  
138                 -- all currently supported processors support
139                 -- PC-relative branch and call instructions,
140                 -- so just jump there if it's a call or a jump
141               _ -> return $ CmmLit $ CmmLabel lbl
142
143
144 -- -----------------------------------------------------------------------------
145 -- Create a position independent reference to a label.
146 -- (but do not bother with dynamic linking).
147 -- We calculate the label's address by adding some (platform-dependent)
148 -- offset to our base register; this offset is calculated by
149 -- the function picRelative in the platform-dependent part below.
150
151 cmmMakePicReference :: DynFlags -> CLabel -> CmmExpr
152 cmmMakePicReference dflags lbl
153
154         -- Windows doesn't need PIC,
155         -- everything gets relocated at runtime
156         | OSMinGW32     <- platformOS $ targetPlatform dflags
157         = CmmLit $ CmmLabel lbl
158
159
160         | (opt_PIC || not opt_Static) && absoluteLabel lbl 
161         = CmmMachOp (MO_Add wordWidth) 
162                 [ CmmReg (CmmGlobal PicBaseReg)
163                 , CmmLit $ picRelative 
164                                 (platformArch   $ targetPlatform dflags)
165                                 (platformOS     $ targetPlatform dflags)
166                                 lbl ]
167
168         | otherwise
169         = CmmLit $ CmmLabel lbl
170   
171   
172 absoluteLabel :: CLabel -> Bool
173 absoluteLabel lbl 
174  = case dynamicLinkerLabelInfo lbl of
175         Just (GotSymbolPtr, _)          -> False
176         Just (GotSymbolOffset, _)       -> False
177         _                               -> True
178
179
180 --------------------------------------------------------------------------------
181 -- Knowledge about how special dynamic linker labels like symbol
182 -- pointers, code stubs and GOT offsets look like is located in the
183 -- module CLabel.
184
185 -- We have to decide which labels need to be accessed
186 -- indirectly or via a piece of stub code.
187 data LabelAccessStyle 
188         = AccessViaStub
189         | AccessViaSymbolPtr
190         | AccessDirectly
191
192 howToAccessLabel 
193         :: DynFlags -> Arch -> OS -> ReferenceKind -> CLabel -> LabelAccessStyle
194
195 -- Windows
196 -- 
197 -- We need to use access *exactly* those things that
198 -- are imported from a DLL via an __imp_* label.
199 -- There are no stubs for imported code.
200 --
201 howToAccessLabel dflags _ OSMinGW32 _ lbl
202         | labelDynamic (thisPackage dflags) lbl 
203         = AccessViaSymbolPtr
204
205         | otherwise
206         = AccessDirectly
207
208
209 -- Mach-O (Darwin, Mac OS X)
210 --
211 -- Indirect access is required in the following cases:
212 --  * things imported from a dynamic library
213 --  * (not on x86_64) data from a different module, if we're generating PIC code
214 -- It is always possible to access something indirectly,
215 -- even when it's not necessary.
216 --
217 howToAccessLabel dflags arch OSDarwin DataReference lbl
218         -- data access to a dynamic library goes via a symbol pointer
219         | labelDynamic (thisPackage dflags) lbl 
220         = AccessViaSymbolPtr
221
222         -- when generating PIC code, all cross-module data references must
223         -- must go via a symbol pointer, too, because the assembler
224         -- cannot generate code for a label difference where one
225         -- label is undefined. Doesn't apply t x86_64.
226         -- Unfortunately, we don't know whether it's cross-module,
227         -- so we do it for all externally visible labels.
228         -- This is a slight waste of time and space, but otherwise
229         -- we'd need to pass the current Module all the way in to
230         -- this function.
231         | arch /= ArchX86_64
232         , opt_PIC && externallyVisibleCLabel lbl 
233         = AccessViaSymbolPtr
234          
235         | otherwise 
236         = AccessDirectly
237
238 howToAccessLabel dflags arch OSDarwin JumpReference lbl
239         -- dyld code stubs don't work for tailcalls because the
240         -- stack alignment is only right for regular calls.
241         -- Therefore, we have to go via a symbol pointer:
242         | arch == ArchX86 || arch == ArchX86_64
243         , labelDynamic (thisPackage dflags) lbl
244         = AccessViaSymbolPtr
245             
246
247 howToAccessLabel dflags arch OSDarwin _ lbl
248         -- Code stubs are the usual method of choice for imported code;
249         -- not needed on x86_64 because Apple's new linker, ld64, generates
250         -- them automatically.
251         | arch /= ArchX86_64
252         , labelDynamic (thisPackage dflags) lbl
253         = AccessViaStub
254
255         | otherwise
256         = AccessDirectly
257
258 -- ELF (Linux)
259 --
260 -- ELF tries to pretend to the main application code that dynamic linking does 
261 -- not exist. While this may sound convenient, it tends to mess things up in
262 -- very bad ways, so we have to be careful when we generate code for the main
263 -- program (-dynamic but no -fPIC).
264 --
265 -- Indirect access is required for references to imported symbols
266 -- from position independent code. It is also required from the main program
267 -- when dynamic libraries containing Haskell code are used.
268
269 howToAccessLabel _ ArchPPC_64 OSLinux kind _
270
271         -- ELF PPC64 (powerpc64-linux), AIX, MacOS 9, BeOS/PPC
272         | DataReference <- kind
273         = AccessViaSymbolPtr
274         
275         -- actually, .label instead of label
276         | otherwise
277         = AccessDirectly 
278
279 howToAccessLabel _ _ OSLinux _ _
280         -- no PIC -> the dynamic linker does everything for us;
281         --           if we don't dynamically link to Haskell code,
282         --           it actually manages to do so without messing thins up.
283         | not opt_PIC && opt_Static 
284         = AccessDirectly
285
286 howToAccessLabel dflags arch OSLinux DataReference lbl
287         -- A dynamic label needs to be accessed via a symbol pointer.
288         | labelDynamic (thisPackage dflags) lbl 
289         = AccessViaSymbolPtr
290
291         -- For PowerPC32 -fPIC, we have to access even static data
292         -- via a symbol pointer (see below for an explanation why
293         -- PowerPC32 Linux is especially broken).
294         | arch == ArchPPC
295         , opt_PIC
296         = AccessViaSymbolPtr
297         
298         | otherwise 
299         = AccessDirectly
300
301
302         -- In most cases, we have to avoid symbol stubs on ELF, for the following reasons:
303         --   on i386, the position-independent symbol stubs in the Procedure Linkage Table
304         --   require the address of the GOT to be loaded into register %ebx on entry.
305         --   The linker will take any reference to the symbol stub as a hint that
306         --   the label in question is a code label. When linking executables, this
307         --   will cause the linker to replace even data references to the label with
308         --   references to the symbol stub.
309
310         -- This leaves calling a (foreign) function from non-PIC code
311         -- (AccessDirectly, because we get an implicit symbol stub)
312         -- and calling functions from PIC code on non-i386 platforms (via a symbol stub) 
313
314 howToAccessLabel dflags arch OSLinux CallReference lbl
315         | labelDynamic (thisPackage dflags) lbl && not opt_PIC
316         = AccessDirectly
317
318         | arch /= ArchX86
319         , labelDynamic (thisPackage dflags) lbl && opt_PIC
320         = AccessViaStub
321
322 howToAccessLabel dflags _ OSLinux _ lbl
323         | labelDynamic (thisPackage dflags) lbl 
324         = AccessViaSymbolPtr
325
326         | otherwise 
327         = AccessDirectly
328
329 -- all other platforms
330 howToAccessLabel _ _ _ _ _
331         | not opt_PIC 
332         = AccessDirectly
333         
334         | otherwise
335         = panic "howToAccessLabel: PIC not defined for this platform"
336
337
338
339 -- -------------------------------------------------------------------
340 -- | Says what we we have to add to our 'PIC base register' in order to
341 --      get the address of a label.
342
343 picRelative :: Arch -> OS -> CLabel -> CmmLit
344
345 -- Darwin, but not x86_64:
346 -- The PIC base register points to the PIC base label at the beginning
347 -- of the current CmmTop. We just have to use a label difference to
348 -- get the offset.
349 -- We have already made sure that all labels that are not from the current
350 -- module are accessed indirectly ('as' can't calculate differences between
351 -- undefined labels).
352 picRelative arch OSDarwin lbl
353         | arch /= ArchX86_64
354         = CmmLabelDiffOff lbl mkPicBaseLabel 0
355         
356
357 -- PowerPC Linux:
358 -- The PIC base register points to our fake GOT. Use a label difference
359 -- to get the offset.
360 -- We have made sure that *everything* is accessed indirectly, so this
361 -- is only used for offsets from the GOT to symbol pointers inside the
362 -- GOT.
363 picRelative ArchPPC OSLinux lbl
364         = CmmLabelDiffOff lbl gotLabel 0
365
366
367 -- Most Linux versions:
368 -- The PIC base register points to the GOT. Use foo@got for symbol
369 -- pointers, and foo@gotoff for everything else.
370 -- Linux and Darwin on x86_64:
371 -- The PIC base register is %rip, we use foo@gotpcrel for symbol pointers,
372 -- and a GotSymbolOffset label for other things.
373 -- For reasons of tradition, the symbol offset label is written as a plain label.
374 picRelative arch os lbl
375         | os == OSLinux || (os == OSDarwin && arch == ArchX86_64)
376         = let   result
377                         | Just (SymbolPtr, lbl') <- dynamicLinkerLabelInfo lbl
378                         = CmmLabel $ mkDynamicLinkerLabel GotSymbolPtr lbl'
379
380                         | otherwise
381                         = CmmLabel $ mkDynamicLinkerLabel GotSymbolOffset lbl
382                         
383           in    result
384
385 picRelative _ _ _
386         = panic "PositionIndependentCode.picRelative undefined for this platform"
387
388
389
390 --------------------------------------------------------------------------------
391
392 -- utility function for pretty-printing asm-labels,
393 -- copied from PprMach
394 --
395 asmSDoc :: Outputable.SDoc -> Doc
396 asmSDoc d 
397         = Outputable.withPprStyleDoc 
398                 (Outputable.mkCodeStyle Outputable.AsmStyle) d
399
400 pprCLabel_asm :: CLabel -> Doc
401 pprCLabel_asm l 
402         = asmSDoc (pprCLabel l)
403
404
405 needImportedSymbols :: Arch -> OS -> Bool
406 needImportedSymbols arch os
407         | os    == OSDarwin
408         , arch  /= ArchX86_64
409         = True
410         
411         -- PowerPC Linux: -fPIC or -dynamic
412         | os    == OSLinux
413         , arch  == ArchPPC
414         = opt_PIC || not opt_Static
415
416         -- i386 (and others?): -dynamic but not -fPIC
417         | os    == OSLinux
418         , arch  /= ArchPPC_64
419         = not opt_Static && not opt_PIC
420
421         | otherwise
422         = False
423
424 -- gotLabel
425 -- The label used to refer to our "fake GOT" from
426 -- position-independent code.
427 gotLabel :: CLabel
428 gotLabel 
429         = mkForeignLabel -- HACK: it's not really foreign
430                 (fsLit ".LCTOC1") Nothing False IsData
431
432
433
434 --------------------------------------------------------------------------------
435 -- We don't need to declare any offset tables.
436 -- However, for PIC on x86, we need a small helper function.
437 pprGotDeclaration :: Arch -> OS -> Doc
438 pprGotDeclaration ArchX86 OSDarwin
439         | opt_PIC
440         = vcat [
441                 ptext (sLit ".section __TEXT,__textcoal_nt,coalesced,no_toc"),
442                 ptext (sLit ".weak_definition ___i686.get_pc_thunk.ax"),
443                 ptext (sLit ".private_extern ___i686.get_pc_thunk.ax"),
444                 ptext (sLit "___i686.get_pc_thunk.ax:"),
445                 ptext (sLit "\tmovl (%esp), %eax"),
446                 ptext (sLit "\tret") ]
447
448 pprGotDeclaration _ OSDarwin
449         = Pretty.empty
450                 
451 -- pprGotDeclaration
452 -- Output whatever needs to be output once per .s file.
453 -- The .LCTOC1 label is defined to point 32768 bytes into the table,
454 -- to make the most of the PPC's 16-bit displacements.
455 -- Only needed for PIC.
456 pprGotDeclaration arch OSLinux
457         | arch  /= ArchPPC_64
458         , not opt_PIC 
459         = Pretty.empty
460
461         | arch  /= ArchPPC_64
462         = vcat [
463                 ptext (sLit ".section \".got2\",\"aw\""),
464                 ptext (sLit ".LCTOC1 = .+32768") ]
465
466 pprGotDeclaration _ _
467         = panic "pprGotDeclaration: no match"   
468
469
470 --------------------------------------------------------------------------------
471 -- On Darwin, we have to generate our own stub code for lazy binding..
472 -- For each processor architecture, there are two versions, one for PIC
473 -- and one for non-PIC.
474 --
475 -- Whenever you change something in this assembler output, make sure
476 -- the splitter in driver/split/ghc-split.lprl recognizes the new output
477
478 pprImportedSymbol :: Arch -> OS -> CLabel -> Doc
479 pprImportedSymbol ArchPPC OSDarwin importedLbl
480         | Just (CodeStub, lbl) <- dynamicLinkerLabelInfo importedLbl
481         = case opt_PIC of
482            False ->
483             vcat [
484                 ptext (sLit ".symbol_stub"),
485                 ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
486                     ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
487                     ptext (sLit "\tlis r11,ha16(L") <> pprCLabel_asm lbl
488                         <> ptext (sLit "$lazy_ptr)"),
489                     ptext (sLit "\tlwz r12,lo16(L") <> pprCLabel_asm lbl
490                         <> ptext (sLit "$lazy_ptr)(r11)"),
491                     ptext (sLit "\tmtctr r12"),
492                     ptext (sLit "\taddi r11,r11,lo16(L") <> pprCLabel_asm lbl
493                         <> ptext (sLit "$lazy_ptr)"),
494                     ptext (sLit "\tbctr")
495             ]
496            True ->
497             vcat [
498                 ptext (sLit ".section __TEXT,__picsymbolstub1,")
499                   <> ptext (sLit "symbol_stubs,pure_instructions,32"),
500                 ptext (sLit "\t.align 2"),
501                 ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
502                     ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
503                     ptext (sLit "\tmflr r0"),
504                     ptext (sLit "\tbcl 20,31,L0$") <> pprCLabel_asm lbl,
505                 ptext (sLit "L0$") <> pprCLabel_asm lbl <> char ':',
506                     ptext (sLit "\tmflr r11"),
507                     ptext (sLit "\taddis r11,r11,ha16(L") <> pprCLabel_asm lbl
508                         <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm lbl <> char ')',
509                     ptext (sLit "\tmtlr r0"),
510                     ptext (sLit "\tlwzu r12,lo16(L") <> pprCLabel_asm lbl
511                         <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm lbl
512                         <> ptext (sLit ")(r11)"),
513                     ptext (sLit "\tmtctr r12"),
514                     ptext (sLit "\tbctr")
515             ]
516           $+$ vcat [
517                 ptext (sLit ".lazy_symbol_pointer"),
518                 ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$lazy_ptr:"),
519                 ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
520                 ptext (sLit "\t.long dyld_stub_binding_helper")]
521
522         | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
523         = vcat [
524                 ptext (sLit ".non_lazy_symbol_pointer"),
525                 char 'L' <> pprCLabel_asm lbl <> ptext (sLit "$non_lazy_ptr:"),
526                 ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
527                 ptext (sLit "\t.long\t0")]
528
529         | otherwise 
530         = empty
531
532                 
533 pprImportedSymbol ArchX86 OSDarwin importedLbl
534         | Just (CodeStub, lbl) <- dynamicLinkerLabelInfo importedLbl
535         = case opt_PIC of
536            False ->
537             vcat [
538                 ptext (sLit ".symbol_stub"),
539                 ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
540                     ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
541                     ptext (sLit "\tjmp *L") <> pprCLabel_asm lbl
542                         <> ptext (sLit "$lazy_ptr"),
543                 ptext (sLit "L") <> pprCLabel_asm lbl
544                     <> ptext (sLit "$stub_binder:"),
545                     ptext (sLit "\tpushl $L") <> pprCLabel_asm lbl
546                         <> ptext (sLit "$lazy_ptr"),
547                     ptext (sLit "\tjmp dyld_stub_binding_helper")
548             ]
549            True ->
550             vcat [
551                 ptext (sLit ".section __TEXT,__picsymbolstub2,")
552                     <> ptext (sLit "symbol_stubs,pure_instructions,25"),
553                 ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
554                     ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
555                     ptext (sLit "\tcall ___i686.get_pc_thunk.ax"),
556                 ptext (sLit "1:"),
557                     ptext (sLit "\tmovl L") <> pprCLabel_asm lbl
558                         <> ptext (sLit "$lazy_ptr-1b(%eax),%edx"),
559                     ptext (sLit "\tjmp *%edx"),
560                 ptext (sLit "L") <> pprCLabel_asm lbl
561                     <> ptext (sLit "$stub_binder:"),
562                     ptext (sLit "\tlea L") <> pprCLabel_asm lbl
563                         <> ptext (sLit "$lazy_ptr-1b(%eax),%eax"),
564                     ptext (sLit "\tpushl %eax"),
565                     ptext (sLit "\tjmp dyld_stub_binding_helper")
566             ]
567           $+$ vcat [        ptext (sLit ".section __DATA, __la_sym_ptr")
568                     <> (if opt_PIC then int 2 else int 3)
569                     <> ptext (sLit ",lazy_symbol_pointers"),
570                 ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$lazy_ptr:"),
571                     ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
572                     ptext (sLit "\t.long L") <> pprCLabel_asm lbl
573                     <> ptext (sLit "$stub_binder")]
574
575         | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
576         = vcat [
577                 ptext (sLit ".non_lazy_symbol_pointer"),
578                 char 'L' <> pprCLabel_asm lbl <> ptext (sLit "$non_lazy_ptr:"),
579                 ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
580                 ptext (sLit "\t.long\t0")]
581
582         | otherwise 
583         = empty
584
585
586 pprImportedSymbol _ OSDarwin _
587         = empty
588         
589
590 -- ELF / Linux
591 --
592 -- In theory, we don't need to generate any stubs or symbol pointers
593 -- by hand for Linux.
594 --
595 -- Reality differs from this in two areas.
596 --
597 -- 1) If we just use a dynamically imported symbol directly in a read-only
598 --    section of the main executable (as GCC does), ld generates R_*_COPY
599 --    relocations, which are fundamentally incompatible with reversed info
600 --    tables. Therefore, we need a table of imported addresses in a writable
601 --    section.
602 --    The "official" GOT mechanism (label@got) isn't intended to be used
603 --    in position dependent code, so we have to create our own "fake GOT"
604 --    when not opt_PCI && not opt_Static.
605 --
606 -- 2) PowerPC Linux is just plain broken.
607 --    While it's theoretically possible to use GOT offsets larger
608 --    than 16 bit, the standard crt*.o files don't, which leads to
609 --    linker errors as soon as the GOT size exceeds 16 bit.
610 --    Also, the assembler doesn't support @gotoff labels.
611 --    In order to be able to use a larger GOT, we have to circumvent the
612 --    entire GOT mechanism and do it ourselves (this is also what GCC does).
613
614
615 -- When needImportedSymbols is defined,
616 -- the NCG will keep track of all DynamicLinkerLabels it uses
617 -- and output each of them using pprImportedSymbol.
618
619 pprImportedSymbol ArchPPC_64 OSLinux _
620         = empty
621
622 pprImportedSymbol _ OSLinux importedLbl
623         | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
624         = let   symbolSize = case wordWidth of
625                      W32 -> sLit "\t.long"
626                      W64 -> sLit "\t.quad"
627                      _ -> panic "Unknown wordRep in pprImportedSymbol"
628
629           in vcat [
630                 ptext (sLit ".section \".got2\", \"aw\""),
631                 ptext (sLit ".LC_") <> pprCLabel_asm lbl <> char ':',
632                 ptext symbolSize <+> pprCLabel_asm lbl ]
633
634         -- PLT code stubs are generated automatically by the dynamic linker.
635         | otherwise = empty
636
637 pprImportedSymbol _ _ _
638         = panic "PIC.pprImportedSymbol: no match"
639
640 --------------------------------------------------------------------------------
641 -- Generate code to calculate the address that should be put in the
642 -- PIC base register.
643 -- This is called by MachCodeGen for every CmmProc that accessed the
644 -- PIC base register. It adds the appropriate instructions to the
645 -- top of the CmmProc.
646
647 -- It is assumed that the first NatCmmTop in the input list is a Proc
648 -- and the rest are CmmDatas.
649
650 -- Darwin is simple: just fetch the address of a local label.
651 -- The FETCHPC pseudo-instruction is expanded to multiple instructions
652 -- during pretty-printing so that we don't have to deal with the
653 -- local label:
654
655 -- PowerPC version:
656 --          bcl 20,31,1f.
657 --      1:  mflr picReg
658
659 -- i386 version:
660 --          call 1f
661 --      1:  popl %picReg
662
663
664
665 -- Get a pointer to our own fake GOT, which is defined on a per-module basis.
666 -- This is exactly how GCC does it, and it's quite horrible:
667 -- We first fetch the address of a local label (mkPicBaseLabel).
668 -- Then we add a 16-bit offset to that to get the address of a .long that we
669 -- define in .text space right next to the proc. This .long literal contains
670 -- the (32-bit) offset from our local label to our global offset table
671 -- (.LCTOC1 aka gotOffLabel).
672
673 initializePicBase_ppc 
674         :: Arch -> OS -> Reg 
675         -> [NatCmmTop PPC.Instr] 
676         -> NatM [NatCmmTop PPC.Instr]
677
678 initializePicBase_ppc ArchPPC OSLinux picReg
679     (CmmProc info lab params (ListGraph blocks) : statics)
680     = do
681         gotOffLabel <- getNewLabelNat
682         tmp <- getNewRegNat $ intSize wordWidth
683         let 
684             gotOffset = CmmData Text [
685                             CmmDataLabel gotOffLabel,
686                             CmmStaticLit (CmmLabelDiffOff gotLabel
687                                                           mkPicBaseLabel
688                                                           0)
689                         ]
690             offsetToOffset
691                         = PPC.ImmConstantDiff 
692                                 (PPC.ImmCLbl gotOffLabel)
693                                 (PPC.ImmCLbl mkPicBaseLabel)
694
695             BasicBlock bID insns 
696                         = head blocks
697
698             b' = BasicBlock bID (PPC.FETCHPC picReg
699                                : PPC.LD PPC.archWordSize tmp
700                                     (PPC.AddrRegImm picReg offsetToOffset)
701                                : PPC.ADD picReg picReg (PPC.RIReg tmp)
702                                : insns)
703
704         return (CmmProc info lab params (ListGraph (b' : tail blocks)) : gotOffset : statics)
705
706 initializePicBase_ppc ArchPPC OSDarwin picReg
707         (CmmProc info lab params (ListGraph blocks) : statics)
708         = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
709
710         where   BasicBlock bID insns = head blocks
711                 b' = BasicBlock bID (PPC.FETCHPC picReg : insns)
712
713
714 initializePicBase_ppc _ _ _ _
715         = panic "initializePicBase_ppc: not needed"
716
717
718 -- We cheat a bit here by defining a pseudo-instruction named FETCHGOT
719 -- which pretty-prints as:
720 --              call 1f
721 -- 1:           popl %picReg
722 --              addl __GLOBAL_OFFSET_TABLE__+.-1b, %picReg
723 -- (See PprMach.lhs)
724
725 initializePicBase_x86
726         :: Arch -> OS -> Reg 
727         -> [NatCmmTop X86.Instr] 
728         -> NatM [NatCmmTop X86.Instr]
729
730 initializePicBase_x86 ArchX86 OSLinux picReg 
731         (CmmProc info lab params (ListGraph blocks) : statics)
732     = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
733     where BasicBlock bID insns = head blocks
734           b' = BasicBlock bID (X86.FETCHGOT picReg : insns)
735
736 initializePicBase_x86 ArchX86 OSDarwin picReg
737         (CmmProc info lab params (ListGraph blocks) : statics)
738         = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
739
740         where   BasicBlock bID insns = head blocks
741                 b' = BasicBlock bID (X86.FETCHPC picReg : insns)
742
743 initializePicBase_x86 _ _ _ _
744         = panic "initializePicBase_x86: not needed"
745