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