ghc/compiler/absCSyn/AbsCSyn.lhs

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