CLabel: Refactor pprDynamicLinkerAsmLabel
[ghc.git] / compiler / cmm / CmmType.hs
index 49a2dc1..cb15dc7 100644 (file)
@@ -1,20 +1,22 @@
+{-# LANGUAGE CPP #-}
 
 module CmmType
     ( CmmType   -- Abstract
-    , b8, b16, b32, b64, b128, f32, f64, bWord, bHalfWord, gcWord
-    , cInt, cLong
+    , b8, b16, b32, b64, b128, b256, b512, f32, f64, bWord, bHalfWord, gcWord
+    , cInt
     , cmmBits, cmmFloat
     , typeWidth, cmmEqType, cmmEqType_ignoring_ptrhood
     , isFloatType, isGcPtrType, isWord32, isWord64, isFloat64, isFloat32
 
     , Width(..)
     , widthInBits, widthInBytes, widthInLog, widthFromBytes
-    , wordWidth, halfWordWidth, cIntWidth, cLongWidth
+    , wordWidth, halfWordWidth, cIntWidth
     , halfWordMask
     , narrowU, narrowS
     , rEP_CostCentreStack_mem_alloc
     , rEP_CostCentreStack_scc_count
     , rEP_StgEntCounter_allocs
+    , rEP_StgEntCounter_allocd
 
     , ForeignHint(..)
 
@@ -29,6 +31,8 @@ where
 
 #include "HsVersions.h"
 
+import GhcPrelude
+
 import DynFlags
 import FastString
 import Outputable
@@ -61,9 +65,9 @@ instance Outputable CmmType where
   ppr (CmmType cat wid) = ppr cat <> ppr (widthInBits wid)
 
 instance Outputable CmmCat where
-  ppr FloatCat       = ptext $ sLit("F")
-  ppr GcPtrCat       = ptext $ sLit("P")
-  ppr BitsCat        = ptext $ sLit("I")
+  ppr FloatCat       = text "F"
+  ppr GcPtrCat       = text "P"
+  ppr BitsCat        = text "I"
   ppr (VecCat n cat) = ppr cat <> text "x" <> ppr n <> text "V"
 
 -- Why is CmmType stratified?  For native code generation,
@@ -106,12 +110,14 @@ cmmFloat = CmmType FloatCat
 
 -------- Common CmmTypes ------------
 -- Floats and words of specific widths
-b8, b16, b32, b64, b128, f32, f64 :: CmmType
+b8, b16, b32, b64, b128, b256, b512, f32, f64 :: CmmType
 b8     = cmmBits W8
 b16    = cmmBits W16
 b32    = cmmBits W32
 b64    = cmmBits W64
 b128   = cmmBits W128
+b256   = cmmBits W256
+b512   = cmmBits W512
 f32    = cmmFloat W32
 f64    = cmmFloat W64
 
@@ -125,10 +131,8 @@ bHalfWord dflags = cmmBits (halfWordWidth dflags)
 gcWord :: DynFlags -> CmmType
 gcWord dflags = CmmType GcPtrCat (wordWidth dflags)
 
-cInt, cLong :: DynFlags -> CmmType
-cInt  dflags = cmmBits (cIntWidth  dflags)
-cLong dflags = cmmBits (cLongWidth dflags)
-
+cInt :: DynFlags -> CmmType
+cInt dflags = cmmBits (cIntWidth  dflags)
 
 ------------ Predicates ----------------
 isFloatType, isGcPtrType :: CmmType -> Bool
@@ -165,6 +169,8 @@ data Width   = W8 | W16 | W32 | W64
                         -- used in x86 native codegen only.
                         -- (we use Ord, so it'd better be in this order)
              | W128
+             | W256
+             | W512
              deriving (Eq, Ord, Show)
 
 instance Outputable Width where
@@ -176,6 +182,8 @@ mrStr W16  = sLit("W16")
 mrStr W32  = sLit("W32")
 mrStr W64  = sLit("W64")
 mrStr W128 = sLit("W128")
+mrStr W256 = sLit("W256")
+mrStr W512 = sLit("W512")
 mrStr W80  = sLit("W80")
 
 
@@ -199,15 +207,11 @@ halfWordMask dflags
  | otherwise             = panic "MachOp.halfWordMask: Unknown word size"
 
 -- cIntRep is the Width for a C-language 'int'
-cIntWidth, cLongWidth :: DynFlags -> Width
+cIntWidth :: DynFlags -> Width
 cIntWidth dflags = case cINT_SIZE dflags of
                    4 -> W32
                    8 -> W64
                    s -> panic ("cIntWidth: Unknown cINT_SIZE: " ++ show s)
-cLongWidth dflags = case cLONG_SIZE dflags of
-                    4 -> W32
-                    8 -> W64
-                    s -> panic ("cIntWidth: Unknown cLONG_SIZE: " ++ show s)
 
 widthInBits :: Width -> Int
 widthInBits W8   = 8
@@ -215,6 +219,8 @@ widthInBits W16  = 16
 widthInBits W32  = 32
 widthInBits W64  = 64
 widthInBits W128 = 128
+widthInBits W256 = 256
+widthInBits W512 = 512
 widthInBits W80  = 80
 
 widthInBytes :: Width -> Int
@@ -223,6 +229,8 @@ widthInBytes W16  = 2
 widthInBytes W32  = 4
 widthInBytes W64  = 8
 widthInBytes W128 = 16
+widthInBytes W256 = 32
+widthInBytes W512 = 64
 widthInBytes W80  = 10
 
 widthFromBytes :: Int -> Width
@@ -231,6 +239,8 @@ widthFromBytes 2  = W16
 widthFromBytes 4  = W32
 widthFromBytes 8  = W64
 widthFromBytes 16 = W128
+widthFromBytes 32 = W256
+widthFromBytes 64 = W512
 widthFromBytes 10 = W80
 widthFromBytes n  = pprPanic "no width for given number of bytes" (ppr n)
 
@@ -241,6 +251,8 @@ widthInLog W16  = 1
 widthInLog W32  = 2
 widthInLog W64  = 3
 widthInLog W128 = 4
+widthInLog W256 = 5
+widthInLog W512 = 6
 widthInLog W80  = panic "widthInLog: F80"
 
 -- widening / narrowing
@@ -337,6 +349,11 @@ rEP_StgEntCounter_allocs dflags
     = cmmBits (widthFromBytes (pc_REP_StgEntCounter_allocs pc))
     where pc = sPlatformConstants (settings dflags)
 
+rEP_StgEntCounter_allocd :: DynFlags -> CmmType
+rEP_StgEntCounter_allocd dflags
+    = cmmBits (widthFromBytes (pc_REP_StgEntCounter_allocd pc))
+    where pc = sPlatformConstants (settings dflags)
+
 -------------------------------------------------------------------------
 {-      Note [Signed vs unsigned]
         ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -415,7 +432,7 @@ Cons:
 
 Currently for GHC, the foreign call point is moot, because we do our
 own promotion of sub-word-sized values to word-sized values.  The Int8
-type is represnted by an Int# which is kept sign-extended at all times
+type is represented by an Int# which is kept sign-extended at all times
 (this is slightly naughty, because we're making assumptions about the
 C calling convention rather early on in the compiler).  However, given
 this, the cons outweigh the pros.