StgCmmUtils.hs 22.6 KB
Newer Older
1
2
{-# LANGUAGE CPP #-}

3
4
5
6
7
8
9
10
11
-----------------------------------------------------------------------------
--
-- Code generator utilities; mostly monadic
--
-- (c) The University of Glasgow 2004-2006
--
-----------------------------------------------------------------------------

module StgCmmUtils (
12
13
        cgLit, mkSimpleLit,
        emitDataLits, mkDataLits,
14
        emitRODataLits, mkRODataLits,
Simon Marlow's avatar
Simon Marlow committed
15
        emitRtsCall, emitRtsCallWithResult, emitRtsCallGen,
16
        assignTemp, newTemp,
17

18
        newUnboxedTupleRegs,
19

20
        emitMultiAssign, emitCmmLitSwitch, emitSwitch,
21

22
        tagToClosure, mkTaggedObjectLoad,
23

24
        callerSaves, callerSaveVolatileRegs, get_GlobalReg_addr,
25

26
        cmmAndWord, cmmOrWord, cmmNegate, cmmEqWord, cmmNeWord,
27
        cmmUGtWord, cmmSubWord, cmmMulWord, cmmAddWord, cmmUShrWord,
28
29
30
31
32
33
        cmmOffsetExprW, cmmOffsetExprB,
        cmmRegOffW, cmmRegOffB,
        cmmLabelOffW, cmmLabelOffB,
        cmmOffsetW, cmmOffsetB,
        cmmOffsetLitW, cmmOffsetLitB,
        cmmLoadIndexW,
34
        cmmConstrTag1,
35

36
        cmmUntag, cmmIsTagged,
37

nfrisby's avatar
nfrisby committed
38
        addToMem, addToMemE, addToMemLblE, addToMemLbl,
39
40
        mkWordCLit,
        newStringCLit, newByteStringCLit,
41
        blankWord,
42
43
44
45
  ) where

#include "HsVersions.h"

46
47
import GhcPrelude

48
49
import StgCmmMonad
import StgCmmClosure
50
import Cmm
51
import BlockId
52
import MkGraph
53
import CodeGen.Platform
54
55
import CLabel
import CmmUtils
56
import CmmSwitch
57
58
59
60
61
62

import ForeignCall
import IdInfo
import Type
import TyCon
import SMRep
63
import Module
64
65
66
67
import Literal
import Digraph
import Util
import Unique
68
import UniqSupply (MonadUnique(..))
69
70
71
import DynFlags
import FastString
import Outputable
72
import RepType
73

74
import qualified Data.ByteString as BS
75
import qualified Data.Map as M
76
import Data.Char
77
78
import Data.List
import Data.Ord
79
80
81
82
83
import Data.Word


-------------------------------------------------------------------------
--
84
--      Literals
85
86
87
88
--
-------------------------------------------------------------------------

cgLit :: Literal -> FCode CmmLit
Sylvain Henry's avatar
Sylvain Henry committed
89
cgLit (LitString s) = newByteStringCLit (BS.unpack s)
90
 -- not unpackFS; we want the UTF-8 byte stream.
Sylvain Henry's avatar
Sylvain Henry committed
91
92
cgLit other_lit     = do dflags <- getDynFlags
                         return (mkSimpleLit dflags other_lit)
93

94
mkSimpleLit :: DynFlags -> Literal -> CmmLit
Sylvain Henry's avatar
Sylvain Henry committed
95
96
97
mkSimpleLit dflags (LitChar   c)                = CmmInt (fromIntegral (ord c))
                                                         (wordWidth dflags)
mkSimpleLit dflags LitNullAddr                  = zeroCLit dflags
98
99
100
101
mkSimpleLit dflags (LitNumber LitNumInt i _)    = CmmInt i (wordWidth dflags)
mkSimpleLit _      (LitNumber LitNumInt64 i _)  = CmmInt i W64
mkSimpleLit dflags (LitNumber LitNumWord i _)   = CmmInt i (wordWidth dflags)
mkSimpleLit _      (LitNumber LitNumWord64 i _) = CmmInt i W64
Sylvain Henry's avatar
Sylvain Henry committed
102
103
104
105
106
107
108
109
mkSimpleLit _      (LitFloat r)                 = CmmFloat r W32
mkSimpleLit _      (LitDouble r)                = CmmFloat r W64
mkSimpleLit _      (LitLabel fs ms fod)
  = let -- TODO: Literal labels might not actually be in the current package...
        labelSrc = ForeignLabelInThisPackage
    in CmmLabel (mkForeignLabel fs ms labelSrc fod)
-- NB: LitRubbish should have been lowered in "CoreToStg"
mkSimpleLit _      other = pprPanic "mkSimpleLit" (ppr other)
110
111
112
113
114
115
116
117
118
119

--------------------------------------------------------------------------
--
-- Incrementing a memory location
--
--------------------------------------------------------------------------

addToMemLbl :: CmmType -> CLabel -> Int -> CmmAGraph
addToMemLbl rep lbl n = addToMem rep (CmmLit (CmmLabel lbl)) n

nfrisby's avatar
nfrisby committed
120
121
122
addToMemLblE :: CmmType -> CLabel -> CmmExpr -> CmmAGraph
addToMemLblE rep lbl = addToMemE rep (CmmLit (CmmLabel lbl))

123
124
125
126
addToMem :: CmmType     -- rep of the counter
         -> CmmExpr     -- Address
         -> Int         -- What to add (a word)
         -> CmmAGraph
127
128
addToMem rep ptr n = addToMemE rep ptr (CmmLit (CmmInt (toInteger n) (typeWidth rep)))

129
130
131
132
addToMemE :: CmmType    -- rep of the counter
          -> CmmExpr    -- Address
          -> CmmExpr    -- What to add (a word-typed expression)
          -> CmmAGraph
133
134
135
136
137
138
addToMemE rep ptr n
  = mkStore ptr (CmmMachOp (MO_Add (typeWidth rep)) [CmmLoad ptr rep, n])


-------------------------------------------------------------------------
--
139
140
--      Loading a field from an object,
--      where the object pointer is itself tagged
141
142
143
--
-------------------------------------------------------------------------

144
145
mkTaggedObjectLoad
  :: DynFlags -> LocalReg -> LocalReg -> ByteOff -> DynTag -> CmmAGraph
146
-- (loadTaggedObjectField reg base off tag) generates assignment
147
--      reg = bitsK[ base + off - tag ]
148
-- where K is fixed by 'reg'
149
mkTaggedObjectLoad dflags reg base offset tag
150
  = mkAssign (CmmLocal reg)
151
152
             (CmmLoad (cmmOffsetB dflags
                                  (CmmReg (CmmLocal base))
153
                                  (offset - tag))
154
155
156
157
                      (localRegType reg))

-------------------------------------------------------------------------
--
158
--      Converting a closure tag to a closure for enumeration types
159
160
161
162
--      (this is the implementation of tagToEnum#).
--
-------------------------------------------------------------------------

163
164
165
tagToClosure :: DynFlags -> TyCon -> CmmExpr -> CmmExpr
tagToClosure dflags tycon tag
  = CmmLoad (cmmOffsetExprW dflags closure_tbl tag) (bWord dflags)
166
  where closure_tbl = CmmLit (CmmLabel lbl)
167
        lbl = mkClosureTableLabel (tyConName tycon) NoCafRefs
168
169
170

-------------------------------------------------------------------------
--
171
--      Conditionals and rts calls
172
173
174
--
-------------------------------------------------------------------------

175
emitRtsCall :: UnitId -> FastString -> [(CmmExpr,ForeignHint)] -> Bool -> FCode ()
176
emitRtsCall pkg fun args safe = emitRtsCallGen [] (mkCmmCodeLabel pkg fun) args safe
177

178
emitRtsCallWithResult :: LocalReg -> ForeignHint -> UnitId -> FastString
179
        -> [(CmmExpr,ForeignHint)] -> Bool -> FCode ()
180
emitRtsCallWithResult res hint pkg fun args safe
181
   = emitRtsCallGen [(res,hint)] (mkCmmCodeLabel pkg fun) args safe
182
183

-- Make a call to an RTS C procedure
Simon Marlow's avatar
Simon Marlow committed
184
emitRtsCallGen
185
   :: [(LocalReg,ForeignHint)]
186
   -> CLabel
187
188
189
   -> [(CmmExpr,ForeignHint)]
   -> Bool -- True <=> CmmSafe call
   -> FCode ()
190
emitRtsCallGen res lbl args safe
191
192
193
  = do { dflags <- getDynFlags
       ; updfr_off <- getUpdFrameOff
       ; let (caller_save, caller_load) = callerSaveVolatileRegs dflags
194
       ; emit caller_save
195
       ; call updfr_off
196
197
       ; emit caller_load }
  where
198
199
    call updfr_off =
      if safe then
200
        emit =<< mkCmmCall fun_expr res' args' updfr_off
201
202
203
      else do
        let conv = ForeignConvention CCallConv arg_hints res_hints CmmMayReturn
        emit $ mkUnsafeCall (ForeignTarget fun_expr conv) res' args'
204
205
    (args', arg_hints) = unzip args
    (res',  res_hints) = unzip res
206
    fun_expr = mkLblExpr lbl
207
208
209
210


-----------------------------------------------------------------------------
--
211
--      Caller-Save Registers
212
213
214
215
216
217
218
219
220
221
--
-----------------------------------------------------------------------------

-- Here we generate the sequence of saves/restores required around a
-- foreign call instruction.

-- TODO: reconcile with includes/Regs.h
--  * Regs.h claims that BaseReg should be saved last and loaded first
--    * This might not have been tickled before since BaseReg is callee save
--  * Regs.h saves SparkHd, ParkT1, SparkBase and SparkLim
222
223
224
--
-- This code isn't actually used right now, because callerSaves
-- only ever returns true in the current universe for registers NOT in
225
-- system_regs (just do a grep for CALLER_SAVES in
226
227
228
229
230
231
232
233
234
235
236
237
238
-- includes/stg/MachRegs.h).  It's all one giant no-op, and for
-- good reason: having to save system registers on every foreign call
-- would be very expensive, so we avoid assigning them to those
-- registers when we add support for an architecture.
--
-- Note that the old code generator actually does more work here: it
-- also saves other global registers.  We can't (nor want) to do that
-- here, as we don't have liveness information.  And really, we
-- shouldn't be doing the workaround at this point in the pipeline, see
-- Note [Register parameter passing] and the ToDo on CmmCall in
-- cmm/CmmNode.hs.  Right now the workaround is to avoid inlining across
-- unsafe foreign calls in rewriteAssignments, but this is strictly
-- temporary.
239
240
callerSaveVolatileRegs :: DynFlags -> (CmmAGraph, CmmAGraph)
callerSaveVolatileRegs dflags = (caller_save, caller_load)
241
  where
242
243
    platform = targetPlatform dflags

244
245
246
    caller_save = catAGraphs (map callerSaveGlobalReg    regs_to_save)
    caller_load = catAGraphs (map callerRestoreGlobalReg regs_to_save)

247
    system_regs = [ Sp,SpLim,Hp,HpLim,CCCS,CurrentTSO,CurrentNursery
248
249
                    {- ,SparkHd,SparkTl,SparkBase,SparkLim -}
                  , BaseReg ]
250

251
    regs_to_save = filter (callerSaves platform) system_regs
252
253

    callerSaveGlobalReg reg
254
        = mkStore (get_GlobalReg_addr dflags reg) (CmmReg (CmmGlobal reg))
255
256

    callerRestoreGlobalReg reg
257
        = mkAssign (CmmGlobal reg)
258
                   (CmmLoad (get_GlobalReg_addr dflags reg) (globalRegType dflags reg))
259
260
261
262
263
264

-- -----------------------------------------------------------------------------
-- Global registers

-- We map STG registers onto appropriate CmmExprs.  Either they map
-- to real machine registers or stored as offsets from BaseReg.  Given
265
-- a GlobalReg, get_GlobalReg_addr always produces the
266
267
268
-- register table address for it.
-- (See also get_GlobalReg_reg_or_addr in MachRegs)

269
get_GlobalReg_addr :: DynFlags -> GlobalReg -> CmmExpr
270
get_GlobalReg_addr dflags BaseReg = regTableOffset dflags 0
271
get_GlobalReg_addr dflags mid
272
273
    = get_Regtable_addr_from_offset dflags
                                    (globalRegType dflags mid) (baseRegOffset dflags mid)
274
275
276

-- Calculate a literal representing an offset into the register table.
-- Used when we don't have an actual BaseReg to offset from.
277
278
279
regTableOffset :: DynFlags -> Int -> CmmExpr
regTableOffset dflags n =
  CmmLit (CmmLabelOff mkMainCapabilityLabel (oFFSET_Capability_r dflags + n))
280

281
282
283
get_Regtable_addr_from_offset :: DynFlags -> CmmType -> Int -> CmmExpr
get_Regtable_addr_from_offset dflags _rep offset =
    if haveRegBase (targetPlatform dflags)
284
    then CmmRegOff baseReg offset
285
    else regTableOffset dflags offset
286
287
288
289
290


-- -----------------------------------------------------------------------------
-- Information about global registers

291
292
293
294
295
296
297
298
299
300
301
302
303
baseRegOffset :: DynFlags -> GlobalReg -> Int

baseRegOffset dflags Sp             = oFFSET_StgRegTable_rSp dflags
baseRegOffset dflags SpLim          = oFFSET_StgRegTable_rSpLim dflags
baseRegOffset dflags (LongReg 1)    = oFFSET_StgRegTable_rL1 dflags
baseRegOffset dflags Hp             = oFFSET_StgRegTable_rHp dflags
baseRegOffset dflags HpLim          = oFFSET_StgRegTable_rHpLim dflags
baseRegOffset dflags CCCS           = oFFSET_StgRegTable_rCCCS dflags
baseRegOffset dflags CurrentTSO     = oFFSET_StgRegTable_rCurrentTSO dflags
baseRegOffset dflags CurrentNursery = oFFSET_StgRegTable_rCurrentNursery dflags
baseRegOffset dflags HpAlloc        = oFFSET_StgRegTable_rHpAlloc dflags
baseRegOffset dflags GCEnter1       = oFFSET_stgGCEnter1 dflags
baseRegOffset dflags GCFun          = oFFSET_stgGCFun dflags
304
baseRegOffset _      reg            = pprPanic "StgCmmUtils.baseRegOffset:" (ppr reg)
305
306
307

-------------------------------------------------------------------------
--
308
--      Strings generate a top-level data block
309
310
311
312
313
--
-------------------------------------------------------------------------

emitDataLits :: CLabel -> [CmmLit] -> FCode ()
-- Emit a data-segment data block
314
emitDataLits lbl lits = emitDecl (mkDataLits (Section Data lbl) lbl lits)
315
316
317

emitRODataLits :: CLabel -> [CmmLit] -> FCode ()
-- Emit a read-only data block
318
319
320
emitRODataLits lbl lits = emitDecl (mkRODataLits lbl lits)

newStringCLit :: String -> FCode CmmLit
321
322
-- Make a global definition for the string,
-- and return its label
323
newStringCLit str = newByteStringCLit (map (fromIntegral . ord) str)
324

325
326
newByteStringCLit :: [Word8] -> FCode CmmLit
newByteStringCLit bytes
327
  = do  { uniq <- newUnique
328
        ; let (lit, decl) = mkByteStringCLit (mkStringLitLabel uniq) bytes
329
330
        ; emitDecl decl
        ; return lit }
331
332
333

-------------------------------------------------------------------------
--
334
--      Assigning expressions to temporaries
335
336
337
338
--
-------------------------------------------------------------------------

assignTemp :: CmmExpr -> FCode LocalReg
339
340
341
342
343
344
345
-- Make sure the argument is in a local register.
-- We don't bother being particularly aggressive with avoiding
-- unnecessary local registers, since we can rely on a later
-- optimization pass to inline as necessary (and skipping out
-- on things like global registers can be a little dangerous
-- due to them being trashed on foreign calls--though it means
-- the optimization pass doesn't have to do as much work)
346
assignTemp (CmmReg (CmmLocal reg)) = return reg
347
348
349
assignTemp e = do { dflags <- getDynFlags
                  ; uniq <- newUnique
                  ; let reg = LocalReg uniq (cmmExprType dflags e)
350
                  ; emitAssign (CmmLocal reg) e
351
                  ; return reg }
352

353
354
newTemp :: MonadUnique m => CmmType -> m LocalReg
newTemp rep = do { uniq <- getUniqueM
355
                 ; return (LocalReg uniq rep) }
356
357
358

newUnboxedTupleRegs :: Type -> FCode ([LocalReg], [ForeignHint])
-- Choose suitable local regs to use for the components
359
-- of an unboxed tuple that we are about to return to
360
-- the Sequel.  If the Sequel is a join point, using the
361
-- regs it wants will save later assignments.
362
newUnboxedTupleRegs res_ty
363
  = ASSERT( isUnboxedTupleType res_ty )
364
365
366
    do  { dflags <- getDynFlags
        ; sequel <- getSequel
        ; regs <- choose_regs dflags sequel
367
        ; ASSERT( regs `equalLength` reps )
Richard Eisenberg's avatar
Richard Eisenberg committed
368
          return (regs, map primRepForeignHint reps) }
369
  where
Richard Eisenberg's avatar
Richard Eisenberg committed
370
    reps = typePrimRep res_ty
371
    choose_regs _ (AssignTo regs _) = return regs
Richard Eisenberg's avatar
Richard Eisenberg committed
372
    choose_regs dflags _            = mapM (newTemp . primRepCmmType dflags) reps
373
374
375
376



-------------------------------------------------------------------------
377
--      emitMultiAssign
378
379
-------------------------------------------------------------------------

380
emitMultiAssign :: [LocalReg] -> [CmmExpr] -> FCode ()
381
382
383
384
-- Emit code to perform the assignments in the
-- input simultaneously, using temporary variables when necessary.

type Key  = Int
385
386
type Vrtx = (Key, Stmt) -- Give each vertex a unique number,
                        -- for fast comparison
387
type Stmt = (LocalReg, CmmExpr) -- r := e
388
389

-- We use the strongly-connected component algorithm, in which
390
391
392
393
--      * the vertices are the statements
--      * an edge goes from s1 to s2 iff
--              s1 assigns to something s2 uses
--        that is, if s1 should *follow* s2 in the final order
394

395
emitMultiAssign []    []    = return ()
396
emitMultiAssign [reg] [rhs] = emitAssign (CmmLocal reg) rhs
397
398
emitMultiAssign regs rhss   = do
  dflags <- getDynFlags
399
  ASSERT2( equalLength regs rhss, ppr regs $$ ppr rhss )
400
    unscramble dflags ([1..] `zip` (regs `zip` rhss))
401

402
403
unscramble :: DynFlags -> [Vrtx] -> FCode ()
unscramble dflags vertices = mapM_ do_component components
404
  where
405
406
        edges :: [ Node Key Vrtx ]
        edges = [ DigraphNode vertex key1 (edges_from stmt1)
407
                | vertex@(key1, stmt1) <- vertices ]
408

409
410
411
        edges_from :: Stmt -> [Key]
        edges_from stmt1 = [ key2 | (key2, stmt2) <- vertices,
                                    stmt1 `mustFollow` stmt2 ]
412

413
        components :: [SCC Vrtx]
niteria's avatar
niteria committed
414
        components = stronglyConnCompFromEdgedVerticesUniq edges
415

416
417
        -- do_components deal with one strongly-connected component
        -- Not cyclic, or singleton?  Just do it
418
419
        do_component :: SCC Vrtx -> FCode ()
        do_component (AcyclicSCC (_,stmt))  = mk_graph stmt
420
421
        do_component (CyclicSCC [])         = panic "do_component"
        do_component (CyclicSCC [(_,stmt)]) = mk_graph stmt
422

423
424
                -- Cyclic?  Then go via temporaries.  Pick one to
                -- break the loop and try again with the rest.
425
        do_component (CyclicSCC ((_,first_stmt) : rest)) = do
426
            dflags <- getDynFlags
427
            u <- newUnique
428
            let (to_tmp, from_tmp) = split dflags u first_stmt
429
            mk_graph to_tmp
430
            unscramble dflags rest
431
            mk_graph from_tmp
432

433
434
        split :: DynFlags -> Unique -> Stmt -> (Stmt, Stmt)
        split dflags uniq (reg, rhs)
435
          = ((tmp, rhs), (reg, CmmReg (CmmLocal tmp)))
436
          where
437
            rep = cmmExprType dflags rhs
438
            tmp = LocalReg uniq rep
439

440
        mk_graph :: Stmt -> FCode ()
441
        mk_graph (reg, rhs) = emitAssign (CmmLocal reg) rhs
442

443
        mustFollow :: Stmt -> Stmt -> Bool
444
        (reg, _) `mustFollow` (_, rhs) = regUsedIn dflags (CmmLocal reg) rhs
445
446

-------------------------------------------------------------------------
447
--      mkSwitch
448
449
450
-------------------------------------------------------------------------


Peter Wortmann's avatar
Peter Wortmann committed
451
452
453
454
455
456
emitSwitch :: CmmExpr                      -- Tag to switch on
           -> [(ConTagZ, CmmAGraphScoped)] -- Tagged branches
           -> Maybe CmmAGraphScoped        -- Default branch (if any)
           -> ConTagZ -> ConTagZ           -- Min and Max possible values;
                                           -- behaviour outside this range is
                                           -- undefined
457
           -> FCode ()
458
459

-- First, two rather common cases in which there is no work to do
460
461
emitSwitch _ []         (Just code) _ _ = emit (fst code)
emitSwitch _ [(_,code)] Nothing     _ _ = emit (fst code)
462
463

-- Right, off we go
464
emitSwitch tag_expr branches mb_deflt lo_tag hi_tag = do
465
    join_lbl      <- newBlockId
466
467
468
    mb_deflt_lbl  <- label_default join_lbl mb_deflt
    branches_lbls <- label_branches join_lbl branches
    tag_expr'     <- assignTemp' tag_expr
469

470
471
472
    -- Sort the branches before calling mk_discrete_switch
    let branches_lbls' = [ (fromIntegral i, l) | (i,l) <- sortBy (comparing fst) branches_lbls ]
    let range = (fromIntegral lo_tag, fromIntegral hi_tag)
473

474
    emit $ mk_discrete_switch False tag_expr' branches_lbls' mb_deflt_lbl range
475
476

    emitLabel join_lbl
477

478
479
480
mk_discrete_switch :: Bool -- ^ Use signed comparisons
          -> CmmExpr
          -> [(Integer, BlockId)]
481
          -> Maybe BlockId
482
483
          -> (Integer, Integer)
          -> CmmAGraph
484
485

-- SINGLETON TAG RANGE: no case analysis to do
486
mk_discrete_switch _ _tag_expr [(tag, lbl)] _ (lo_tag, hi_tag)
487
488
  | lo_tag == hi_tag
  = ASSERT( tag == lo_tag )
489
    mkBranch lbl
490
491

-- SINGLETON BRANCH, NO DEFAULT: no case analysis to do
492
493
mk_discrete_switch _ _tag_expr [(_tag,lbl)] Nothing _
  = mkBranch lbl
494
495
496
497
498
        -- The simplifier might have eliminated a case
        --       so we may have e.g. case xs of
        --                               [] -> e
        -- In that situation we can be sure the (:) case
        -- can't happen, so no need to test
499

500
501
502
503
-- SOMETHING MORE COMPLICATED: defer to CmmImplementSwitchPlans
-- See Note [Cmm Switches, the general plan] in CmmSwitch
mk_discrete_switch signed tag_expr branches mb_deflt range
  = mkSwitch tag_expr $ mkSwitchTargets signed range mb_deflt (M.fromList branches)
504

505
506
507
508
509
510
511
divideBranches :: Ord a => [(a,b)] -> ([(a,b)], a, [(a,b)])
divideBranches branches = (lo_branches, mid, hi_branches)
  where
    -- 2 branches => n_branches `div` 2 = 1
    --            => branches !! 1 give the *second* tag
    -- There are always at least 2 branches here
    (mid,_) = branches !! (length branches `div` 2)
512
    (lo_branches, hi_branches) = span is_lo branches
513
    is_lo (t,_) = t < mid
514
515

--------------
Peter Wortmann's avatar
Peter Wortmann committed
516
517
518
519
520
emitCmmLitSwitch :: CmmExpr                    -- Tag to switch on
               -> [(Literal, CmmAGraphScoped)] -- Tagged branches
               -> CmmAGraphScoped              -- Default branch (always)
               -> FCode ()                     -- Emit the code
emitCmmLitSwitch _scrut []       deflt = emit $ fst deflt
521
522
emitCmmLitSwitch scrut  branches deflt = do
    scrut' <- assignTemp' scrut
523
    join_lbl <- newBlockId
524
525
    deflt_lbl <- label_code join_lbl deflt
    branches_lbls <- label_branches join_lbl branches
526
527
528
529
530
531
532

    dflags <- getDynFlags
    let cmm_ty = cmmExprType dflags scrut
        rep = typeWidth cmm_ty

    -- We find the necessary type information in the literals in the branches
    let signed = case head branches of
533
                    (LitNumber nt _ _, _) -> litNumIsSigned nt
534
535
536
537
538
539
540
541
542
543
544
545
546
                    _ -> False

    let range | signed    = (tARGET_MIN_INT dflags, tARGET_MAX_INT dflags)
              | otherwise = (0, tARGET_MAX_WORD dflags)

    if isFloatType cmm_ty
    then emit =<< mk_float_switch rep scrut' deflt_lbl noBound branches_lbls
    else emit $ mk_discrete_switch
        signed
        scrut'
        [(litValue lit,l) | (lit,l) <- branches_lbls]
        (Just deflt_lbl)
        range
547
    emitLabel join_lbl
548

549
550
551
552
553
554
-- | lower bound (inclusive), upper bound (exclusive)
type LitBound = (Maybe Literal, Maybe Literal)

noBound :: LitBound
noBound = (Nothing, Nothing)

555
mk_float_switch :: Width -> CmmExpr -> BlockId
556
              -> LitBound
557
              -> [(Literal,BlockId)]
558
              -> FCode CmmAGraph
559
560
mk_float_switch rep scrut deflt _bounds [(lit,blk)]
  = do dflags <- getDynFlags
561
       return $ mkCbranch (cond dflags) deflt blk Nothing
562
  where
563
564
565
566
    cond dflags = CmmMachOp ne [scrut, CmmLit cmm_lit]
      where
        cmm_lit = mkSimpleLit dflags lit
        ne      = MO_F_Ne rep
567

568
mk_float_switch rep scrut deflt_blk_id (lo_bound, hi_bound) branches
569
  = do dflags <- getDynFlags
570
571
       lo_blk <- mk_float_switch rep scrut deflt_blk_id bounds_lo lo_branches
       hi_blk <- mk_float_switch rep scrut deflt_blk_id bounds_hi hi_branches
572
       mkCmmIfThenElse (cond dflags) lo_blk hi_blk
573
  where
574
    (lo_branches, mid_lit, hi_branches) = divideBranches branches
575

576
577
578
    bounds_lo = (lo_bound, Just mid_lit)
    bounds_hi = (Just mid_lit, hi_bound)

579
580
581
582
    cond dflags = CmmMachOp lt [scrut, CmmLit cmm_lit]
      where
        cmm_lit = mkSimpleLit dflags mid_lit
        lt      = MO_F_Lt rep
583
584
585


--------------
Peter Wortmann's avatar
Peter Wortmann committed
586
label_default :: BlockId -> Maybe CmmAGraphScoped -> FCode (Maybe BlockId)
587
label_default _ Nothing
Gabor Greif's avatar
Gabor Greif committed
588
  = return Nothing
589
590
591
label_default join_lbl (Just code)
  = do lbl <- label_code join_lbl code
       return (Just lbl)
592
593

--------------
Peter Wortmann's avatar
Peter Wortmann committed
594
label_branches :: BlockId -> [(a,CmmAGraphScoped)] -> FCode [(a,BlockId)]
595
596
597
598
599
600
label_branches _join_lbl []
  = return []
label_branches join_lbl ((tag,code):branches)
  = do lbl <- label_code join_lbl code
       branches' <- label_branches join_lbl branches
       return ((tag,lbl):branches')
601
602

--------------
Peter Wortmann's avatar
Peter Wortmann committed
603
label_code :: BlockId -> CmmAGraphScoped -> FCode BlockId
604
--  label_code J code
605
--      generates
606
607
--  [L: code; goto J]
-- and returns L
Peter Wortmann's avatar
Peter Wortmann committed
608
label_code join_lbl (code,tsc) = do
609
    lbl <- newBlockId
Peter Wortmann's avatar
Peter Wortmann committed
610
    emitOutOfLine lbl (code MkGraph.<*> mkBranch join_lbl, tsc)
611
    return lbl
612
613

--------------
614
615
616
617
assignTemp' :: CmmExpr -> FCode CmmExpr
assignTemp' e
  | isTrivialCmmExpr e = return e
  | otherwise = do
618
619
       dflags <- getDynFlags
       lreg <- newTemp (cmmExprType dflags e)
620
621
622
       let reg = CmmLocal lreg
       emitAssign reg e
       return (CmmReg reg)