2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 % $Id: AbsCSyn.lhs,v 1.37 2001/07/24 05:04:58 ken Exp $
6 \section[AbstractC]{Abstract C: the last stop before machine code}
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.
24 mkAbstractCs, mkAbsCStmts, mkAlgAltsCSwitch,
33 MagicId(..), node, infoptr,
38 #include "HsVersions.h"
40 import {-# SOURCE #-} ClosureInfo ( ClosureInfo )
43 import Constants ( mAX_Vanilla_REG, mAX_Float_REG,
44 mAX_Double_REG, spRelToInt )
45 import CostCentre ( CostCentre, CostCentreStack )
46 import Literal ( mkMachInt, Literal(..) )
47 import ForeignCall ( CCallSpec )
48 import PrimRep ( PrimRep(..) )
49 import Unique ( Unique )
50 import StgSyn ( StgOp, SRT(..) )
51 import TyCon ( TyCon )
52 import BitSet -- for liveness masks
57 @AbstractC@ is a list of Abstract~C statements, but the data structure
58 is tree-ish, for easier and more efficient putting-together.
64 | AbsCStmts AbstractC AbstractC
66 -- and the individual stmts...
69 A note on @CAssign@: In general, the type associated with an assignment
70 is the type of the lhs. However, when the lhs is a pointer to mixed
71 types (e.g. SpB relative), the type of the assignment is the type of
72 the rhs for float types, or the generic StgWord for all other types.
73 (In particular, a CharRep on the rhs is promoted to IntRep when
74 stored in a mixed type location.)
82 CAddrMode -- Put this in the program counter
83 -- eg `CJump (CReg (VanillaReg PtrRep 1))' puts Ret1 in PC
84 -- Enter can be done by:
85 -- CJump (CVal NodeRel zeroOff)
88 CAddrMode -- Fall through into this routine
89 -- (for the benefit of the native code generators)
90 -- Equivalent to CJump in C land
92 | CReturn -- Perform a return
93 CAddrMode -- Address of a RET_<blah> info table
94 ReturnInfo -- Whether it's a direct or vectored return
97 [(Literal, AbstractC)] -- alternatives
98 AbstractC -- default; if there is no real Abstract C in here
99 -- (e.g., all comments; see function "nonemptyAbsC"),
100 -- then that means the default _cannot_ occur.
101 -- If there is only one alternative & no default code,
102 -- then there is no need to check the tag.
104 -- CSwitch m [(tag,code)] AbsCNop == code
106 | CCodeBlock CLabel AbstractC
107 -- A labelled block of code; this "statement" is not
108 -- executed; rather, the labelled code will be hoisted
109 -- out to the top level (out of line) & it can be
112 | CInitHdr -- to initialise the header of a closure (both fixed/var parts)
114 CAddrMode -- address of the info ptr
115 CAddrMode -- cost centre to place in closure
116 -- CReg CurCostCentre or CC_HDR(R1.p{-Node-})
119 [CAddrMode] -- Results
121 [CAddrMode] -- Arguments
122 [MagicId] -- Potentially volatile/live registers
123 -- (to save/restore around the call/op)
125 -- INVARIANT: When a PrimOp which can cause GC is used, the
126 -- only live data is tidily on the STG stacks or in the STG
127 -- registers (the code generator ensures this).
129 -- Why this? Because if the arguments were arbitrary
130 -- addressing modes, they might be things like (Hp+6) which
131 -- will get utterly spongled by GC.
133 | CSimultaneous -- Perform simultaneously all the statements
134 AbstractC -- in the nested AbstractC. They are only
135 -- allowed to be CAssigns, COpStmts and AbsCNops, so the
136 -- "simultaneous" part just concerns making
137 -- sure that permutations work.
138 -- For example { a := b, b := a }
139 -- needs to go via (at least one) temporary
141 | CCheck -- heap or stack checks, or both.
142 CCheckMacro -- These might include some code to fill in tags
143 [CAddrMode] -- on the stack, so we can't use CMacroStmt below.
146 | CRetDirect -- Direct return
147 !Unique -- for making labels
148 AbstractC -- return code
149 (CLabel,SRT) -- SRT info
150 Liveness -- stack liveness at the return point
152 -- see the notes about these next few; they follow below...
153 | CMacroStmt CStmtMacro [CAddrMode]
154 | CCallProfCtrMacro FAST_STRING [CAddrMode]
155 | CCallProfCCMacro FAST_STRING [CAddrMode]
157 {- The presence of this constructor is a makeshift solution;
158 it being used to work around a gcc-related problem of
159 handling typedefs within statement blocks (or, rather,
160 the inability to do so.)
162 The AbstractC flattener takes care of lifting out these
163 typedefs if needs be (i.e., when generating .hc code and
164 compiling 'foreign import dynamic's)
166 | CCallTypedef Bool {- True => use "typedef"; False => use "extern"-}
167 CCallSpec Unique [CAddrMode] [CAddrMode]
169 -- *** the next three [or so...] are DATA (those above are CODE) ***
172 CLabel -- The (full, not base) label to use for labelling the closure.
174 CAddrMode -- cost centre identifier to place in closure
175 [CAddrMode] -- free vars; ptrs, then non-ptrs.
177 | CSRT CLabel [CLabel] -- SRT declarations: basically an array of
178 -- pointers to static closures.
180 | CBitmap CLabel LivenessMask -- A bitmap to be emitted if and only if
181 -- it is larger than a target machine word.
183 | CClosureInfoAndCode
184 ClosureInfo -- Explains placement and layout of closure
185 AbstractC -- Slow entry point code
187 -- Fast entry point code, if any
188 String -- Closure description; NB we can't get this
189 -- from ClosureInfo, because the latter refers
190 -- to the *right* hand side of a defn, whereas
191 -- the "description" refers to *left* hand side
193 | CRetVector -- A labelled block of static data
196 (CLabel,SRT) -- SRT info
197 Liveness -- stack liveness at the return point
199 | CClosureTbl -- table of constructors for enumerated types
200 TyCon -- which TyCon this table is for
202 | CModuleInitBlock -- module initialisation block
203 CLabel -- label for init block
204 AbstractC -- initialisation code
206 | CCostCentreDecl -- A cost centre *declaration*
207 Bool -- True <=> local => full declaration
208 -- False <=> extern; just say so
211 | CCostCentreStackDecl -- A cost centre stack *declaration*
212 CostCentreStack -- this is the declaration for a
213 -- pre-defined singleton CCS (see
216 | CSplitMarker -- Split into separate object modules here
219 About @CMacroStmt@, etc.: notionally, they all just call some
220 arbitrary C~macro or routine, passing the @CAddrModes@ as arguments.
221 However, we distinguish between various flavours of these things,
222 mostly just to keep things somewhat less wild and wooly.
226 Some {\em essential} bits of the STG execution model are done with C
227 macros. An example is @STK_CHK@, which checks for stack-space
228 overflow. This enumeration type lists all such macros:
231 = ARGS_CHK -- arg satisfaction check
232 | ARGS_CHK_LOAD_NODE -- arg check for top-level functions
233 | UPD_CAF -- update CAF closure with indirection
234 | UPD_BH_UPDATABLE -- eager backholing
235 | UPD_BH_SINGLE_ENTRY -- more eager blackholing
236 | PUSH_UPD_FRAME -- push update frame
237 | PUSH_SEQ_FRAME -- push seq frame
238 | UPDATE_SU_FROM_UPD_FRAME -- pull Su out of the update frame
239 | SET_TAG -- set TagReg if it exists
241 | REGISTER_FOREIGN_EXPORT -- register a foreign exported fun
242 | REGISTER_IMPORT -- register an imported module
243 | REGISTER_DIMPORT -- register an imported module from
246 | GRAN_FETCH -- for GrAnSim only -- HWL
247 | GRAN_RESCHEDULE -- for GrAnSim only -- HWL
248 | GRAN_FETCH_AND_RESCHEDULE -- for GrAnSim only -- HWL
249 | THREAD_CONTEXT_SWITCH -- for GrAnSim only -- HWL
250 | GRAN_YIELD -- for GrAnSim only -- HWL
253 Heap/Stack checks. There are far too many of these.
258 = HP_CHK_NP -- heap/stack checks when
259 | STK_CHK_NP -- node points to the closure
261 | HP_CHK_SEQ_NP -- for 'seq' style case alternatives
263 | HP_CHK -- heap/stack checks when
264 | STK_CHK -- node doesn't point
266 -- case alternative heap checks:
268 | HP_CHK_NOREGS -- no registers live
269 | HP_CHK_UNPT_R1 -- R1 is boxed/unlifted
270 | HP_CHK_UNBX_R1 -- R1 is unboxed
271 | HP_CHK_F1 -- FloatReg1 (only) is live
272 | HP_CHK_D1 -- DblReg1 (only) is live
273 | HP_CHK_L1 -- LngReg1 (only) is live
274 | HP_CHK_UT_ALT -- unboxed tuple return.
276 | HP_CHK_GEN -- generic heap check
279 \item[@CCallProfCtrMacro@:]
280 The @String@ names a macro that, if \tr{#define}d, will bump one/some
281 of the STG-event profiling counters.
283 \item[@CCallProfCCMacro@:]
284 The @String@ names a macro that, if \tr{#define}d, will perform some
285 cost-centre-profiling-related action.
288 %************************************************************************
290 \subsection[CAddrMode]{C addressing modes}
292 %************************************************************************
296 = CVal RegRelative PrimRep
297 -- On RHS of assign: Contents of Magic[n]
298 -- On LHS of assign: location Magic[n]
299 -- (ie at addr Magic+n)
302 -- On RHS of assign: Address of Magic[n]; ie Magic+n
303 -- n=0 gets the Magic location itself
304 -- (NB: n=0 case superceded by CReg)
305 -- On LHS of assign: only sensible if n=0,
306 -- which gives the magic location itself
307 -- (NB: superceded by CReg)
309 | CReg MagicId -- To replace (CAddr MagicId 0)
311 | CTemp !Unique !PrimRep -- Temporary locations
312 -- ``Temporaries'' correspond to local variables in C, and registers in
315 | CLbl CLabel -- Labels in the runtime system, etc.
316 PrimRep -- the kind is so we can generate accurate C decls
318 | CCharLike CAddrMode -- The address of a static char-like closure for
319 -- the specified character. It is guaranteed to be in
320 -- the range mIN_CHARLIKE..mAX_CHARLIKE
322 | CIntLike CAddrMode -- The address of a static int-like closure for the
323 -- specified small integer. It is guaranteed to be in
324 -- the range mIN_INTLIKE..mAX_INTLIKE
328 | CJoinPoint -- This is used as the amode of a let-no-escape-bound
330 VirtualSpOffset -- Sp value after any volatile free vars
331 -- of the rhs have been saved on stack.
332 -- Just before the code for the thing is jumped to,
333 -- Sp will be set to this value,
334 -- and then any stack-passed args pushed,
335 -- then the code for this thing will be entered
337 !PrimRep -- the kind of the result
338 CExprMacro -- the macro to generate a value
339 [CAddrMode] -- and its arguments
342 Various C macros for values which are dependent on the back-end layout.
348 | ARG_TAG -- stack argument tagging
349 | GET_TAG -- get current constructor tag
355 Convenience functions:
358 mkIntCLit :: Int -> CAddrMode
359 mkIntCLit i = CLit (mkMachInt (toInteger i))
361 mkCString :: FAST_STRING -> CAddrMode
362 mkCString s = CLit (MachStr s)
364 mkCCostCentre :: CostCentre -> CAddrMode
365 mkCCostCentre cc = CLbl (mkCC_Label cc) DataPtrRep
367 mkCCostCentreStack :: CostCentreStack -> CAddrMode
368 mkCCostCentreStack ccs = CLbl (mkCCS_Label ccs) DataPtrRep
371 %************************************************************************
373 \subsection[RegRelative]{@RegRelatives@: ???}
375 %************************************************************************
380 | SpRel FastInt -- }- offsets in StgWords
381 | NodeRel FastInt -- }
382 | CIndex CAddrMode CAddrMode PrimRep -- pointer arithmetic :-)
383 -- CIndex a b k === (k*)a[b]
386 = DirectReturn -- Jump directly, if possible
387 | StaticVectoredReturn Int -- Fixed tag, starting at zero
388 | DynamicVectoredReturn CAddrMode -- Dynamic tag given by amode, starting at zero
390 hpRel :: VirtualHeapOffset -- virtual offset of Hp
391 -> VirtualHeapOffset -- virtual offset of The Thing
392 -> RegRelative -- integer offset
393 hpRel hp off = HpRel (iUnbox (hp - off))
395 spRel :: VirtualSpOffset -- virtual offset of Sp
396 -> VirtualSpOffset -- virtual offset of The Thing
397 -> RegRelative -- integer offset
398 spRel sp off = SpRel (iUnbox (spRelToInt sp off))
400 nodeRel :: VirtualHeapOffset
402 nodeRel off = NodeRel (iUnbox off)
406 %************************************************************************
408 \subsection[Liveness]{Liveness Masks}
410 %************************************************************************
412 We represent liveness bitmaps as a BitSet (whose internal
413 representation really is a bitmap). These are pinned onto case return
414 vectors to indicate the state of the stack for the garbage collector.
416 In the compiled program, liveness bitmaps that fit inside a single
417 word (StgWord) are stored as a single word, while larger bitmaps are
418 stored as a pointer to an array of words. When we compile via C
419 (especially when we bootstrap via HC files), we generate identical C
420 code regardless of whether words are 32- or 64-bit on the target
421 machine, by postponing the decision of how to store each liveness
422 bitmap to C compilation time (or rather, C preprocessing time).
425 type LivenessMask = [BitSet]
427 data Liveness = Liveness CLabel LivenessMask
430 %************************************************************************
432 \subsection[HeapOffset]{@Heap Offsets@}
434 %************************************************************************
436 This used to be a grotesquely complicated datatype in an attempt to
437 hide the details of header sizes from the compiler itself. Now these
438 constants are imported from the RTS, and we deal in real Ints.
441 type HeapOffset = Int -- ToDo: remove
443 type VirtualHeapOffset = HeapOffset
444 type VirtualSpOffset = Int
446 type HpRelOffset = HeapOffset
447 type SpRelOffset = Int
450 %************************************************************************
452 \subsection[MagicId]{@MagicIds@: registers and such}
454 %************************************************************************
458 = BaseReg -- mentioned only in nativeGen
460 -- Argument and return registers
461 | VanillaReg -- pointers, unboxed ints and chars
463 FastInt -- its number (1 .. mAX_Vanilla_REG)
465 | FloatReg -- single-precision floating-point registers
466 FastInt -- its number (1 .. mAX_Float_REG)
468 | DoubleReg -- double-precision floating-point registers
469 FastInt -- its number (1 .. mAX_Double_REG)
472 | Sp -- Stack ptr; points to last occupied stack location.
473 | Su -- Stack update frame pointer
474 | SpLim -- Stack limit
475 | Hp -- Heap ptr; points to last occupied heap location.
476 | HpLim -- Heap limit register
477 | CurCostCentre -- current cost centre register.
478 | VoidReg -- see "VoidPrim" type; just a placeholder;
479 -- no actual register
480 | LongReg -- long int registers (64-bit, really)
481 PrimRep -- Int64Rep or Word64Rep
482 FastInt -- its number (1 .. mAX_Long_REG)
484 | CurrentTSO -- pointer to current thread's TSO
485 | CurrentNursery -- pointer to allocation area
488 node = VanillaReg PtrRep (_ILIT 1) -- A convenient alias for Node
489 tagreg = VanillaReg WordRep (_ILIT 2) -- A convenient alias for TagReg
494 We need magical @Eq@ because @VanillaReg@s come in multiple flavors.
497 instance Eq MagicId where
498 reg1 == reg2 = tag reg1 ==# tag reg2
500 tag BaseReg = (_ILIT(0) :: FastInt)
506 tag CurCostCentre = _ILIT(6)
507 tag VoidReg = _ILIT(7)
509 tag (VanillaReg _ i) = _ILIT(8) +# i
511 tag (FloatReg i) = _ILIT(8) +# maxv +# i
512 tag (DoubleReg i) = _ILIT(8) +# maxv +# maxf +# i
513 tag (LongReg _ i) = _ILIT(8) +# maxv +# maxf +# maxd +# i
515 maxv = iUnbox mAX_Vanilla_REG
516 maxf = iUnbox mAX_Float_REG
517 maxd = iUnbox mAX_Double_REG
520 Returns True for any register that {\em potentially} dies across
521 C calls (or anything near equivalent). We just say @True@ and
522 let the (machine-specific) registering macros sort things out...
525 isVolatileReg :: MagicId -> Bool
526 isVolatileReg any = True