X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FcodeGen%2FCgUtils.hs;h=2f69927db00e7c891057d35854ce0a579ea69751;hb=9d7da331989abcd1844e9d03b8d1e4163796fa85;hp=414e90a91adf290ad230576199d306c1709f8418;hpb=a609df425d10b6d5e87cf43d01b4c2cd83551fbb;p=ghc-hetmet.git diff --git a/ghc/compiler/codeGen/CgUtils.hs b/ghc/compiler/codeGen/CgUtils.hs index 414e90a..2f69927 100644 --- a/ghc/compiler/codeGen/CgUtils.hs +++ b/ghc/compiler/codeGen/CgUtils.hs @@ -45,24 +45,23 @@ import CLabel import CmmUtils import MachOp ( MachRep(..), wordRep, MachOp(..), MachHint(..), mo_wordOr, mo_wordAnd, mo_wordNe, mo_wordEq, - mo_wordULt, mo_wordUGt, machRepByteWidth ) + mo_wordULt, mo_wordUGt, mo_wordUGe, machRepByteWidth ) import ForeignCall ( CCallConv(..) ) import Literal ( Literal(..) ) import CLabel ( CLabel, mkStringLitLabel ) import Digraph ( SCC(..), stronglyConnComp ) import ListSetOps ( assocDefault ) import Util ( filterOut, sortLe ) -import CmdLineOpts ( DynFlags ) -import FastString ( LitString, FastString, unpackFS ) +import DynFlags ( DynFlags(..), HscTarget(..) ) +import Packages ( HomeModules ) +import FastString ( LitString, FastString, bytesFS ) import Outputable import Char ( ord ) import DATA_BITS +import DATA_WORD ( Word8 ) import Maybe ( isNothing ) -#include "../includes/ghcconfig.h" - -- For WORDS_BIGENDIAN - ------------------------------------------------------------------------- -- -- Random small functions @@ -79,7 +78,8 @@ addIdReps ids = [(idCgRep id, id) | id <- ids] ------------------------------------------------------------------------- cgLit :: Literal -> FCode CmmLit -cgLit (MachStr s) = mkStringCLit (unpackFS s) +cgLit (MachStr s) = mkByteStringCLit (bytesFS s) + -- not unpackFS; we want the UTF-8 byte stream. cgLit other_lit = return (mkSimpleLit other_lit) mkSimpleLit :: Literal -> CmmLit @@ -156,6 +156,7 @@ cmmAndWord e1 e2 = CmmMachOp mo_wordAnd [e1, e2] cmmNeWord e1 e2 = CmmMachOp mo_wordNe [e1, e2] cmmEqWord e1 e2 = CmmMachOp mo_wordEq [e1, e2] cmmULtWord e1 e2 = CmmMachOp mo_wordULt [e1, e2] +cmmUGeWord e1 e2 = CmmMachOp mo_wordUGe [e1, e2] cmmUGtWord e1 e2 = CmmMachOp mo_wordUGt [e1, e2] cmmNegate :: CmmExpr -> CmmExpr @@ -212,11 +213,11 @@ addToMemE rep ptr n -- ------------------------------------------------------------------------- -tagToClosure :: DynFlags -> TyCon -> CmmExpr -> CmmExpr -tagToClosure dflags tycon tag +tagToClosure :: HomeModules -> TyCon -> CmmExpr -> CmmExpr +tagToClosure hmods tycon tag = CmmLoad (cmmOffsetExprW closure_tbl tag) wordRep where closure_tbl = CmmLit (CmmLabel lbl) - lbl = mkClosureTableLabel dflags (tyConName tycon) + lbl = mkClosureTableLabel hmods (tyConName tycon) ------------------------------------------------------------------------- -- @@ -299,15 +300,23 @@ emitDataLits lbl lits emitRODataLits :: CLabel -> [CmmLit] -> Code -- Emit a read-only data block emitRODataLits lbl lits - = emitData ReadOnlyData (CmmDataLabel lbl : map CmmStaticLit lits) + = emitData section (CmmDataLabel lbl : map CmmStaticLit lits) + where section | any needsRelocation lits = RelocatableReadOnlyData + | otherwise = ReadOnlyData + needsRelocation (CmmLabel _) = True + needsRelocation (CmmLabelOff _ _) = True + needsRelocation _ = False mkStringCLit :: String -> FCode CmmLit -- Make a global definition for the string, -- and return its label -mkStringCLit str +mkStringCLit str = mkByteStringCLit (map (fromIntegral.ord) str) + +mkByteStringCLit :: [Word8] -> FCode CmmLit +mkByteStringCLit bytes = do { uniq <- newUnique ; let lbl = mkStringLitLabel uniq - ; emitData ReadOnlyData [CmmDataLabel lbl, CmmString str] + ; emitData ReadOnlyData [CmmDataLabel lbl, CmmString bytes] ; return (CmmLabel lbl) } ------------------------------------------------------------------------- @@ -356,8 +365,12 @@ emitSwitch tag_expr branches mb_deflt lo_tag hi_tag Nothing -> return Nothing Just stmts -> do id <- forkCgStmts stmts; return (Just id) + ; dflags <- getDynFlags + ; let via_C | HscC <- hscTarget dflags = True + | otherwise = False + ; stmts <- mk_switch tag_expr (sortLe le branches) - mb_deflt_id lo_tag hi_tag + mb_deflt_id lo_tag hi_tag via_C ; emitCgStmts stmts } where @@ -365,17 +378,17 @@ emitSwitch tag_expr branches mb_deflt lo_tag hi_tag mk_switch :: CmmExpr -> [(ConTagZ, CgStmts)] - -> Maybe BlockId -> ConTagZ -> ConTagZ + -> Maybe BlockId -> ConTagZ -> ConTagZ -> Bool -> FCode CgStmts -- SINGLETON TAG RANGE: no case analysis to do -mk_switch tag_expr [(tag,stmts)] _ lo_tag hi_tag +mk_switch tag_expr [(tag,stmts)] _ lo_tag hi_tag via_C | lo_tag == hi_tag = ASSERT( tag == lo_tag ) return stmts -- SINGLETON BRANCH, NO DEFUALT: no case analysis to do -mk_switch tag_expr [(tag,stmts)] Nothing lo_tag hi_tag +mk_switch tag_expr [(tag,stmts)] Nothing lo_tag hi_tag via_C = return stmts -- The simplifier might have eliminated a case -- so we may have e.g. case xs of @@ -384,7 +397,7 @@ mk_switch tag_expr [(tag,stmts)] Nothing lo_tag hi_tag -- can't happen, so no need to test -- SINGLETON BRANCH: one equality check to do -mk_switch tag_expr [(tag,stmts)] (Just deflt) lo_tag hi_tag +mk_switch tag_expr [(tag,stmts)] (Just deflt) lo_tag hi_tag via_C = return (CmmCondBranch cond deflt `consCgStmt` stmts) where cond = cmmNeWord tag_expr (CmmLit (mkIntCLit tag)) @@ -395,8 +408,16 @@ mk_switch tag_expr [(tag,stmts)] (Just deflt) lo_tag hi_tag -- the branches is the tag 0, because comparing '== 0' is likely to be -- more efficient than other kinds of comparison. --- DENSE TAG RANGE: use a switch statment -mk_switch tag_expr branches mb_deflt lo_tag hi_tag +-- DENSE TAG RANGE: use a switch statment. +-- +-- We also use a switch uncoditionally when compiling via C, because +-- this will get emitted as a C switch statement and the C compiler +-- should do a good job of optimising it. Also, older GCC versions +-- (2.95 in particular) have problems compiling the complicated +-- if-trees generated by this code, so compiling to a switch every +-- time works around that problem. +-- +mk_switch tag_expr branches mb_deflt lo_tag hi_tag via_C | use_switch -- Use a switch = do { branch_ids <- mapM forkCgStmts (map snd branches) ; let @@ -421,7 +442,8 @@ mk_switch tag_expr branches mb_deflt lo_tag hi_tag = do { (assign_tag, tag_expr') <- assignTemp' tag_expr ; let cond = cmmULtWord tag_expr' (CmmLit (mkIntCLit lowest_branch)) branch = CmmCondBranch cond deflt - ; stmts <- mk_switch tag_expr' branches mb_deflt lowest_branch hi_tag + ; stmts <- mk_switch tag_expr' branches mb_deflt + lowest_branch hi_tag via_C ; return (assign_tag `consCgStmt` (branch `consCgStmt` stmts)) } @@ -429,26 +451,40 @@ mk_switch tag_expr branches mb_deflt lo_tag hi_tag = do { (assign_tag, tag_expr') <- assignTemp' tag_expr ; let cond = cmmUGtWord tag_expr' (CmmLit (mkIntCLit highest_branch)) branch = CmmCondBranch cond deflt - ; stmts <- mk_switch tag_expr' branches mb_deflt lo_tag highest_branch + ; stmts <- mk_switch tag_expr' branches mb_deflt + lo_tag highest_branch via_C ; return (assign_tag `consCgStmt` (branch `consCgStmt` stmts)) } | otherwise -- Use an if-tree = do { (assign_tag, tag_expr') <- assignTemp' tag_expr -- To avoid duplication - ; lo_stmts <- mk_switch tag_expr' lo_branches mb_deflt lo_tag (mid_tag-1) - ; hi_stmts <- mk_switch tag_expr' hi_branches mb_deflt mid_tag hi_tag - ; lo_id <- forkCgStmts lo_stmts - ; let cond = cmmULtWord tag_expr' (CmmLit (mkIntCLit mid_tag)) - branch_stmt = CmmCondBranch cond lo_id - ; return (assign_tag `consCgStmt` (branch_stmt `consCgStmt` hi_stmts)) + ; lo_stmts <- mk_switch tag_expr' lo_branches mb_deflt + lo_tag (mid_tag-1) via_C + ; hi_stmts <- mk_switch tag_expr' hi_branches mb_deflt + mid_tag hi_tag via_C + ; hi_id <- forkCgStmts hi_stmts + ; let cond = cmmUGeWord tag_expr' (CmmLit (mkIntCLit mid_tag)) + branch_stmt = CmmCondBranch cond hi_id + ; return (assign_tag `consCgStmt` (branch_stmt `consCgStmt` lo_stmts)) } + -- we test (e >= mid_tag) rather than (e < mid_tag), because + -- the former works better when e is a comparison, and there + -- are two tags 0 & 1 (mid_tag == 1). In this case, the code + -- generator can reduce the condition to e itself without + -- having to reverse the sense of the comparison: comparisons + -- can't always be easily reversed (eg. floating + -- pt. comparisons). where - use_switch = ASSERT( n_branches > 1 && n_tags > 1 ) - {- pprTrace "mk_switch" (ppr tag_expr <+> text "n_tags: " - <+> int n_tags <+> text "dense: " - <+> int n_branches) $ -} - n_tags > 2 && (small || dense) + use_switch = {- pprTrace "mk_switch" ( + ppr tag_expr <+> text "n_tags:" <+> int n_tags <+> + text "n_branches:" <+> int n_branches <+> + text "lo_tag: " <+> int lo_tag <+> + text "hi_tag: " <+> int hi_tag <+> + text "real_lo_tag: " <+> int real_lo_tag <+> + text "real_hi_tag: " <+> int real_hi_tag) $ -} + ASSERT( n_branches > 1 && n_tags > 1 ) + n_tags > 2 && (small || dense || via_C) -- a 2-branch switch always turns into an if. small = n_tags <= 4 dense = n_branches > (n_tags `div` 2)