CmmParse.y 49.5 KB
Newer Older
1
2
-----------------------------------------------------------------------------
--
3
-- (c) The University of Glasgow, 2004-2012
4
5
6
7
8
--
-- Parser for concrete Cmm.
--
-----------------------------------------------------------------------------

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
{- -----------------------------------------------------------------------------
Note [Syntax of .cmm files]

NOTE: You are very much on your own in .cmm.  There is very little
error checking at all:

  * Type errors are detected by the (optional) -dcmm-lint pass, if you
    don't turn this on then a type error will likely result in a panic
    from the native code generator.

  * Passing the wrong number of arguments or arguments of the wrong
    type is not detected.

There are two ways to write .cmm code:

 (1) High-level Cmm code delegates the stack handling to GHC, and
     never explicitly mentions Sp or registers.

 (2) Low-level Cmm manages the stack itself, and must know about
     calling conventions.

Whether you want high-level or low-level Cmm is indicated by the
presence of an argument list on a procedure.  For example:

foo ( gcptr a, bits32 b )
{
  // this is high-level cmm code

  if (b > 0) {
     // we can make tail calls passing arguments:
     jump stg_ap_0_fast(a);
  }

  push (stg_upd_frame_info, a) {
    // stack frames can be explicitly pushed

    (x,y) = call wibble(a,b,3,4);
      // calls pass arguments and return results using the native
      // Haskell calling convention.  The code generator will automatically
      // construct a stack frame and an info table for the continuation.

    return (x,y);
      // we can return multiple values from the current proc
  }
}

bar
{
  // this is low-level cmm code, indicated by the fact that we did not
  // put an argument list on bar.

  x = R1;  // the calling convention is explicit: better be careful
           // that this works on all platforms!

  jump %ENTRY_CODE(Sp(0))
}

Here is a list of rules for high-level and low-level code.  If you
break the rules, you get a panic (for using a high-level construct in
a low-level proc), or wrong code (when using low-level code in a
high-level proc).  This stuff isn't checked! (TODO!)

High-level only:

  - tail-calls with arguments, e.g.
    jump stg_fun (arg1, arg2);

  - function calls:
    (ret1,ret2) = call stg_fun (arg1, arg2);

    This makes a call with the NativeNodeCall convention, and the
    values are returned to the following code using the NativeReturn
    convention.

  - returning:
    return (ret1, ret2)

    These use the NativeReturn convention to return zero or more
    results to the caller.

  - pushing stack frames:
    push (info_ptr, field1, ..., fieldN) { ... statements ... }

Low-level only:

  - References to Sp, R1-R8, F1-F4 etc.

    NB. foreign calls may clobber the argument registers R1-R8, F1-F4
    etc., so ensure they are saved into variables around foreign
    calls.

  - SAVE_THREAD_STATE() and LOAD_THREAD_STATE(), which modify Sp
    directly.

Both high-level and low-level code can use a raw tail-call:

    jump stg_fun [R1,R2]

This always transfers control to a low-level Cmm function, but the
call can be made from high-level code.  Arguments must be passed
explicitly in R/F/D/L registers.

NB. you *must* specify the list of GlobalRegs that are passed via a
jump, otherwise the register allocator will assume that all the
GlobalRegs are dead at the jump.


A stack frame is written like this:

INFO_TABLE_RET ( label, FRAME_TYPE, info_ptr, field1, ..., fieldN )
               return ( arg1, ..., argM )
{
  ... code ...
}

where field1 ... fieldN are the fields of the stack frame (with types)
arg1...argN are the values returned to the stack frame (with types).
The return values are assumed to be passed according to the
NativeReturn convention.

On entry to the code, the stack frame looks like:

   |----------|
   | fieldN   |
   |   ...    |
   | field1   |
   |----------|
   | info_ptr |
   |----------|
   |  argN    |
   |   ...    | <- Sp

and some of the args may be in registers.

We prepend the code by a copyIn of the args, and assign all the stack
frame fields to their formals.  The initial "arg offset" for stack
layout purposes consists of the whole stack frame plus any args that
might be on the stack.

A tail-call may pass a stack frame to the callee using the following
syntax:

jump f (info_ptr, field1,..,fieldN) (arg1,..,argN)

where info_ptr and field1..fieldN describe the stack frame, and
arg1..argN are the arguments passed to f using the NativeNodeCall
convention.

----------------------------------------------------------------------------- -}
158

159
{
160
{-# LANGUAGE BangPatterns #-} -- required for versions of Happy before 1.18.6
161
{-# OPTIONS -Wwarn -w #-}
162
163
164
-- The above warning supression flag is a temporary kludge.
-- While working on this module you are encouraged to remove it and fix
-- any warnings in the module. See
Ian Lynagh's avatar
Ian Lynagh committed
165
--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
166
167
-- for details

168
169
module CmmParse ( parseCmmFile ) where

170
171
172
173
174
175
176
177
178
179
180
181
import StgCmmExtCode
import CmmCallConv
import StgCmmProf
import StgCmmHeap
import StgCmmMonad hiding ( getCode, getCodeR, emitLabel, emit, emitStore
                          , emitAssign, emitOutOfLine, withUpdFrameOff
                          , getUpdFrameOff )
import qualified StgCmmMonad as F
import StgCmmUtils
import StgCmmForeign
import StgCmmExpr
import StgCmmClosure
Simon Marlow's avatar
Simon Marlow committed
182
import StgCmmLayout     hiding (ArgRep(..))
183
184
185
186
187
import StgCmmTicky
import StgCmmBind       ( emitBlackHoleCode, emitUpdateFrame )

import MkGraph
import Cmm
Simon Marlow's avatar
Simon Marlow committed
188
import CmmUtils
189
import CmmInfo
190
import BlockId
191
192
import CmmLex
import CLabel
Simon Marlow's avatar
Simon Marlow committed
193
import SMRep
194
195
import Lexer

196
import CostCentre
Simon Marlow's avatar
Simon Marlow committed
197
import ForeignCall
198
import Module
199
import Platform
Simon Marlow's avatar
Simon Marlow committed
200
import Literal
201
202
203
import Unique
import UniqFM
import SrcLoc
Simon Marlow's avatar
Simon Marlow committed
204
205
206
207
import DynFlags
import StaticFlags
import ErrUtils
import StringBuffer
208
import FastString
Simon Marlow's avatar
Simon Marlow committed
209
210
import Panic
import Constants
211
import Outputable
212
import BasicTypes
213
import Bag              ( emptyBag, unitBag )
214
import Var
215

216
import Control.Monad
217
import Data.Array
218
import Data.Char        ( ord )
219
import System.Exit
220
import Data.Maybe
221
222

#include "HsVersions.h"
223
224
}

225
226
%expect 0

227
%token
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
        ':'     { L _ (CmmT_SpecChar ':') }
        ';'     { L _ (CmmT_SpecChar ';') }
        '{'     { L _ (CmmT_SpecChar '{') }
        '}'     { L _ (CmmT_SpecChar '}') }
        '['     { L _ (CmmT_SpecChar '[') }
        ']'     { L _ (CmmT_SpecChar ']') }
        '('     { L _ (CmmT_SpecChar '(') }
        ')'     { L _ (CmmT_SpecChar ')') }
        '='     { L _ (CmmT_SpecChar '=') }
        '`'     { L _ (CmmT_SpecChar '`') }
        '~'     { L _ (CmmT_SpecChar '~') }
        '/'     { L _ (CmmT_SpecChar '/') }
        '*'     { L _ (CmmT_SpecChar '*') }
        '%'     { L _ (CmmT_SpecChar '%') }
        '-'     { L _ (CmmT_SpecChar '-') }
        '+'     { L _ (CmmT_SpecChar '+') }
        '&'     { L _ (CmmT_SpecChar '&') }
        '^'     { L _ (CmmT_SpecChar '^') }
        '|'     { L _ (CmmT_SpecChar '|') }
        '>'     { L _ (CmmT_SpecChar '>') }
        '<'     { L _ (CmmT_SpecChar '<') }
        ','     { L _ (CmmT_SpecChar ',') }
        '!'     { L _ (CmmT_SpecChar '!') }

        '..'    { L _ (CmmT_DotDot) }
        '::'    { L _ (CmmT_DoubleColon) }
        '>>'    { L _ (CmmT_Shr) }
        '<<'    { L _ (CmmT_Shl) }
        '>='    { L _ (CmmT_Ge) }
        '<='    { L _ (CmmT_Le) }
        '=='    { L _ (CmmT_Eq) }
        '!='    { L _ (CmmT_Ne) }
260
261
262
        '&&'    { L _ (CmmT_BoolAnd) }
        '||'    { L _ (CmmT_BoolOr) }

263
        'CLOSURE'       { L _ (CmmT_CLOSURE) }
Simon Marlow's avatar
untab    
Simon Marlow committed
264
265
266
267
268
269
270
271
272
273
274
        'INFO_TABLE'    { L _ (CmmT_INFO_TABLE) }
        'INFO_TABLE_RET'{ L _ (CmmT_INFO_TABLE_RET) }
        'INFO_TABLE_FUN'{ L _ (CmmT_INFO_TABLE_FUN) }
        'INFO_TABLE_CONSTR'{ L _ (CmmT_INFO_TABLE_CONSTR) }
        'INFO_TABLE_SELECTOR'{ L _ (CmmT_INFO_TABLE_SELECTOR) }
        'else'          { L _ (CmmT_else) }
        'export'        { L _ (CmmT_export) }
        'section'       { L _ (CmmT_section) }
        'align'         { L _ (CmmT_align) }
        'goto'          { L _ (CmmT_goto) }
        'if'            { L _ (CmmT_if) }
275
276
277
        'call'          { L _ (CmmT_call) }
        'jump'          { L _ (CmmT_jump) }
        'foreign'       { L _ (CmmT_foreign) }
Simon Marlow's avatar
untab    
Simon Marlow committed
278
279
280
281
282
283
284
        'never'         { L _ (CmmT_never) }
        'prim'          { L _ (CmmT_prim) }
        'return'        { L _ (CmmT_return) }
        'returns'       { L _ (CmmT_returns) }
        'import'        { L _ (CmmT_import) }
        'switch'        { L _ (CmmT_switch) }
        'case'          { L _ (CmmT_case) }
285
286
287
        'default'       { L _ (CmmT_default) }
        'push'          { L _ (CmmT_push) }
        'bits8'         { L _ (CmmT_bits8) }
Simon Marlow's avatar
untab    
Simon Marlow committed
288
289
290
        'bits16'        { L _ (CmmT_bits16) }
        'bits32'        { L _ (CmmT_bits32) }
        'bits64'        { L _ (CmmT_bits64) }
291
        'bits128'       { L _ (CmmT_bits128) }
Simon Marlow's avatar
untab    
Simon Marlow committed
292
293
294
295
296
297
298
299
300
        'float32'       { L _ (CmmT_float32) }
        'float64'       { L _ (CmmT_float64) }
        'gcptr'         { L _ (CmmT_gcptr) }

        GLOBALREG       { L _ (CmmT_GlobalReg   $$) }
        NAME            { L _ (CmmT_Name        $$) }
        STRING          { L _ (CmmT_String      $$) }
        INT             { L _ (CmmT_Int         $$) }
        FLOAT           { L _ (CmmT_Float       $$) }
301
302
303
304
305
306
307

%monad { P } { >>= } { return }
%lexer { cmmlex } { L _ CmmT_EOF }
%name cmmParse cmm
%tokentype { Located CmmToken }

-- C-- operator precedences, taken from the C-- spec
308
309
%right '||'     -- non-std extension, called %disjoin in C--
%right '&&'     -- non-std extension, called %conjoin in C--
310
311
312
313
314
315
316
317
318
319
320
321
%right '!'
%nonassoc '>=' '>' '<=' '<' '!=' '=='
%left '|'
%left '^'
%left '&'
%left '>>' '<<'
%left '-' '+'
%left '/' '*' '%'
%right '~'

%%

322
cmm     :: { CmmParse () }
Simon Marlow's avatar
untab    
Simon Marlow committed
323
324
        : {- empty -}                   { return () }
        | cmmtop cmm                    { do $1; $2 }
325

326
cmmtop  :: { CmmParse () }
Simon Marlow's avatar
untab    
Simon Marlow committed
327
328
329
330
331
332
333
        : cmmproc                       { $1 }
        | cmmdata                       { $1 }
        | decl                          { $1 } 
        | 'CLOSURE' '(' NAME ',' NAME lits ')' ';'  
                {% withThisPackage $ \pkg -> 
                   do lits <- sequence $6;
                      staticClosure pkg $3 $5 (map getLit lits) }
334
335
336
337
338

-- The only static closures in the RTS are dummy closures like
-- stg_END_TSO_QUEUE_closure and stg_dummy_ret.  We don't need
-- to provide the full generality of static closures here.
-- In particular:
339
340
341
342
--      * CCS can always be CCS_DONT_CARE
--      * closure is always extern
--      * payload is always empty
--      * we can derive closure and info table labels from a single NAME
343

344
cmmdata :: { CmmParse () }
Simon Marlow's avatar
untab    
Simon Marlow committed
345
346
347
348
        : 'section' STRING '{' data_label statics '}' 
                { do lbl <- $4;
                     ss <- sequence $5;
                     code (emitDecl (CmmData (section $2) (Statics lbl $ concat ss))) }
349
350

data_label :: { CmmParse CLabel }
Simon Marlow's avatar
untab    
Simon Marlow committed
351
352
353
    : NAME ':'  
                {% withThisPackage $ \pkg -> 
                   return (mkCmmDataLabel pkg $1) }
354

Simon Marlow's avatar
untab    
Simon Marlow committed
355
356
357
statics :: { [CmmParse [CmmStatic]] }
        : {- empty -}                   { [] }
        | static statics                { $1 : $2 }
358
    
359
360
-- Strings aren't used much in the RTS HC code, so it doesn't seem
-- worth allowing inline strings.  C-- doesn't allow them anyway.
361
static  :: { CmmParse [CmmStatic] }
Simon Marlow's avatar
untab    
Simon Marlow committed
362
363
364
365
366
367
368
369
370
371
372
373
        : type expr ';' { do e <- $2;
                             return [CmmStaticLit (getLit e)] }
        | type ';'                      { return [CmmUninitialised
                                                        (widthInBytes (typeWidth $1))] }
        | 'bits8' '[' ']' STRING ';'    { return [mkString $4] }
        | 'bits8' '[' INT ']' ';'       { return [CmmUninitialised 
                                                        (fromIntegral $3)] }
        | typenot8 '[' INT ']' ';'      { return [CmmUninitialised 
                                                (widthInBytes (typeWidth $1) * 
                                                        fromIntegral $3)] }
        | 'CLOSURE' '(' NAME lits ')'
                { do { lits <- sequence $4
374
                ; dflags <- getDynFlags
375
                     ; return $ map CmmStaticLit $
376
                        mkStaticClosure dflags (mkForeignLabel $3 Nothing ForeignLabelInExternalPackage IsData)
377
378
                         -- mkForeignLabel because these are only used
                         -- for CHARLIKE and INTLIKE closures in the RTS.
379
                        dontCareCCS (map getLit lits) [] [] [] } }
380
        -- arrays of closures required for the CHARLIKE & INTLIKE arrays
381

382
lits    :: { [CmmParse CmmExpr] }
Simon Marlow's avatar
untab    
Simon Marlow committed
383
384
        : {- empty -}           { [] }
        | ',' expr lits         { $2 : $3 }
385
386
387
388
389
390
391

cmmproc :: { CmmParse () }
        : info maybe_conv maybe_formals maybe_body
                { do ((entry_ret_label, info, stk_formals, formals), agraph) <-
                       getCodeR $ loopDecls $ do {
                         (entry_ret_label, info, stk_formals) <- $1;
                         formals <- sequence (fromMaybe [] $3);
Simon Marlow's avatar
Simon Marlow committed
392
                         $4;
393
394
395
396
397
                         return (entry_ret_label, info, stk_formals, formals) }
                     let do_layout = isJust $3
                     code (emitProcWithStackFrame $2 info
                                entry_ret_label stk_formals formals agraph
                                do_layout ) }
398

399
400
401
maybe_conv :: { Convention }
           : {- empty -}        { NativeNodeCall }
           | 'return'           { NativeReturn }
402

403
404
405
406
407
408
maybe_body :: { CmmParse () }
           : ';'                { return () }
           | '{' body '}'       { $2 }

info    :: { CmmParse (CLabel, Maybe CmmInfoTable, [LocalReg]) }
        : NAME
Simon Marlow's avatar
untab    
Simon Marlow committed
409
410
                {% withThisPackage $ \pkg ->
                   do   newFunctionName $1 pkg
411
412
413
414
                        return (mkCmmCodeLabel pkg $1, Nothing, []) }


        | 'INFO_TABLE' '(' NAME ',' INT ',' INT ',' INT ',' STRING ',' STRING ')'
Simon Marlow's avatar
untab    
Simon Marlow committed
415
416
                -- ptrs, nptrs, closure type, description, type
                {% withThisPackage $ \pkg ->
417
418
                   do dflags <- getDynFlags
                      let prof = profilingInfo dflags $11 $13
419
                          rep  = mkRTSRep (fromIntegral $9) $
420
                                   mkHeapRep dflags False (fromIntegral $5)
421
422
423
424
                                                   (fromIntegral $7) Thunk
                              -- not really Thunk, but that makes the info table
                              -- we want.
                      return (mkCmmEntryLabel pkg $3,
425
                              Just $ CmmInfoTable { cit_lbl = mkCmmInfoLabel pkg $3
Simon Marlow's avatar
untab    
Simon Marlow committed
426
427
428
429
                                           , cit_rep = rep
                                           , cit_prof = prof, cit_srt = NoC_SRT },
                              []) }
        
430
        | 'INFO_TABLE_FUN' '(' NAME ',' INT ',' INT ',' INT ',' STRING ',' STRING ',' INT ')'
Simon Marlow's avatar
untab    
Simon Marlow committed
431
432
                -- ptrs, nptrs, closure type, description, type, fun type
                {% withThisPackage $ \pkg -> 
433
434
                   do dflags <- getDynFlags
                      let prof = profilingInfo dflags $11 $13
435
                          ty   = Fun 0 (ArgSpec (fromIntegral $15))
436
                                -- Arity zero, arg_type $15
437
                          rep = mkRTSRep (fromIntegral $9) $
438
                                    mkHeapRep dflags False (fromIntegral $5)
439
440
                                                    (fromIntegral $7) ty
                      return (mkCmmEntryLabel pkg $3,
441
                              Just $ CmmInfoTable { cit_lbl = mkCmmInfoLabel pkg $3
Simon Marlow's avatar
untab    
Simon Marlow committed
442
443
444
445
446
                                           , cit_rep = rep
                                           , cit_prof = prof, cit_srt = NoC_SRT },
                              []) }
                -- we leave most of the fields zero here.  This is only used
                -- to generate the BCO info table in the RTS at the moment.
447
448

        | 'INFO_TABLE_CONSTR' '(' NAME ',' INT ',' INT ',' INT ',' INT ',' STRING ',' STRING ')'
449
450
                -- ptrs, nptrs, tag, closure type, description, type
                {% withThisPackage $ \pkg ->
451
452
                   do dflags <- getDynFlags
                      let prof = profilingInfo dflags $13 $15
453
                          ty  = Constr (fromIntegral $9)  -- Tag
454
                                       (stringToWord8s $13)
455
                          rep = mkRTSRep (fromIntegral $11) $
456
                                  mkHeapRep dflags False (fromIntegral $5)
457
458
                                                  (fromIntegral $7) ty
                      return (mkCmmEntryLabel pkg $3,
459
                              Just $ CmmInfoTable { cit_lbl = mkCmmInfoLabel pkg $3
Simon Marlow's avatar
untab    
Simon Marlow committed
460
461
462
                                           , cit_rep = rep
                                           , cit_prof = prof, cit_srt = NoC_SRT },
                              []) }
463

Simon Marlow's avatar
untab    
Simon Marlow committed
464
465
466
                     -- If profiling is on, this string gets duplicated,
                     -- but that's the way the old code did it we can fix it some other time.
        
467
        | 'INFO_TABLE_SELECTOR' '(' NAME ',' INT ',' INT ',' STRING ',' STRING ')'
Simon Marlow's avatar
untab    
Simon Marlow committed
468
469
                -- selector, closure type, description, type
                {% withThisPackage $ \pkg ->
470
471
                   do dflags <- getDynFlags
                      let prof = profilingInfo dflags $9 $11
472
473
                          ty  = ThunkSelector (fromIntegral $5)
                          rep = mkRTSRep (fromIntegral $7) $
474
                                   mkHeapRep dflags False 0 0 ty
475
                      return (mkCmmEntryLabel pkg $3,
476
                              Just $ CmmInfoTable { cit_lbl = mkCmmInfoLabel pkg $3
Simon Marlow's avatar
untab    
Simon Marlow committed
477
478
479
                                           , cit_rep = rep
                                           , cit_prof = prof, cit_srt = NoC_SRT },
                              []) }
480
481

        | 'INFO_TABLE_RET' '(' NAME ',' INT ')'
Simon Marlow's avatar
untab    
Simon Marlow committed
482
483
484
                -- closure type (no live regs)
                {% withThisPackage $ \pkg ->
                   do let prof = NoProfilingInfo
485
                          rep  = mkRTSRep (fromIntegral $5) $ mkStackRep []
486
                      return (mkCmmRetLabel pkg $3,
487
                              Just $ CmmInfoTable { cit_lbl = mkCmmRetInfoLabel pkg $3
Simon Marlow's avatar
untab    
Simon Marlow committed
488
489
490
                                           , cit_rep = rep
                                           , cit_prof = prof, cit_srt = NoC_SRT },
                              []) }
491
492

        | 'INFO_TABLE_RET' '(' NAME ',' INT ',' formals0 ')'
Simon Marlow's avatar
untab    
Simon Marlow committed
493
494
                -- closure type, live regs
                {% withThisPackage $ \pkg ->
495
                   do dflags <- getDynFlags
496
                      live <- sequence $7
Simon Marlow's avatar
untab    
Simon Marlow committed
497
                      let prof = NoProfilingInfo
498
499
500
                          -- drop one for the info pointer
                          bitmap = mkLiveness dflags (map Just (drop 1 live))
                          rep  = mkRTSRep (fromIntegral $5) $ mkStackRep bitmap
501
                      return (mkCmmRetLabel pkg $3,
502
                              Just $ CmmInfoTable { cit_lbl = mkCmmRetInfoLabel pkg $3
Simon Marlow's avatar
untab    
Simon Marlow committed
503
504
                                           , cit_rep = rep
                                           , cit_prof = prof, cit_srt = NoC_SRT },
505
                              live) }
506

507
body    :: { CmmParse () }
Simon Marlow's avatar
untab    
Simon Marlow committed
508
509
510
        : {- empty -}                   { return () }
        | decl body                     { do $1; $2 }
        | stmt body                     { do $1; $2 }
511

512
decl    :: { CmmParse () }
Simon Marlow's avatar
untab    
Simon Marlow committed
513
514
515
        : type names ';'                { mapM_ (newLocal $1) $2 }
        | 'import' importNames ';'      { mapM_ newImport $2 }
        | 'export' names ';'            { return () }  -- ignore exports
516

517
518

-- an imported function name, with optional packageId
519
520
521
522
523
importNames
        :: { [(FastString, CLabel)] }
        : importName                    { [$1] }
        | importName ',' importNames    { $1 : $3 }

524
importName
525
526
        :: { (FastString,  CLabel) }

Simon Marlow's avatar
untab    
Simon Marlow committed
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
        -- A label imported without an explicit packageId.
        --      These are taken to come frome some foreign, unnamed package.
        : NAME  
        { ($1, mkForeignLabel $1 Nothing ForeignLabelInExternalPackage IsFunction) }

        -- A label imported with an explicit packageId.
        | STRING NAME
        { ($2, mkCmmCodeLabel (fsToPackageId (mkFastString $1)) $2) }
        
        
names   :: { [FastString] }
        : NAME                          { [$1] }
        | NAME ',' names                { $1 : $3 }

stmt    :: { CmmParse () }
542
543
        : ';'                                   { return () }

Simon Marlow's avatar
untab    
Simon Marlow committed
544
        | NAME ':'
545
546
547
548
                { do l <- newLabel $1; emitLabel l }



Simon Marlow's avatar
untab    
Simon Marlow committed
549
        | lreg '=' expr ';'
550
                { do reg <- $1; e <- $3; emitAssign reg e }
Simon Marlow's avatar
untab    
Simon Marlow committed
551
552
        | type '[' expr ']' '=' expr ';'
                { doStore $1 $3 $6 }
553
554

        -- Gah! We really want to say "foreign_results" but that causes
Simon Marlow's avatar
untab    
Simon Marlow committed
555
556
557
558
559
        -- a shift/reduce conflict with assignment.  We either
        -- we expand out the no-result and single result cases or
        -- we tweak the syntax to avoid the conflict.  The later
        -- option is taken here because the other way would require
        -- multiple levels of expanding and get unwieldy.
560
        | foreign_results 'foreign' STRING foreignLabel '(' cmm_hint_exprs0 ')' safety opt_never_returns ';'
561
562
563
                {% foreignCall $3 $1 $4 $6 $8 $9 }
        | foreign_results 'prim' '%' NAME '(' exprs0 ')' ';'
                {% primCall $1 $4 $6 }
Simon Marlow's avatar
untab    
Simon Marlow committed
564
565
566
567
568
569
570
        -- stmt-level macros, stealing syntax from ordinary C-- function calls.
        -- Perhaps we ought to use the %%-form?
        | NAME '(' exprs0 ')' ';'
                {% stmtMacro $1 $3  }
        | 'switch' maybe_range expr '{' arms default '}'
                { do as <- sequence $5; doSwitch $2 $3 as $6 }
        | 'goto' NAME ';'
571
572
573
                { do l <- lookupLabel $2; emit (mkBranch l) }
        | 'return' '(' exprs0 ')' ';'
                { doReturn $3 }
574
        | 'jump' expr vols ';'
575
576
577
578
579
580
581
582
583
                { doRawJump $2 $3 }
        | 'jump' expr '(' exprs0 ')' ';'
                { doJumpWithStack $2 [] $4 }
        | 'jump' expr '(' exprs0 ')' '(' exprs0 ')' ';'
                { doJumpWithStack $2 $4 $7 }
        | 'call' expr '(' exprs0 ')' ';'
                { doCall $2 [] $4 }
        | '(' formals ')' '=' 'call' expr '(' exprs0 ')' ';'
                { doCall $6 $2 $8 }
584
        | 'if' bool_expr 'goto' NAME
Simon Marlow's avatar
untab    
Simon Marlow committed
585
586
587
                { do l <- lookupLabel $4; cmmRawIf $2 l }
        | 'if' bool_expr '{' body '}' else      
                { cmmIfThenElse $2 $4 $6 }
588
589
        | 'push' '(' exprs0 ')' maybe_body
                { pushStackFrame $3 $5 }
590

591
foreignLabel     :: { CmmParse CmmExpr }
592
        : NAME                          { return (CmmLit (CmmLabel (mkForeignLabel $1 Nothing ForeignLabelInThisPackage IsFunction))) }
593

594
595
596
opt_never_returns :: { CmmReturnInfo }
        :                               { CmmMayReturn }
        | 'never' 'returns'             { CmmNeverReturns }
597

598
bool_expr :: { CmmParse BoolExpr }
Simon Marlow's avatar
untab    
Simon Marlow committed
599
600
        : bool_op                       { $1 }
        | expr                          { do e <- $1; return (BoolTest e) }
601
602

bool_op :: { CmmParse BoolExpr }
Simon Marlow's avatar
untab    
Simon Marlow committed
603
604
605
606
607
608
        : bool_expr '&&' bool_expr      { do e1 <- $1; e2 <- $3; 
                                          return (BoolAnd e1 e2) }
        | bool_expr '||' bool_expr      { do e1 <- $1; e2 <- $3; 
                                          return (BoolOr e1 e2)  }
        | '!' bool_expr                 { do e <- $2; return (BoolNot e) }
        | '(' bool_op ')'               { $2 }
609
610
611

safety  :: { Safety }
        : {- empty -}                   { PlayRisky }
Simon Marlow's avatar
untab    
Simon Marlow committed
612
        | STRING                        {% parseSafety $1 }
613
614
615
616

vols    :: { [GlobalReg] }
        : '[' ']'                       { [] }
        | '[' '*' ']'                   {% do df <- getDynFlags
617
618
619
                                         ; return (realArgRegsCover df) }
                                           -- All of them. See comment attached
                                           -- to realArgRegsCover
620
        | '[' globals ']'               { $2 }
621
622

globals :: { [GlobalReg] }
623
624
        : GLOBALREG                     { [$1] }
        | GLOBALREG ',' globals         { $1 : $3 }
625
626

maybe_range :: { Maybe (Int,Int) }
627
628
        : '[' INT '..' INT ']'  { Just (fromIntegral $2, fromIntegral $4) }
        | {- empty -}           { Nothing }
629

630
arms    :: { [CmmParse ([Int],Either BlockId (CmmParse ()))] }
Simon Marlow's avatar
untab    
Simon Marlow committed
631
632
        : {- empty -}                   { [] }
        | arm arms                      { $1 : $2 }
633

634
arm     :: { CmmParse ([Int],Either BlockId (CmmParse ())) }
Simon Marlow's avatar
untab    
Simon Marlow committed
635
        : 'case' ints ':' arm_body      { do b <- $4; return ($2, b) }
636

637
arm_body :: { CmmParse (Either BlockId (CmmParse ())) }
Simon Marlow's avatar
untab    
Simon Marlow committed
638
639
        : '{' body '}'                  { return (Right $2) }
        | 'goto' NAME ';'               { do l <- lookupLabel $2; return (Left l) }
640

641
642
643
ints    :: { [Int] }
        : INT                           { [ fromIntegral $1 ] }
        | INT ',' ints                  { fromIntegral $1 : $3 }
644

645
default :: { Maybe (CmmParse ()) }
Simon Marlow's avatar
untab    
Simon Marlow committed
646
647
648
649
        : 'default' ':' '{' body '}'    { Just $4 }
        -- taking a few liberties with the C-- syntax here; C-- doesn't have
        -- 'default' branches
        | {- empty -}                   { Nothing }
650

651
652
-- Note: OldCmm doesn't support a first class 'else' statement, though
-- CmmNode does.
653
654
else    :: { CmmParse () }
        : {- empty -}                   { return () }
Simon Marlow's avatar
untab    
Simon Marlow committed
655
        | 'else' '{' body '}'           { $3 }
656
657
658

-- we have to write this out longhand so that Happy's precedence rules
-- can kick in.
659
expr    :: { CmmParse CmmExpr }
Simon Marlow's avatar
untab    
Simon Marlow committed
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
        : expr '/' expr                 { mkMachOp MO_U_Quot [$1,$3] }
        | expr '*' expr                 { mkMachOp MO_Mul [$1,$3] }
        | expr '%' expr                 { mkMachOp MO_U_Rem [$1,$3] }
        | expr '-' expr                 { mkMachOp MO_Sub [$1,$3] }
        | expr '+' expr                 { mkMachOp MO_Add [$1,$3] }
        | expr '>>' expr                { mkMachOp MO_U_Shr [$1,$3] }
        | expr '<<' expr                { mkMachOp MO_Shl [$1,$3] }
        | expr '&' expr                 { mkMachOp MO_And [$1,$3] }
        | expr '^' expr                 { mkMachOp MO_Xor [$1,$3] }
        | expr '|' expr                 { mkMachOp MO_Or [$1,$3] }
        | expr '>=' expr                { mkMachOp MO_U_Ge [$1,$3] }
        | expr '>' expr                 { mkMachOp MO_U_Gt [$1,$3] }
        | expr '<=' expr                { mkMachOp MO_U_Le [$1,$3] }
        | expr '<' expr                 { mkMachOp MO_U_Lt [$1,$3] }
        | expr '!=' expr                { mkMachOp MO_Ne [$1,$3] }
        | expr '==' expr                { mkMachOp MO_Eq [$1,$3] }
        | '~' expr                      { mkMachOp MO_Not [$2] }
        | '-' expr                      { mkMachOp MO_S_Neg [$2] }
        | expr0 '`' NAME '`' expr0      {% do { mo <- nameToMachOp $3 ;
                                                return (mkMachOp mo [$1,$5]) } }
        | expr0                         { $1 }

expr0   :: { CmmParse CmmExpr }
        : INT   maybe_ty         { return (CmmLit (CmmInt $1 (typeWidth $2))) }
        | FLOAT maybe_ty         { return (CmmLit (CmmFloat $1 (typeWidth $2))) }
        | STRING                 { do s <- code (newStringCLit $1); 
                                      return (CmmLit s) }
        | reg                    { $1 }
        | type '[' expr ']'      { do e <- $3; return (CmmLoad e $1) }
        | '%' NAME '(' exprs0 ')' {% exprOp $2 $4 }
        | '(' expr ')'           { $2 }
691
692
693


-- leaving out the type of a literal gives you the native word size in C--
694
maybe_ty :: { CmmType }
695
        : {- empty -}                   {% do dflags <- getDynFlags; return $ bWord dflags }
696
        | '::' type                     { $2 }
697

698
cmm_hint_exprs0 :: { [CmmParse (CmmExpr, ForeignHint)] }
Simon Marlow's avatar
untab    
Simon Marlow committed
699
        : {- empty -}                   { [] }
700
        | cmm_hint_exprs                { $1 }
701

702
cmm_hint_exprs :: { [CmmParse (CmmExpr, ForeignHint)] }
Simon Marlow's avatar
untab    
Simon Marlow committed
703
704
        : cmm_hint_expr                 { [$1] }
        | cmm_hint_expr ',' cmm_hint_exprs      { $1 : $3 }
705

706
707
708
cmm_hint_expr :: { CmmParse (CmmExpr, ForeignHint) }
        : expr                          { do e <- $1;
                                             return (e, inferCmmHint e) }
Simon Marlow's avatar
untab    
Simon Marlow committed
709
710
        | expr STRING                   {% do h <- parseCmmHint $2;
                                              return $ do
711
                                                e <- $1; return (e, h) }
712

713
exprs0  :: { [CmmParse CmmExpr] }
Simon Marlow's avatar
untab    
Simon Marlow committed
714
715
        : {- empty -}                   { [] }
        | exprs                         { $1 }
716

717
exprs   :: { [CmmParse CmmExpr] }
Simon Marlow's avatar
untab    
Simon Marlow committed
718
719
        : expr                          { [ $1 ] }
        | expr ',' exprs                { $1 : $3 }
720

721
reg     :: { CmmParse CmmExpr }
Simon Marlow's avatar
untab    
Simon Marlow committed
722
723
        : NAME                  { lookupName $1 }
        | GLOBALREG             { return (CmmReg (CmmGlobal $1)) }
724
725
726
727
728
729

foreign_results :: { [CmmParse (LocalReg, ForeignHint)] }
        : {- empty -}                   { [] }
        | '(' foreign_formals ')' '='   { $2 }

foreign_formals :: { [CmmParse (LocalReg, ForeignHint)] }
Simon Marlow's avatar
untab    
Simon Marlow committed
730
        : foreign_formal                        { [$1] }
731
732
733
734
735
736
737
738
739
740
        | foreign_formal ','                    { [$1] }
        | foreign_formal ',' foreign_formals    { $1 : $3 }

foreign_formal :: { CmmParse (LocalReg, ForeignHint) }
        : local_lreg            { do e <- $1; return (e, (inferCmmHint (CmmReg (CmmLocal e)))) }
        | STRING local_lreg     {% do h <- parseCmmHint $1;
                                      return $ do
                                         e <- $2; return (e,h) }

local_lreg :: { CmmParse LocalReg }
Simon Marlow's avatar
untab    
Simon Marlow committed
741
742
743
744
745
746
747
748
749
750
751
752
753
        : NAME                  { do e <- lookupName $1;
                                     return $
                                       case e of 
                                        CmmReg (CmmLocal r) -> r
                                        other -> pprPanic "CmmParse:" (ftext $1 <> text " not a local register") }

lreg    :: { CmmParse CmmReg }
        : NAME                  { do e <- lookupName $1;
                                     return $
                                       case e of 
                                        CmmReg r -> r
                                        other -> pprPanic "CmmParse:" (ftext $1 <> text " not a register") }
        | GLOBALREG             { return (CmmGlobal $1) }
754
755
756
757
758
759

maybe_formals :: { Maybe [CmmParse LocalReg] }
        : {- empty -}           { Nothing }
        | '(' formals0 ')'      { Just $2 }

formals0 :: { [CmmParse LocalReg] }
Simon Marlow's avatar
untab    
Simon Marlow committed
760
        : {- empty -}           { [] }
761
762
763
764
765
766
767
768
        | formals               { $1 }

formals :: { [CmmParse LocalReg] }
        : formal ','            { [$1] }
        | formal                { [$1] }
        | formal ',' formals       { $1 : $3 }

formal :: { CmmParse LocalReg }
Simon Marlow's avatar
untab    
Simon Marlow committed
769
        : type NAME             { newLocal $1 $2 }
770

Simon Marlow's avatar
Simon Marlow committed
771
type    :: { CmmType }
772
773
        : 'bits8'               { b8 }
        | typenot8              { $1 }
774

775
typenot8 :: { CmmType }
776
777
778
        : 'bits16'              { b16 }
        | 'bits32'              { b32 }
        | 'bits64'              { b64 }
779
        | 'bits128'             { b128 }
780
781
        | 'float32'             { f32 }
        | 'float64'             { f64 }
782
        | 'gcptr'               {% do dflags <- getDynFlags; return $ gcWord dflags }
783

784
785
{
section :: String -> Section
786
787
788
section "text"      = Text
section "data"      = Data
section "rodata"    = ReadOnlyData
789
section "relrodata" = RelocatableReadOnlyData
790
791
section "bss"       = UninitialisedData
section s           = OtherSection s
792

793
794
795
mkString :: String -> CmmStatic
mkString s = CmmString (map (fromIntegral.ord) s)

796
797
798
799
800
801
802
803
804
805
806
-- |
-- Given an info table, decide what the entry convention for the proc
-- is.  That is, for an INFO_TABLE_RET we want the return convention,
-- otherwise it is a NativeNodeCall.
--
infoConv :: Maybe CmmInfoTable -> Convention
infoConv Nothing = NativeNodeCall
infoConv (Just info)
  | isStackRep (cit_rep info) = NativeReturn
  | otherwise                 = NativeNodeCall

807
808
809
810
-- mkMachOp infers the type of the MachOp from the type of its first
-- argument.  We assume that this is correct: for MachOps that don't have
-- symmetrical args (e.g. shift ops), the first arg determines the type of
-- the op.
811
mkMachOp :: (Width -> MachOp) -> [CmmParse CmmExpr] -> CmmParse CmmExpr
812
mkMachOp fn args = do
813
  dflags <- getDynFlags
814
  arg_exprs <- sequence args
815
  return (CmmMachOp (fn (typeWidth (cmmExprType dflags (head arg_exprs)))) arg_exprs)
816
817
818
819
820
821

getLit :: CmmExpr -> CmmLit
getLit (CmmLit l) = l
getLit (CmmMachOp (MO_S_Neg _) [CmmLit (CmmInt i r)])  = CmmInt (negate i) r
getLit _ = panic "invalid literal" -- TODO messy failure

822
nameToMachOp :: FastString -> P (Width -> MachOp)
823
nameToMachOp name =
824
  case lookupUFM machOps name of
825
826
        Nothing -> fail ("unknown primitive " ++ unpackFS name)
        Just m  -> return m
827

828
exprOp :: FastString -> [CmmParse CmmExpr] -> P (CmmParse CmmExpr)
829
830
831
exprOp name args_code = do
  dflags <- getDynFlags
  case lookupUFM (exprMacros dflags) name of
832
833
     Just f  -> return $ do
        args <- sequence args_code
834
        return (f args)
835
     Nothing -> do
836
837
        mo <- nameToMachOp name
        return $ mkMachOp mo args_code
838

839
840
exprMacros :: DynFlags -> UniqFM ([CmmExpr] -> CmmExpr)
exprMacros dflags = listToUFM [
841
  ( fsLit "ENTRY_CODE",   \ [x] -> entryCode dflags x ),
842
  ( fsLit "INFO_PTR",     \ [x] -> closureInfoPtr dflags x ),
843
844
  ( fsLit "STD_INFO",     \ [x] -> infoTable dflags x ),
  ( fsLit "FUN_INFO",     \ [x] -> funInfoTable dflags x ),
845
846
847
  ( fsLit "GET_ENTRY",    \ [x] -> entryCode dflags (closureInfoPtr dflags x) ),
  ( fsLit "GET_STD_INFO", \ [x] -> infoTable dflags (closureInfoPtr dflags x) ),
  ( fsLit "GET_FUN_INFO", \ [x] -> funInfoTable dflags (closureInfoPtr dflags x) ),
848
849
850
  ( fsLit "INFO_TYPE",    \ [x] -> infoTableClosureType dflags x ),
  ( fsLit "INFO_PTRS",    \ [x] -> infoTablePtrs dflags x ),
  ( fsLit "INFO_NPTRS",   \ [x] -> infoTableNonPtrs dflags x )
851
852
853
854
  ]

-- we understand a subset of C-- primitives:
machOps = listToUFM $
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
        map (\(x, y) -> (mkFastString x, y)) [
        ( "add",        MO_Add ),
        ( "sub",        MO_Sub ),
        ( "eq",         MO_Eq ),
        ( "ne",         MO_Ne ),
        ( "mul",        MO_Mul ),
        ( "neg",        MO_S_Neg ),
        ( "quot",       MO_S_Quot ),
        ( "rem",        MO_S_Rem ),
        ( "divu",       MO_U_Quot ),
        ( "modu",       MO_U_Rem ),

        ( "ge",         MO_S_Ge ),
        ( "le",         MO_S_Le ),
        ( "gt",         MO_S_Gt ),
        ( "lt",         MO_S_Lt ),

        ( "geu",        MO_U_Ge ),
        ( "leu",        MO_U_Le ),
        ( "gtu",        MO_U_Gt ),
        ( "ltu",        MO_U_Lt ),
876

877
        ( "and",        MO_And ),
878
879
880
881
882
883
        ( "or",         MO_Or ),
        ( "xor",        MO_Xor ),
        ( "com",        MO_Not ),
        ( "shl",        MO_Shl ),
        ( "shrl",       MO_U_Shr ),
        ( "shra",       MO_S_Shr ),
884

885
886
887
888
889
890
891
892
893
894
895
896
897
898
        ( "fadd",       MO_F_Add ),
        ( "fsub",       MO_F_Sub ),
        ( "fneg",       MO_F_Neg ),
        ( "fmul",       MO_F_Mul ),
        ( "fquot",      MO_F_Quot ),

        ( "feq",        MO_F_Eq ),
        ( "fne",        MO_F_Ne ),
        ( "fge",        MO_F_Ge ),
        ( "fle",        MO_F_Le ),
        ( "fgt",        MO_F_Gt ),
        ( "flt",        MO_F_Lt ),

        ( "lobits8",  flip MO_UU_Conv W8  ),
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
        ( "lobits16", flip MO_UU_Conv W16 ),
        ( "lobits32", flip MO_UU_Conv W32 ),
        ( "lobits64", flip MO_UU_Conv W64 ),

        ( "zx16",     flip MO_UU_Conv W16 ),
        ( "zx32",     flip MO_UU_Conv W32 ),
        ( "zx64",     flip MO_UU_Conv W64 ),

        ( "sx16",     flip MO_SS_Conv W16 ),
        ( "sx32",     flip MO_SS_Conv W32 ),
        ( "sx64",     flip MO_SS_Conv W64 ),

        ( "f2f32",    flip MO_FF_Conv W32 ),  -- TODO; rounding mode
        ( "f2f64",    flip MO_FF_Conv W64 ),  -- TODO; rounding mode
        ( "f2i8",     flip MO_FS_Conv W8 ),
        ( "f2i16",    flip MO_FS_Conv W16 ),
        ( "f2i32",    flip MO_FS_Conv W32 ),
        ( "f2i64",    flip MO_FS_Conv W64 ),
        ( "i2f32",    flip MO_SF_Conv W32 ),
        ( "i2f64",    flip MO_SF_Conv W64 )
        ]
920

921
callishMachOps = listToUFM $
922
        map (\(x, y) -> (mkFastString x, y)) [
923
924
925
926
        ( "write_barrier", MO_WriteBarrier ),
        ( "memcpy", MO_Memcpy ),
        ( "memset", MO_Memset ),
        ( "memmove", MO_Memmove )
927
928
929
        -- ToDo: the rest, maybe
    ]

930
931
932
933
parseSafety :: String -> P Safety
parseSafety "safe"   = return PlaySafe
parseSafety "unsafe" = return PlayRisky
parseSafety "interruptible" = return PlayInterruptible
934
935
parseSafety str      = fail ("unrecognised safety: " ++ str)

936
937
938
939
parseCmmHint :: String -> P ForeignHint
parseCmmHint "ptr"    = return AddrHint
parseCmmHint "signed" = return SignedHint
parseCmmHint str      = fail ("unrecognised hint: " ++ str)
940

941
-- labels are always pointers, so we might as well infer the hint
942
943
944
945
946
inferCmmHint :: CmmExpr -> ForeignHint
inferCmmHint (CmmLit (CmmLabel _)) = AddrHint
inferCmmHint (CmmReg (CmmGlobal g)) | isPtrGlobalReg g = AddrHint
inferCmmHint _ = NoHint

947
948
949
950
isPtrGlobalReg Sp                    = True
isPtrGlobalReg SpLim                 = True
isPtrGlobalReg Hp                    = True
isPtrGlobalReg HpLim                 = True
951
952
953
isPtrGlobalReg CCCS                  = True
isPtrGlobalReg CurrentTSO            = True
isPtrGlobalReg CurrentNursery        = True
954
isPtrGlobalReg (VanillaReg _ VGcPtr) = True
955
isPtrGlobalReg _                     = False
956
957
958
959
960
961
962

happyError :: P a
happyError = srcParseFail

-- -----------------------------------------------------------------------------
-- Statement-level macros

963
stmtMacro :: FastString -> [CmmParse CmmExpr] -> P (CmmParse ())
964
965
966
967
stmtMacro fun args_code = do
  case lookupUFM stmtMacros fun of
    Nothing -> fail ("unknown macro: " ++ unpackFS fun)
    Just fcode -> return $ do
968
969
        args <- sequence args_code
        code (fcode args)
970

971
stmtMacros :: UniqFM ([CmmExpr] -> FCode ())
972
stmtMacros = listToUFM [
973
  ( fsLit "CCS_ALLOC",             \[words,ccs]  -> profAlloc words ccs ),
974
975
  ( fsLit "ENTER_CCS_THUNK",       \[e] -> enterCostCentreThunk e ),

976
977
  ( fsLit "CLOSE_NURSERY",         \[]  -> emitCloseNursery ),
  ( fsLit "OPEN_NURSERY",          \[]  -> emitOpenNursery ),
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998

  -- completely generic heap and stack checks, for use in high-level cmm.
  ( fsLit "HP_CHK_GEN",            \[bytes] ->
                                      heapStackCheckGen Nothing (Just bytes) ),
  ( fsLit "STK_CHK_GEN",           \[] ->
                                      heapStackCheckGen (Just (CmmLit CmmHighStackMark)) Nothing ),

  -- A stack check for a fixed amount of stack.  Sounds a bit strange, but
  -- we use the stack for a bit of temporary storage in a couple of primops
  ( fsLit "STK_CHK_GEN_N",         \[bytes] ->
                                      heapStackCheckGen (Just bytes) Nothing ),

  -- A stack check on entry to a thunk, where the argument is the thunk pointer.
  ( fsLit "STK_CHK_NP"   ,         \[node] -> entryHeapCheck' False node 0 [] (return ())),

  ( fsLit "LOAD_THREAD_STATE",     \[] -> emitLoadThreadState ),
  ( fsLit "SAVE_THREAD_STATE",     \[] -> emitSaveThreadState ),

  ( fsLit "LDV_ENTER",             \[e] -> ldvEnter e ),
  ( fsLit "LDV_RECORD_CREATE",     \[e] -> ldvRecordCreate e ),

999
1000
  ( fsLit "PUSH_UPD_FRAME",        \[sp,e] -> emitPushUpdateFrame sp e ),
  ( fsLit "SET_HDR",               \[ptr,info,ccs] ->
Simon Marlow's avatar
untab    
Simon Marlow committed
1001
                                        emitSetDynHdr ptr info ccs ),
1002
  ( fsLit "TICK_ALLOC_PRIM",       \[hdr,goods,slop] ->
Simon Marlow's avatar
untab    
Simon Marlow committed
1003
                                        tickyAllocPrim hdr goods slop ),
1004
  ( fsLit "TICK_ALLOC_PAP",        \[goods,slop] ->
Simon Marlow's avatar
untab    
Simon Marlow committed
1005
                                        tickyAllocPAP goods slop ),
1006
  ( fsLit "TICK_ALLOC_UP_THK",     \[goods,slop] ->
Simon Marlow's avatar
untab    
Simon Marlow committed
1007
                                        tickyAllocThunk goods slop ),
1008
1009
  ( fsLit "UPD_BH_UPDATABLE",      \[reg] -> emitBlackHoleCode False reg ),
  ( fsLit "UPD_BH_SINGLE_ENTRY",   \[reg] -> emitBlackHoleCode True  reg )
1010
1011
 ]

1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
emitPushUpdateFrame :: CmmExpr -> CmmExpr -> FCode ()
emitPushUpdateFrame sp e = do
  dflags <- getDynFlags
  emitUpdateFrame dflags sp mkUpdInfoLabel e

pushStackFrame :: [CmmParse CmmExpr] -> CmmParse () -> CmmParse ()
pushStackFrame fields body = do
  dflags <- getDynFlags
  exprs <- sequence fields
  updfr_off <- getUpdFrameOff
  let (new_updfr_off, _, g) = copyOutOflow dflags NativeReturn Ret Old
                                           [] updfr_off exprs
  emit g
  withUpdFrameOff new_updfr_off body
1026

1027
profilingInfo dflags desc_str ty_str
ian@well-typed.com's avatar
ian@well-typed.com committed
1028
  = if not (gopt Opt_SccProfilingOn dflags)
1029
1030
1031
    then NoProfilingInfo
    else ProfilingInfo (stringToWord8s desc_str)
                       (stringToWord8s ty_str)
1032

1033
staticClosure :: PackageId -> FastString -> FastString -> [CmmLit] -> CmmParse ()
1034
staticClosure pkg cl_label info payload
1035
1036
1037
  = do dflags <- getDynFlags
       let lits = mkStaticClosure dflags (mkCmmInfoLabel pkg info) dontCareCCS payload [] [] []
       code $ emitDataLits (mkCmmDataLabel pkg cl_label) lits
1038
1039

foreignCall
1040
        :: String
1041
        -> [CmmParse (LocalReg, ForeignHint)]
Simon Marlow's avatar
untab    
Simon Marlow committed
1042
        -> CmmParse CmmExpr
1043
1044
        -> [CmmParse (CmmExpr, ForeignHint)]
        -> Safety
1045
        -> CmmReturnInfo
1046
1047
1048
        -> P (CmmParse ())
foreignCall conv_string results_code expr_code args_code safety ret
  = do  conv <- case conv_string of
1049
          "C" -> return CCallConv
1050
          "stdcall" -> return StdCallConv
1051
          _ -> fail ("unknown calling convention: " ++ conv_string)
1052
        return $ do
1053
          dflags <- getDynFlags
1054
          results <- sequence results_code
Simon Marlow's avatar
untab    
Simon Marlow committed
1055
1056
          expr <- expr_code
          args <- sequence args_code
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
          let
                  expr' = adjCallTarget dflags conv expr args
                  (arg_exprs, arg_hints) = unzip args
                  (res_regs,  res_hints) = unzip results
                  fc = ForeignConvention conv arg_hints res_hints ret
                  target = ForeignTarget expr' fc
          _ <- code $ emitForeignCall safety res_regs target arg_exprs
          return ()


doReturn :: [CmmParse CmmExpr] -> CmmParse ()
doReturn exprs_code = do
  dflags <- getDynFlags
  exprs <- sequence exprs_code
  updfr_off <- getUpdFrameOff
  emit (mkReturnSimple dflags exprs updfr_off)

1074
1075
1076
1077
1078
1079
mkReturnSimple  :: DynFlags -> [CmmActual] -> UpdFrameOffset -> CmmAGraph
mkReturnSimple dflags actuals updfr_off =
  mkReturn dflags e actuals updfr_off
  where e = entryCode dflags (CmmLoad (CmmStackSlot Old updfr_off)
                             (gcWord dflags))

1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
doRawJump :: CmmParse CmmExpr -> [GlobalReg] -> CmmParse ()
doRawJump expr_code vols = do
  dflags <- getDynFlags
  expr <- expr_code
  updfr_off <- getUpdFrameOff
  emit (mkRawJump dflags expr updfr_off vols)

doJumpWithStack :: CmmParse CmmExpr -> [CmmParse CmmExpr]
                -> [CmmParse CmmExpr] -> CmmParse ()
doJumpWithStack expr_code stk_code args_code = do
  dflags <- getDynFlags
  expr <- expr_code
  stk_args <- sequence stk_code
  args <- sequence args_code
  updfr_off <- getUpdFrameOff
1095
  emit (mkJumpExtra dflags NativeNodeCall expr args updfr_off stk_args)
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108

doCall :: CmmParse CmmExpr -> [CmmParse LocalReg] -> [CmmParse CmmExpr]
       -> CmmParse ()
doCall expr_code res_code args_code = do
  dflags <- getDynFlags
  expr <- expr_code
  args <- sequence args_code
  ress <- sequence res_code
  updfr_off <- getUpdFrameOff
  c <- code $ mkCall expr (NativeNodeCall,NativeReturn) ress args updfr_off []
  emit c

adjCallTarget :: DynFlags -> CCallConv -> CmmExpr -> [(CmmExpr, ForeignHint) ]
1109
              -> CmmExpr
1110
1111
-- On Windows, we have to add the '@N' suffix to the label when making
-- a call with the stdcall calling convention.
1112
1113
adjCallTarget dflags StdCallConv (CmmLit (CmmLabel lbl)) args
 | platformOS (targetPlatform dflags) == OSMinGW32
1114
  = CmmLit (CmmLabel (addLabelSize lbl (sum (map size args))))
1115
  where size (e, _) = max (wORD_SIZE dflags) (widthInBytes (typeWidth (cmmExprType dflags e)))
1116
                 -- c.f. CgForeignCall.emitForeignCall
1117
adjCallTarget _ _ expr _
1118
1119
  = expr

1120
primCall
1121
        :: [CmmParse (CmmFormal, ForeignHint)]
Simon Marlow's avatar
untab    
Simon Marlow committed
1122
        -> FastString
1123
1124
1125
        -> [CmmParse CmmExpr]
        -> P (CmmParse ())
primCall results_code name args_code
1126
  = case lookupUFM callishMachOps name of
1127
        Nothing -> fail ("unknown primitive " ++ unpackFS name)
Simon Marlow's avatar
untab    
Simon Marlow committed
1128
1129
1130
        Just p  -> return $ do
                results <- sequence results_code
                args <- sequence args_code
1131
1132
1133
                code (emitPrimCall (map fst results) p args)

doStore :: CmmType -> CmmParse CmmExpr  -> CmmParse CmmExpr -> CmmParse ()
1134
doStore rep addr_code val_code
1135
1136
  = do dflags <- getDynFlags
       addr <- addr_code
1137
       val <- val_code
1138
1139
1140
1141
1142
        -- if the specified store type does not match the type of the expr
        -- on the rhs, then we insert a coercion that will cause the type
        -- mismatch to be flagged by cmm-lint.  If we don't do this, then
        -- the store will happen at the wrong type, and the error will not
        -- be noticed.
1143
       let val_width = typeWidth (cmmExprType dflags val)
1144
           rep_width = typeWidth rep
1145
1146
1147
       let coerce_val
                | val_width /= rep_width = CmmMachOp (MO_UU_Conv val_width rep_width) [val]
                | otherwise              = val
1148
       emitStore addr coerce_val
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160

-- -----------------------------------------------------------------------------
-- If-then-else and boolean expressions

data BoolExpr
  = BoolExpr `BoolAnd` BoolExpr
  | BoolExpr `BoolOr`  BoolExpr
  | BoolNot BoolExpr
  | BoolTest CmmExpr

-- ToDo: smart constructors which simplify the boolean expression.

1161
cmmIfThenElse cond then_part else_part = do
1162
1163
     then_id <- newBlockId
     join_id <- newBlockId
1164
1165
1166
     c <- cond
     emitCond c then_id
     else_part
1167
1168
     emit (mkBranch join_id)
     emitLabel then_id
1169
1170
     then_part
     -- fall through to join
1171
     emitLabel join_id
1172

1173
1174
1175
1176
cmmRawIf cond then_id = do
    c <- cond
    emitCond c then_id

1177
1178
1179
-- 'emitCond cond true_id'  emits code to test whether the cond is true,
-- branching to true_id if so, and falling through otherwise.
emitCond (BoolTest e) then_id = do
1180
1181
1182
  else_id <- newBlockId
  emit (mkCbranch e then_id else_id)
  emitLabel else_id
1183
1184
1185
1186
emitCond (BoolNot (BoolTest (CmmMachOp op args))) then_id
  | Just op' <- maybeInvertComparison op
  = emitCond (BoolTest (CmmMachOp op' args)) then_id
emitCond (BoolNot e) then_id = do
1187
  else_id <- newBlockId
1188
  emitCond e else_id
1189
1190
  emit (mkBranch then_id)
  emitLabel else_id
1191
1192
1193
1194
emitCond (e1 `BoolOr` e2) then_id = do
  emitCond e1 then_id
  emitCond e2 then_id
emitCond (e1 `BoolAnd` e2) then_id = do
1195
        -- we'd like to invert one of the conditionals here to avoid an
Simon Marlow's avatar
untab    
Simon Marlow committed
1196
1197
1198
        -- extra branch instruction, but we can't use maybeInvertComparison
        -- here because we can't look too closely at the expression since
        -- we're in a loop.
1199
1200
  and_id <- newBlockId
  else_id <- newBlockId
1201
  emitCond e1 and_id
1202
1203
  emit (mkBranch else_id)
  emitLabel and_id
1204
  emitCond e2 then_id
1205
  emitLabel else_id
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217


-- -----------------------------------------------------------------------------
-- Table jumps

-- We use a simplified form of C-- switch statements for now.  A
-- switch statement always compiles to a table jump.  Each arm can
-- specify a list of values (not ranges), and there can be a single
-- default branch.  The range of the table is given either by the
-- optional range on the switch (eg. switch [0..7] {...}), or by
-- the minimum/maximum values from the branches.

1218
1219
doSwitch :: Maybe (Int,Int) -> CmmParse CmmExpr -> [([Int],Either BlockId (CmmParse ()))]
         -> Maybe (CmmParse ()) -> CmmParse ()
1220
doSwitch mb_range scrut arms deflt
1221
   = do
Simon Marlow's avatar
untab    
Simon Marlow committed
1222
1223
1224
1225
        -- Compile code for the default branch
        dflt_entry <- 
                case deflt of
                  Nothing -> return Nothing
1226
1227
                  Just e  -> do b <- forkLabelledCode e; return (Just b)

Simon Marlow's avatar
untab    
Simon Marlow committed
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
        -- Compile each case branch
        table_entries <- mapM emitArm arms

        -- Construct the table
        let
            all_entries = concat table_entries
            ixs = map fst all_entries
            (min,max) 
                | Just (l,u) <- mb_range = (l,u)
                | otherwise              = (minimum ixs, maximum ixs)

            entries = elems (accumArray (\_ a -> Just a) dflt_entry (min,max)
                                all_entries)
        expr <- scrut
        -- ToDo: check for out of range and jump to default if necessary
1243
        emit (mkSwitch expr entries)
1244
   where
1245
        emitArm :: ([Int],Either BlockId (CmmParse ())) -> CmmParse [(Int,BlockId)]
Simon Marlow's avatar
untab    
Simon Marlow committed
1246
1247
        emitArm (ints,Left blockid) = return [ (i,blockid) | i <- ints ]
        emitArm (ints,Right code) = do
1248
           blockid <- forkLabelledCode code
Simon Marlow's avatar
untab    
Simon Marlow committed
1249
           return [ (i,blockid) | i <- ints ]
1250
1251
1252
1253
1254
1255
1256

forkLabelledCode :: CmmParse () -> CmmParse BlockId
forkLabelledCode p = do
  ag <- getCode p
  l <- newBlockId
  emitOutOfLine l ag
  return l
1257
1258
1259
1260
1261
1262

-- -----------------------------------------------------------------------------
-- Putting it all together

-- The initial environment: we define some constants that the compiler
-- knows about here.
1263
1264
initEnv :: DynFlags -> Env
initEnv dflags = listToUFM [
1265
  ( fsLit "SIZEOF_StgHeader",
1266
    VarN (CmmLit (CmmInt (fromIntegral (fixedHdrSize dflags * wORD_SIZE dflags)) (wordWidth dflags)) )),
Ian Lynagh's avatar
Ian Lynagh committed
1267
  ( fsLit "SIZEOF_StgInfoTable",
1268
    VarN (CmmLit (CmmInt (fromIntegral (stdInfoTableSizeB dflags)) (wordWidth dflags)) ))
1269
1270
  ]

Simon Peyton Jones's avatar
Simon Peyton Jones committed
1271
parseCmmFile :: DynFlags -> FilePath -> IO (Messages, Maybe CmmGroup)
Simon Marlow's avatar
Simon Marlow committed
1272
parseCmmFile dflags filename = do
1273
1274
1275
  showPass dflags "ParseCmm"
  buf <- hGetStringBuffer filename
  let
1276
1277
1278
1279
        init_loc = mkRealSrcLoc (mkFastString filename) 1 1
        init_state = (mkPState dflags buf init_loc) { lex_state = [0] }
                -- reset the lex_state: the Lexer monad leaves some stuff
                -- in there we don't want.
1280
  case unP cmmParse init_state of
1281
    PFailed span err -> do
Ian Lynagh's avatar
Ian Lynagh committed
1282
        let msg = mkPlainErrMsg dflags span err
1283
        return ((emptyBag, unitBag msg), Nothing)
1284
    POk pst code -> do
1285
        st <- initC
1286
        let (cmm,_) = runC dflags no_module st (getCmm (unEC code (initEnv dflags) [] >> return ()))
1287
1288
1289
1290
        let ms = getMessages pst
        if (errorsFound dflags ms)
         then return (ms, Nothing)
         else do
Ian Lynagh's avatar
Ian Lynagh committed
1291
           dumpIfSet_dyn dflags Opt_D_dump_cmm "Cmm" (ppr cmm)
1292
           return (ms, Just cmm)
1293
  where
1294
        no_module = panic "parseCmmFile: no module"
1295
}