ghc/compiler/absCSyn/AbsCSyn.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 % $Id: AbsCSyn.lhs,v 1.44 2002/01/02 12:32:19 simonmar Exp $
   5 %
   6 \section[AbstractC]{Abstract C: the last stop before machine code}
   7
   8 This ``Abstract C'' data type describes the raw Spineless Tagless
   9 machine model at a C-ish level; it is ``abstract'' in that it only
  10 includes C-like structures that we happen to need.  The conversion of
  11 programs from @StgSyntax@ (basically a functional language) to
  12 @AbstractC@ (basically imperative C) is the heart of code generation.
  13 From @AbstractC@, one may convert to real C (for portability) or to
  14 raw assembler/machine code.
  15
  16 \begin{code}
  17 module AbsCSyn {- (
  18         -- export everything
  19         AbstractC(..),
  20         C_SRT(..)
  21         CStmtMacro(..),
  22         CExprMacro(..),
  23         CAddrMode(..),
  24         ReturnInfo(..),
  25         mkAbstractCs, mkAbsCStmts, mkAlgAltsCSwitch,
  26         mkIntCLit,
  27         mkAbsCStmtList,
  28         mkCCostCentre,
  29
  30         -- RegRelatives
  31         RegRelative(..),
  32
  33         -- registers
  34         MagicId(..), node, infoptr,
  35         isVolatileReg,
  36         CostRes(Cost)
  37     )-} where
  38
  39 #include "HsVersions.h"
  40
  41 import {-# SOURCE #-} ClosureInfo ( ClosureInfo )
  42
  43 import CLabel
  44 import Constants        ( mAX_Vanilla_REG, mAX_Float_REG,
  45                           mAX_Double_REG, spRelToInt )
  46 import CostCentre       ( CostCentre, CostCentreStack )
  47 import Literal          ( mkMachInt, Literal(..) )
  48 import ForeignCall      ( CCallSpec )
  49 import PrimRep          ( PrimRep(..) )
  50 import MachOp           ( MachOp(..) )
  51 import Unique           ( Unique )
  52 import StgSyn           ( StgOp )
  53 import TyCon            ( TyCon )
  54 import BitSet                           -- for liveness masks
  55 import FastTypes
  56
  57 import Outputable
  58 \end{code}
  59
  60 @AbstractC@ is a list of Abstract~C statements, but the data structure
  61 is tree-ish, for easier and more efficient putting-together.
  62 \begin{code}
  63 absCNop = AbsCNop
  64
  65 data AbstractC
  66   = AbsCNop
  67   | AbsCStmts           AbstractC AbstractC
  68
  69   -- and the individual stmts...
  70 \end{code}
  71
  72 A note on @CAssign@: In general, the type associated with an assignment
  73 is the type of the lhs.  However, when the lhs is a pointer to mixed
  74 types (e.g. SpB relative), the type of the assignment is the type of
  75 the rhs for float types, or the generic StgWord for all other types.
  76 (In particular, a CharRep on the rhs is promoted to IntRep when
  77 stored in a mixed type location.)
  78
  79 \begin{code}
  80   | CAssign
  81         !CAddrMode      -- target
  82         !CAddrMode      -- source
  83
  84   | CJump
  85         CAddrMode       -- Put this in the program counter
  86                         -- eg `CJump (CReg (VanillaReg PtrRep 1))' puts Ret1 in PC
  87                         -- Enter can be done by:
  88                         --        CJump (CVal NodeRel zeroOff)
  89
  90   | CFallThrough
  91         CAddrMode       -- Fall through into this routine
  92                         -- (for the benefit of the native code generators)
  93                         -- Equivalent to CJump in C land
  94
  95   | CReturn             -- Perform a return
  96         CAddrMode       -- Address of a RET_<blah> info table
  97         ReturnInfo      -- Whether it's a direct or vectored return
  98
  99   | CSwitch !CAddrMode
 100         [(Literal, AbstractC)]  -- alternatives
 101         AbstractC               -- default; if there is no real Abstract C in here
 102                                 -- (e.g., all comments; see function "nonemptyAbsC"),
 103                                 -- then that means the default _cannot_ occur.
 104                                 -- If there is only one alternative & no default code,
 105                                 -- then there is no need to check the tag.
 106                                 -- Therefore, e.g.:
 107                                 --  CSwitch m [(tag,code)] AbsCNop == code
 108
 109   | CCodeBlock CLabel AbstractC
 110                         -- A labelled block of code; this "statement" is not
 111                         -- executed; rather, the labelled code will be hoisted
 112                         -- out to the top level (out of line) & it can be
 113                         -- jumped to.
 114
 115   | CInitHdr            -- to initialise the header of a closure (both fixed/var parts)
 116         ClosureInfo
 117         CAddrMode       -- address of the info ptr
 118         !CAddrMode      -- cost centre to place in closure
 119                         --   CReg CurCostCentre or CC_HDR(R1.p{-Node-})
 120         Int             -- size of closure, for profiling
 121
 122   -- NEW CASES FOR EXPANDED PRIMOPS
 123
 124   | CMachOpStmt                 -- Machine-level operation
 125         (Maybe CAddrMode)       -- 0 or 1 results
 126         MachOp
 127         [CAddrMode]             -- Arguments
 128         (Maybe [MagicId])       -- list of regs which need to be preserved
 129         -- across the primop.  This is allowed to be Nothing only if
 130         -- machOpIsDefinitelyInline returns True.  And that in turn may
 131         -- only return True if we are absolutely sure that the mach op
 132         -- can be done inline on all platforms.
 133
 134   | CSequential         -- Do the nested AbstractCs sequentially.
 135         [AbstractC]     -- In particular, as far as the AbsCUtils.doSimultaneously
 136                         -- is concerned, these stmts are to be treated as atomic
 137                         -- and are not to be reordered.
 138
 139   -- end of NEW CASES FOR EXPANDED PRIMOPS
 140
 141   | COpStmt
 142         [CAddrMode]     -- Results
 143         StgOp
 144         [CAddrMode]     -- Arguments
 145         [MagicId]       -- Potentially volatile/live registers
 146                         -- (to save/restore around the call/op)
 147
 148         -- INVARIANT: When a PrimOp which can cause GC is used, the
 149         -- only live data is tidily on the STG stacks or in the STG
 150         -- registers (the code generator ensures this).
 151         --
 152         -- Why this?  Because if the arguments were arbitrary
 153         -- addressing modes, they might be things like (Hp+6) which
 154         -- will get utterly spongled by GC.
 155
 156   | CSimultaneous       -- Perform simultaneously all the statements
 157         AbstractC       -- in the nested AbstractC.  They are only
 158                         -- allowed to be CAssigns, COpStmts and AbsCNops, so the
 159                         -- "simultaneous" part just concerns making
 160                         -- sure that permutations work.
 161                         -- For example { a := b, b := a }
 162                         --      needs to go via (at least one) temporary
 163
 164   | CCheck              -- heap or stack checks, or both.
 165         CCheckMacro     -- These might include some code to fill in tags
 166         [CAddrMode]     -- on the stack, so we can't use CMacroStmt below.
 167         AbstractC
 168
 169   | CRetDirect                  -- Direct return
 170         !Unique                 -- for making labels
 171         AbstractC               -- return code
 172         C_SRT                   -- SRT info
 173         Liveness                -- stack liveness at the return point
 174
 175   -- see the notes about these next few; they follow below...
 176   | CMacroStmt          CStmtMacro      [CAddrMode]
 177   | CCallProfCtrMacro   FAST_STRING     [CAddrMode]
 178   | CCallProfCCMacro    FAST_STRING     [CAddrMode]
 179
 180     {- The presence of this constructor is a makeshift solution;
 181        it being used to work around a gcc-related problem of
 182        handling typedefs within statement blocks (or, rather,
 183        the inability to do so.)
 184
 185        The AbstractC flattener takes care of lifting out these
 186        typedefs if needs be (i.e., when generating .hc code and
 187        compiling 'foreign import dynamic's)
 188     -}
 189   | CCallTypedef Bool {- True => use "typedef"; False => use "extern"-}
 190                  CCallSpec Unique [CAddrMode] [CAddrMode]
 191
 192   -- *** the next three [or so...] are DATA (those above are CODE) ***
 193
 194   | CStaticClosure
 195         ClosureInfo             -- Todo: maybe info_lbl & closure_lbl instead?
 196         CAddrMode               -- cost centre identifier to place in closure
 197         [CAddrMode]             -- free vars; ptrs, then non-ptrs.
 198
 199   | CSRT CLabel [CLabel]        -- SRT declarations: basically an array of
 200                                 -- pointers to static closures.
 201
 202   | CBitmap CLabel LivenessMask -- A bitmap to be emitted if and only if
 203                                 -- it is larger than a target machine word.
 204
 205   | CClosureInfoAndCode
 206         ClosureInfo             -- Explains placement and layout of closure
 207         AbstractC               -- Slow entry point code
 208         (Maybe AbstractC)
 209                                 -- Fast entry point code, if any
 210         String                  -- Closure description; NB we can't get this
 211                                 -- from ClosureInfo, because the latter refers
 212                                 -- to the *right* hand side of a defn, whereas
 213                                 -- the  "description" refers to *left* hand side
 214
 215   | CRetVector                  -- A labelled block of static data
 216         CLabel
 217         [CAddrMode]
 218         C_SRT                   -- SRT info
 219         Liveness                -- stack liveness at the return point
 220
 221   | CClosureTbl                 -- table of constructors for enumerated types
 222         TyCon                   -- which TyCon this table is for
 223
 224   | CModuleInitBlock            -- module initialisation block
 225         CLabel                  -- label for init block
 226         AbstractC               -- initialisation code
 227
 228   | CCostCentreDecl             -- A cost centre *declaration*
 229         Bool                    -- True  <=> local => full declaration
 230                                 -- False <=> extern; just say so
 231         CostCentre
 232
 233   | CCostCentreStackDecl        -- A cost centre stack *declaration*
 234         CostCentreStack         -- this is the declaration for a
 235                                 -- pre-defined singleton CCS (see
 236                                 -- CostCentre.lhs)
 237
 238   | CSplitMarker                -- Split into separate object modules here
 239
 240 -- C_SRT is what StgSyn.SRT gets translated to...
 241 -- we add a label for the table, and expect only the 'offset/length' form
 242
 243 data C_SRT = NoC_SRT
 244            | C_SRT CLabel !Int{-offset-} !Int{-length-}
 245
 246 needsSRT :: C_SRT -> Bool
 247 needsSRT NoC_SRT       = False
 248 needsSRT (C_SRT _ _ _) = True
 249 \end{code}
 250
 251 About @CMacroStmt@, etc.: notionally, they all just call some
 252 arbitrary C~macro or routine, passing the @CAddrModes@ as arguments.
 253 However, we distinguish between various flavours of these things,
 254 mostly just to keep things somewhat less wild and wooly.
 255
 256 \begin{description}
 257 \item[@CMacroStmt@:]
 258 Some {\em essential} bits of the STG execution model are done with C
 259 macros.  An example is @STK_CHK@, which checks for stack-space
 260 overflow.  This enumeration type lists all such macros:
 261 \begin{code}
 262 data CStmtMacro
 263   = ARGS_CHK                            -- arg satisfaction check
 264   | ARGS_CHK_LOAD_NODE                  -- arg check for top-level functions
 265   | UPD_CAF                             -- update CAF closure with indirection
 266   | UPD_BH_UPDATABLE                    -- eager backholing
 267   | UPD_BH_SINGLE_ENTRY                 -- more eager blackholing
 268   | PUSH_UPD_FRAME                      -- push update frame
 269   | PUSH_SEQ_FRAME                      -- push seq frame
 270   | UPDATE_SU_FROM_UPD_FRAME            -- pull Su out of the update frame
 271   | SET_TAG                             -- set TagReg if it exists
 272
 273   | REGISTER_FOREIGN_EXPORT             -- register a foreign exported fun
 274   | REGISTER_IMPORT                     -- register an imported module
 275   | REGISTER_DIMPORT                    -- register an imported module from
 276                                         -- another DLL
 277
 278   | GRAN_FETCH                  -- for GrAnSim only  -- HWL
 279   | GRAN_RESCHEDULE             -- for GrAnSim only  -- HWL
 280   | GRAN_FETCH_AND_RESCHEDULE   -- for GrAnSim only  -- HWL
 281   | THREAD_CONTEXT_SWITCH       -- for GrAnSim only  -- HWL
 282   | GRAN_YIELD                  -- for GrAnSim only  -- HWL
 283 \end{code}
 284
 285 Heap/Stack checks.  There are far too many of these.
 286
 287 \begin{code}
 288 data CCheckMacro
 289
 290   = HP_CHK_NP                           -- heap/stack checks when
 291   | STK_CHK_NP                          -- node points to the closure
 292   | HP_STK_CHK_NP
 293   | HP_CHK_SEQ_NP                       -- for 'seq' style case alternatives
 294
 295   | HP_CHK                              -- heap/stack checks when
 296   | STK_CHK                             -- node doesn't point
 297   | HP_STK_CHK
 298                                         -- case alternative heap checks:
 299
 300   | HP_CHK_NOREGS                       --   no registers live
 301   | HP_CHK_UNPT_R1                      --   R1 is boxed/unlifted
 302   | HP_CHK_UNBX_R1                      --   R1 is unboxed
 303   | HP_CHK_F1                           --   FloatReg1 (only) is live
 304   | HP_CHK_D1                           --   DblReg1   (only) is live
 305   | HP_CHK_L1                           --   LngReg1   (only) is live
 306   | HP_CHK_UT_ALT                       --   unboxed tuple return.
 307
 308   | HP_CHK_GEN                          -- generic heap check
 309 \end{code}
 310
 311 \item[@CCallProfCtrMacro@:]
 312 The @String@ names a macro that, if \tr{#define}d, will bump one/some
 313 of the STG-event profiling counters.
 314
 315 \item[@CCallProfCCMacro@:]
 316 The @String@ names a macro that, if \tr{#define}d, will perform some
 317 cost-centre-profiling-related action.
 318 \end{description}
 319
 320 %************************************************************************
 321 %*                                                                      *
 322 \subsection[CAddrMode]{C addressing modes}
 323 %*                                                                      *
 324 %************************************************************************
 325
 326 \begin{code}
 327 data CAddrMode
 328   = CVal  RegRelative PrimRep
 329                         -- On RHS of assign: Contents of Magic[n]
 330                         -- On LHS of assign: location Magic[n]
 331                         -- (ie at addr Magic+n)
 332
 333   | CAddr RegRelative
 334                         -- On RHS of assign: Address of Magic[n]; ie Magic+n
 335                         --      n=0 gets the Magic location itself
 336                         --      (NB: n=0 case superceded by CReg)
 337                         -- On LHS of assign: only sensible if n=0,
 338                         --      which gives the magic location itself
 339                         --      (NB: superceded by CReg)
 340
 341   | CReg MagicId        -- To replace (CAddr MagicId 0)
 342
 343   | CTemp !Unique !PrimRep      -- Temporary locations
 344         -- ``Temporaries'' correspond to local variables in C, and registers in
 345         -- native code.
 346
 347   | CLbl    CLabel      -- Labels in the runtime system, etc.
 348             PrimRep     -- the kind is so we can generate accurate C decls
 349
 350   | CCharLike CAddrMode -- The address of a static char-like closure for
 351                         -- the specified character.  It is guaranteed to be in
 352                         -- the range mIN_CHARLIKE..mAX_CHARLIKE
 353
 354   | CIntLike CAddrMode  -- The address of a static int-like closure for the
 355                         -- specified small integer.  It is guaranteed to be in
 356                         -- the range mIN_INTLIKE..mAX_INTLIKE
 357
 358   | CLit    Literal
 359
 360   | CJoinPoint          -- This is used as the amode of a let-no-escape-bound
 361                         -- variable.
 362         VirtualSpOffset   -- Sp value after any volatile free vars
 363                           -- of the rhs have been saved on stack.
 364                           -- Just before the code for the thing is jumped to,
 365                           -- Sp will be set to this value,
 366                           -- and then any stack-passed args pushed,
 367                           -- then the code for this thing will be entered
 368   | CMacroExpr
 369         !PrimRep        -- the kind of the result
 370         CExprMacro      -- the macro to generate a value
 371         [CAddrMode]     -- and its arguments
 372
 373   | CMem   PrimRep      -- A value :: PrimRep, in memory, at the
 374            CAddrMode    -- specified address
 375
 376   | CBytesPerWord       -- Word size, in bytes, on this platform
 377                         -- required for: half-word loads (used in fishing tags
 378                         -- out of info tables), and sizeofByteArray#.
 379 \end{code}
 380
 381 Various C macros for values which are dependent on the back-end layout.
 382
 383 \begin{code}
 384
 385 data CExprMacro
 386   = ENTRY_CODE
 387   | ARG_TAG                             -- stack argument tagging
 388   | GET_TAG                             -- get current constructor tag
 389   | UPD_FRAME_UPDATEE
 390   | CCS_HDR
 391
 392 \end{code}
 393
 394 Convenience functions:
 395
 396 \begin{code}
 397 mkIntCLit :: Int -> CAddrMode
 398 mkIntCLit i = CLit (mkMachInt (toInteger i))
 399
 400 mkCString :: FAST_STRING -> CAddrMode
 401 mkCString s = CLit (MachStr s)
 402
 403 mkCCostCentre :: CostCentre -> CAddrMode
 404 mkCCostCentre cc = CLbl (mkCC_Label cc) DataPtrRep
 405
 406 mkCCostCentreStack :: CostCentreStack -> CAddrMode
 407 mkCCostCentreStack ccs = CLbl (mkCCS_Label ccs) DataPtrRep
 408 \end{code}
 409
 410 %************************************************************************
 411 %*                                                                      *
 412 \subsection[RegRelative]{@RegRelatives@: ???}
 413 %*                                                                      *
 414 %************************************************************************
 415
 416 \begin{code}
 417 data RegRelative
 418   = HpRel       FastInt -- }
 419   | SpRel       FastInt -- }- offsets in StgWords
 420   | NodeRel     FastInt -- }
 421   | CIndex      CAddrMode CAddrMode PrimRep     -- pointer arithmetic :-)
 422                                                 -- CIndex a b k === (k*)a[b]
 423
 424 data ReturnInfo
 425   = DirectReturn                        -- Jump directly, if possible
 426   | StaticVectoredReturn Int            -- Fixed tag, starting at zero
 427   | DynamicVectoredReturn CAddrMode     -- Dynamic tag given by amode, starting at zero
 428
 429 hpRel :: VirtualHeapOffset      -- virtual offset of Hp
 430       -> VirtualHeapOffset      -- virtual offset of The Thing
 431       -> RegRelative            -- integer offset
 432 hpRel hp off = HpRel (iUnbox (hp - off))
 433
 434 spRel :: VirtualSpOffset        -- virtual offset of Sp
 435       -> VirtualSpOffset        -- virtual offset of The Thing
 436       -> RegRelative            -- integer offset
 437 spRel sp off = SpRel (iUnbox (spRelToInt sp off))
 438
 439 nodeRel :: VirtualHeapOffset
 440         -> RegRelative
 441 nodeRel off = NodeRel (iUnbox off)
 442
 443 \end{code}
 444
 445 %************************************************************************
 446 %*                                                                      *
 447 \subsection[Liveness]{Liveness Masks}
 448 %*                                                                      *
 449 %************************************************************************
 450
 451 We represent liveness bitmaps as a BitSet (whose internal
 452 representation really is a bitmap).  These are pinned onto case return
 453 vectors to indicate the state of the stack for the garbage collector.
 454
 455 In the compiled program, liveness bitmaps that fit inside a single
 456 word (StgWord) are stored as a single word, while larger bitmaps are
 457 stored as a pointer to an array of words.  When we compile via C
 458 (especially when we bootstrap via HC files), we generate identical C
 459 code regardless of whether words are 32- or 64-bit on the target
 460 machine, by postponing the decision of how to store each liveness
 461 bitmap to C compilation time (or rather, C preprocessing time).
 462
 463 \begin{code}
 464 type LivenessMask = [BitSet]
 465
 466 data Liveness = Liveness CLabel LivenessMask
 467 \end{code}
 468
 469 %************************************************************************
 470 %*                                                                      *
 471 \subsection[HeapOffset]{@Heap Offsets@}
 472 %*                                                                      *
 473 %************************************************************************
 474
 475 This used to be a grotesquely complicated datatype in an attempt to
 476 hide the details of header sizes from the compiler itself.  Now these
 477 constants are imported from the RTS, and we deal in real Ints.
 478
 479 \begin{code}
 480 type HeapOffset = Int                   -- ToDo: remove
 481
 482 type VirtualHeapOffset  = HeapOffset
 483 type VirtualSpOffset    = Int
 484
 485 type HpRelOffset        = HeapOffset
 486 type SpRelOffset        = Int
 487 \end{code}
 488
 489 %************************************************************************
 490 %*                                                                      *
 491 \subsection[MagicId]{@MagicIds@: registers and such}
 492 %*                                                                      *
 493 %************************************************************************
 494
 495 \begin{code}
 496 data MagicId
 497   = BaseReg     -- mentioned only in nativeGen
 498
 499   -- Argument and return registers
 500   | VanillaReg          -- pointers, unboxed ints and chars
 501         PrimRep
 502         FastInt -- its number (1 .. mAX_Vanilla_REG)
 503
 504   | FloatReg            -- single-precision floating-point registers
 505         FastInt -- its number (1 .. mAX_Float_REG)
 506
 507   | DoubleReg           -- double-precision floating-point registers
 508         FastInt -- its number (1 .. mAX_Double_REG)
 509
 510   -- STG registers
 511   | Sp                  -- Stack ptr; points to last occupied stack location.
 512   | Su                  -- Stack update frame pointer
 513   | SpLim               -- Stack limit
 514   | Hp                  -- Heap ptr; points to last occupied heap location.
 515   | HpLim               -- Heap limit register
 516   | CurCostCentre       -- current cost centre register.
 517   | VoidReg             -- see "VoidPrim" type; just a placeholder;
 518                         --   no actual register
 519   | LongReg             -- long int registers (64-bit, really)
 520         PrimRep         -- Int64Rep or Word64Rep
 521         FastInt -- its number (1 .. mAX_Long_REG)
 522
 523   | CurrentTSO          -- pointer to current thread's TSO
 524   | CurrentNursery      -- pointer to allocation area
 525   | HpAlloc             -- allocation count for heap check failure
 526
 527
 528 node    = VanillaReg PtrRep     (_ILIT 1) -- A convenient alias for Node
 529 tagreg  = VanillaReg WordRep    (_ILIT 2) -- A convenient alias for TagReg
 530
 531 nodeReg = CReg node
 532 \end{code}
 533
 534 We need magical @Eq@ because @VanillaReg@s come in multiple flavors.
 535
 536 \begin{code}
 537 instance Eq MagicId where
 538     reg1 == reg2 = tag reg1 ==# tag reg2
 539      where
 540         tag BaseReg          = (_ILIT(0) :: FastInt)
 541         tag Sp               = _ILIT(1)
 542         tag Su               = _ILIT(2)
 543         tag SpLim            = _ILIT(3)
 544         tag Hp               = _ILIT(4)
 545         tag HpLim            = _ILIT(5)
 546         tag CurCostCentre    = _ILIT(6)
 547         tag VoidReg          = _ILIT(7)
 548
 549         tag (VanillaReg _ i) = _ILIT(8) +# i
 550
 551         tag (FloatReg i)  = _ILIT(8) +# maxv +# i
 552         tag (DoubleReg i) = _ILIT(8) +# maxv +# maxf +# i
 553         tag (LongReg _ i) = _ILIT(8) +# maxv +# maxf +# maxd +# i
 554
 555         maxv = iUnbox mAX_Vanilla_REG
 556         maxf = iUnbox mAX_Float_REG
 557         maxd = iUnbox mAX_Double_REG
 558 \end{code}
 559
 560 Returns True for any register that {\em potentially} dies across
 561 C calls (or anything near equivalent).  We just say @True@ and
 562 let the (machine-specific) registering macros sort things out...
 563
 564 \begin{code}
 565 isVolatileReg :: MagicId -> Bool
 566 isVolatileReg any = True
 567 \end{code}