← Back to branch summary

~ubuntu-branches/ubuntu/precise/ghc/precise

« back to all changes in this revision

Viewing changes to compiler/nativeGen/PIC.hs

  • Committer: Bazaar Package Importer
  • Author(s): Joachim Breitner
  • Date: 2011-01-17 12:49:24 UTC
  • Revision ID: james.westby@ubuntu.com-20110117124924-do1pym1jlf5o636m
Tags: upstream-7.0.1
Import upstream version 7.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
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, ForeignLabelSource(..), 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
--------------------------------------------------------------------------------
 
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
        | (opt_PIC || 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 (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 (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
        , opt_PIC && 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 (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 (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 _ _ 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 opt_PIC && 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 (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
            , opt_PIC
 
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 (thisPackage dflags) lbl && not opt_PIC
 
345
        = AccessDirectly
 
346
 
 
347
        | osElfTarget os
 
348
        , arch /= ArchX86
 
349
        , labelDynamic (thisPackage dflags) lbl && opt_PIC
 
350
        = AccessViaStub
 
351
 
 
352
howToAccessLabel dflags _ os _ lbl
 
353
        | osElfTarget os
 
354
        = if labelDynamic (thisPackage dflags) lbl 
 
355
            then AccessViaSymbolPtr
 
356
            else AccessDirectly
 
357
 
 
358
-- all other platforms
 
359
howToAccessLabel _ _ _ _ _
 
360
        | not opt_PIC 
 
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 CmmTop. 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
-- utility function for pretty-printing asm-labels,
 
423
-- copied from PprMach
 
424
--
 
425
asmSDoc :: Outputable.SDoc -> Doc
 
426
asmSDoc d 
 
427
        = Outputable.withPprStyleDoc 
 
428
                (Outputable.mkCodeStyle Outputable.AsmStyle) d
 
429
 
 
430
pprCLabel_asm :: CLabel -> Doc
 
431
pprCLabel_asm l 
 
432
        = asmSDoc (pprCLabel l)
 
433
 
 
434
 
 
435
needImportedSymbols :: Arch -> OS -> Bool
 
436
needImportedSymbols arch os
 
437
        | os    == OSDarwin
 
438
        , arch  /= ArchX86_64
 
439
        = True
 
440
        
 
441
        -- PowerPC Linux: -fPIC or -dynamic
 
442
        | osElfTarget os
 
443
        , arch  == ArchPPC
 
444
        = opt_PIC || not opt_Static
 
445
 
 
446
        -- i386 (and others?): -dynamic but not -fPIC
 
447
        | osElfTarget os
 
448
        , arch  /= ArchPPC_64
 
449
        = not opt_Static && not opt_PIC
 
450
 
 
451
        | otherwise
 
452
        = False
 
453
 
 
454
-- gotLabel
 
455
-- The label used to refer to our "fake GOT" from
 
456
-- position-independent code.
 
457
gotLabel :: CLabel
 
458
gotLabel 
 
459
        -- HACK: this label isn't really foreign
 
460
        = mkForeignLabel 
 
461
                (fsLit ".LCTOC1") 
 
462
                Nothing ForeignLabelInThisPackage IsData
 
463
 
 
464
 
 
465
 
 
466
--------------------------------------------------------------------------------
 
467
-- We don't need to declare any offset tables.
 
468
-- However, for PIC on x86, we need a small helper function.
 
469
pprGotDeclaration :: Arch -> OS -> Doc
 
470
pprGotDeclaration ArchX86 OSDarwin
 
471
        | opt_PIC
 
472
        = vcat [
 
473
                ptext (sLit ".section __TEXT,__textcoal_nt,coalesced,no_toc"),
 
474
                ptext (sLit ".weak_definition ___i686.get_pc_thunk.ax"),
 
475
                ptext (sLit ".private_extern ___i686.get_pc_thunk.ax"),
 
476
                ptext (sLit "___i686.get_pc_thunk.ax:"),
 
477
                ptext (sLit "\tmovl (%esp), %eax"),
 
478
                ptext (sLit "\tret") ]
 
479
 
 
480
pprGotDeclaration _ OSDarwin
 
481
        = Pretty.empty
 
482
                
 
483
-- pprGotDeclaration
 
484
-- Output whatever needs to be output once per .s file.
 
485
-- The .LCTOC1 label is defined to point 32768 bytes into the table,
 
486
-- to make the most of the PPC's 16-bit displacements.
 
487
-- Only needed for PIC.
 
488
pprGotDeclaration arch os
 
489
        | osElfTarget os
 
490
        , arch  /= ArchPPC_64
 
491
        , not opt_PIC 
 
492
        = Pretty.empty
 
493
 
 
494
        | osElfTarget os
 
495
        , arch  /= ArchPPC_64
 
496
        = vcat [
 
497
                ptext (sLit ".section \".got2\",\"aw\""),
 
498
                ptext (sLit ".LCTOC1 = .+32768") ]
 
499
 
 
500
pprGotDeclaration _ _
 
501
        = panic "pprGotDeclaration: no match"   
 
502
 
 
503
 
 
504
--------------------------------------------------------------------------------
 
505
-- On Darwin, we have to generate our own stub code for lazy binding..
 
506
-- For each processor architecture, there are two versions, one for PIC
 
507
-- and one for non-PIC.
 
508
--
 
509
-- Whenever you change something in this assembler output, make sure
 
510
-- the splitter in driver/split/ghc-split.lprl recognizes the new output
 
511
 
 
512
pprImportedSymbol :: Arch -> OS -> CLabel -> Doc
 
513
pprImportedSymbol ArchPPC OSDarwin importedLbl
 
514
        | Just (CodeStub, lbl) <- dynamicLinkerLabelInfo importedLbl
 
515
        = case opt_PIC of
 
516
           False ->
 
517
            vcat [
 
518
                ptext (sLit ".symbol_stub"),
 
519
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
 
520
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
521
                    ptext (sLit "\tlis r11,ha16(L") <> pprCLabel_asm lbl
 
522
                        <> ptext (sLit "$lazy_ptr)"),
 
523
                    ptext (sLit "\tlwz r12,lo16(L") <> pprCLabel_asm lbl
 
524
                        <> ptext (sLit "$lazy_ptr)(r11)"),
 
525
                    ptext (sLit "\tmtctr r12"),
 
526
                    ptext (sLit "\taddi r11,r11,lo16(L") <> pprCLabel_asm lbl
 
527
                        <> ptext (sLit "$lazy_ptr)"),
 
528
                    ptext (sLit "\tbctr")
 
529
            ]
 
530
           True ->
 
531
            vcat [
 
532
                ptext (sLit ".section __TEXT,__picsymbolstub1,")
 
533
                  <> ptext (sLit "symbol_stubs,pure_instructions,32"),
 
534
                ptext (sLit "\t.align 2"),
 
535
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
 
536
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
537
                    ptext (sLit "\tmflr r0"),
 
538
                    ptext (sLit "\tbcl 20,31,L0$") <> pprCLabel_asm lbl,
 
539
                ptext (sLit "L0$") <> pprCLabel_asm lbl <> char ':',
 
540
                    ptext (sLit "\tmflr r11"),
 
541
                    ptext (sLit "\taddis r11,r11,ha16(L") <> pprCLabel_asm lbl
 
542
                        <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm lbl <> char ')',
 
543
                    ptext (sLit "\tmtlr r0"),
 
544
                    ptext (sLit "\tlwzu r12,lo16(L") <> pprCLabel_asm lbl
 
545
                        <> ptext (sLit "$lazy_ptr-L0$") <> pprCLabel_asm lbl
 
546
                        <> ptext (sLit ")(r11)"),
 
547
                    ptext (sLit "\tmtctr r12"),
 
548
                    ptext (sLit "\tbctr")
 
549
            ]
 
550
          $+$ vcat [
 
551
                ptext (sLit ".lazy_symbol_pointer"),
 
552
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$lazy_ptr:"),
 
553
                ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
554
                ptext (sLit "\t.long dyld_stub_binding_helper")]
 
555
 
 
556
        | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
 
557
        = vcat [
 
558
                ptext (sLit ".non_lazy_symbol_pointer"),
 
559
                char 'L' <> pprCLabel_asm lbl <> ptext (sLit "$non_lazy_ptr:"),
 
560
                ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
561
                ptext (sLit "\t.long\t0")]
 
562
 
 
563
        | otherwise 
 
564
        = empty
 
565
 
 
566
                
 
567
pprImportedSymbol ArchX86 OSDarwin importedLbl
 
568
        | Just (CodeStub, lbl) <- dynamicLinkerLabelInfo importedLbl
 
569
        = case opt_PIC of
 
570
           False ->
 
571
            vcat [
 
572
                ptext (sLit ".symbol_stub"),
 
573
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
 
574
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
575
                    ptext (sLit "\tjmp *L") <> pprCLabel_asm lbl
 
576
                        <> ptext (sLit "$lazy_ptr"),
 
577
                ptext (sLit "L") <> pprCLabel_asm lbl
 
578
                    <> ptext (sLit "$stub_binder:"),
 
579
                    ptext (sLit "\tpushl $L") <> pprCLabel_asm lbl
 
580
                        <> ptext (sLit "$lazy_ptr"),
 
581
                    ptext (sLit "\tjmp dyld_stub_binding_helper")
 
582
            ]
 
583
           True ->
 
584
            vcat [
 
585
                ptext (sLit ".section __TEXT,__picsymbolstub2,")
 
586
                    <> ptext (sLit "symbol_stubs,pure_instructions,25"),
 
587
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$stub:"),
 
588
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
589
                    ptext (sLit "\tcall ___i686.get_pc_thunk.ax"),
 
590
                ptext (sLit "1:"),
 
591
                    ptext (sLit "\tmovl L") <> pprCLabel_asm lbl
 
592
                        <> ptext (sLit "$lazy_ptr-1b(%eax),%edx"),
 
593
                    ptext (sLit "\tjmp *%edx"),
 
594
                ptext (sLit "L") <> pprCLabel_asm lbl
 
595
                    <> ptext (sLit "$stub_binder:"),
 
596
                    ptext (sLit "\tlea L") <> pprCLabel_asm lbl
 
597
                        <> ptext (sLit "$lazy_ptr-1b(%eax),%eax"),
 
598
                    ptext (sLit "\tpushl %eax"),
 
599
                    ptext (sLit "\tjmp dyld_stub_binding_helper")
 
600
            ]
 
601
          $+$ vcat [        ptext (sLit ".section __DATA, __la_sym_ptr")
 
602
                    <> (if opt_PIC then int 2 else int 3)
 
603
                    <> ptext (sLit ",lazy_symbol_pointers"),
 
604
                ptext (sLit "L") <> pprCLabel_asm lbl <> ptext (sLit "$lazy_ptr:"),
 
605
                    ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
606
                    ptext (sLit "\t.long L") <> pprCLabel_asm lbl
 
607
                    <> ptext (sLit "$stub_binder")]
 
608
 
 
609
        | Just (SymbolPtr, lbl) <- dynamicLinkerLabelInfo importedLbl
 
610
        = vcat [
 
611
                ptext (sLit ".non_lazy_symbol_pointer"),
 
612
                char 'L' <> pprCLabel_asm lbl <> ptext (sLit "$non_lazy_ptr:"),
 
613
                ptext (sLit "\t.indirect_symbol") <+> pprCLabel_asm lbl,
 
614
                ptext (sLit "\t.long\t0")]
 
615
 
 
616
        | otherwise 
 
617
        = empty
 
618
 
 
619
 
 
620
pprImportedSymbol _ OSDarwin _
 
621
        = empty
 
622
        
 
623
 
 
624
-- ELF / Linux
 
625
--
 
626
-- In theory, we don't need to generate any stubs or symbol pointers
 
627
-- by hand for Linux.
 
628
--
 
629
-- Reality differs from this in two areas.
 
630
--
 
631
-- 1) If we just use a dynamically imported symbol directly in a read-only
 
632
--    section of the main executable (as GCC does), ld generates R_*_COPY
 
633
--    relocations, which are fundamentally incompatible with reversed info
 
634
--    tables. Therefore, we need a table of imported addresses in a writable
 
635
--    section.
 
636
--    The "official" GOT mechanism (label@got) isn't intended to be used
 
637
--    in position dependent code, so we have to create our own "fake GOT"
 
638
--    when not opt_PIC && not opt_Static.
 
639
--
 
640
-- 2) PowerPC Linux is just plain broken.
 
641
--    While it's theoretically possible to use GOT offsets larger
 
642
--    than 16 bit, the standard crt*.o files don't, which leads to
 
643
--    linker errors as soon as the GOT size exceeds 16 bit.
 
644
--    Also, the assembler doesn't support @gotoff labels.
 
645
--    In order to be able to use a larger GOT, we have to circumvent the
 
646
--    entire GOT mechanism and do it ourselves (this is also what GCC does).
 
647
 
 
648
 
 
649
-- When needImportedSymbols is defined,
 
650
-- the NCG will keep track of all DynamicLinkerLabels it uses
 
651
-- and output each of them using pprImportedSymbol.
 
652
 
 
653
pprImportedSymbol ArchPPC_64 os _
 
654
        | osElfTarget os
 
655
        = empty
 
656
 
 
657
pprImportedSymbol _ os importedLbl
 
658
        | osElfTarget os
 
659
        = case dynamicLinkerLabelInfo importedLbl of
 
660
            Just (SymbolPtr, lbl)
 
661
              -> let symbolSize = case wordWidth of
 
662
                         W32 -> sLit "\t.long"
 
663
                         W64 -> sLit "\t.quad"
 
664
                         _ -> panic "Unknown wordRep in pprImportedSymbol"
 
665
 
 
666
                 in vcat [
 
667
                      ptext (sLit ".section \".got2\", \"aw\""),
 
668
                      ptext (sLit ".LC_") <> pprCLabel_asm lbl <> char ':',
 
669
                      ptext symbolSize <+> pprCLabel_asm lbl ]
 
670
 
 
671
            -- PLT code stubs are generated automatically by the dynamic linker.
 
672
            _ -> empty
 
673
 
 
674
pprImportedSymbol _ _ _
 
675
        = panic "PIC.pprImportedSymbol: no match"
 
676
 
 
677
--------------------------------------------------------------------------------
 
678
-- Generate code to calculate the address that should be put in the
 
679
-- PIC base register.
 
680
-- This is called by MachCodeGen for every CmmProc that accessed the
 
681
-- PIC base register. It adds the appropriate instructions to the
 
682
-- top of the CmmProc.
 
683
 
 
684
-- It is assumed that the first NatCmmTop in the input list is a Proc
 
685
-- and the rest are CmmDatas.
 
686
 
 
687
-- Darwin is simple: just fetch the address of a local label.
 
688
-- The FETCHPC pseudo-instruction is expanded to multiple instructions
 
689
-- during pretty-printing so that we don't have to deal with the
 
690
-- local label:
 
691
 
 
692
-- PowerPC version:
 
693
--          bcl 20,31,1f.
 
694
--      1:  mflr picReg
 
695
 
 
696
-- i386 version:
 
697
--          call 1f
 
698
--      1:  popl %picReg
 
699
 
 
700
 
 
701
 
 
702
-- Get a pointer to our own fake GOT, which is defined on a per-module basis.
 
703
-- This is exactly how GCC does it, and it's quite horrible:
 
704
-- We first fetch the address of a local label (mkPicBaseLabel).
 
705
-- Then we add a 16-bit offset to that to get the address of a .long that we
 
706
-- define in .text space right next to the proc. This .long literal contains
 
707
-- the (32-bit) offset from our local label to our global offset table
 
708
-- (.LCTOC1 aka gotOffLabel).
 
709
 
 
710
initializePicBase_ppc 
 
711
        :: Arch -> OS -> Reg 
 
712
        -> [NatCmmTop PPC.Instr] 
 
713
        -> NatM [NatCmmTop PPC.Instr]
 
714
 
 
715
initializePicBase_ppc ArchPPC os picReg
 
716
    (CmmProc info lab params (ListGraph blocks) : statics)
 
717
    | osElfTarget os
 
718
    = do
 
719
        gotOffLabel <- getNewLabelNat
 
720
        tmp <- getNewRegNat $ intSize wordWidth
 
721
        let 
 
722
            gotOffset = CmmData Text [
 
723
                            CmmDataLabel gotOffLabel,
 
724
                            CmmStaticLit (CmmLabelDiffOff gotLabel
 
725
                                                          mkPicBaseLabel
 
726
                                                          0)
 
727
                        ]
 
728
            offsetToOffset
 
729
                        = PPC.ImmConstantDiff 
 
730
                                (PPC.ImmCLbl gotOffLabel)
 
731
                                (PPC.ImmCLbl mkPicBaseLabel)
 
732
 
 
733
            BasicBlock bID insns 
 
734
                        = head blocks
 
735
 
 
736
            b' = BasicBlock bID (PPC.FETCHPC picReg
 
737
                               : PPC.LD PPC.archWordSize tmp
 
738
                                    (PPC.AddrRegImm picReg offsetToOffset)
 
739
                               : PPC.ADD picReg picReg (PPC.RIReg tmp)
 
740
                               : insns)
 
741
 
 
742
        return (CmmProc info lab params (ListGraph (b' : tail blocks)) : gotOffset : statics)
 
743
 
 
744
initializePicBase_ppc ArchPPC OSDarwin picReg
 
745
        (CmmProc info lab params (ListGraph blocks) : statics)
 
746
        = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
 
747
 
 
748
        where   BasicBlock bID insns = head blocks
 
749
                b' = BasicBlock bID (PPC.FETCHPC picReg : insns)
 
750
 
 
751
 
 
752
initializePicBase_ppc _ _ _ _
 
753
        = panic "initializePicBase_ppc: not needed"
 
754
 
 
755
 
 
756
-- We cheat a bit here by defining a pseudo-instruction named FETCHGOT
 
757
-- which pretty-prints as:
 
758
--              call 1f
 
759
-- 1:           popl %picReg
 
760
--              addl __GLOBAL_OFFSET_TABLE__+.-1b, %picReg
 
761
-- (See PprMach.lhs)
 
762
 
 
763
initializePicBase_x86
 
764
        :: Arch -> OS -> Reg 
 
765
        -> [NatCmmTop X86.Instr] 
 
766
        -> NatM [NatCmmTop X86.Instr]
 
767
 
 
768
initializePicBase_x86 ArchX86 os picReg 
 
769
        (CmmProc info lab params (ListGraph blocks) : statics)
 
770
    | osElfTarget os
 
771
    = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
 
772
    where BasicBlock bID insns = head blocks
 
773
          b' = BasicBlock bID (X86.FETCHGOT picReg : insns)
 
774
 
 
775
initializePicBase_x86 ArchX86 OSDarwin picReg
 
776
        (CmmProc info lab params (ListGraph blocks) : statics)
 
777
        = return (CmmProc info lab params (ListGraph (b':tail blocks)) : statics)
 
778
 
 
779
        where   BasicBlock bID insns = head blocks
 
780
                b' = BasicBlock bID (X86.FETCHPC picReg : insns)
 
781
 
 
782
initializePicBase_x86 _ _ _ _
 
783
        = panic "initializePicBase_x86: not needed"
 
784