Matthew Pickering pushed to branch wip/26507 at Glasgow Haskell Compiler / GHC

Commits:

5 changed files:

Changes:

  • libraries/ghc-internal/cbits/Stack_c.c
    ... ... @@ -9,13 +9,13 @@
    9 9 
     #include "rts/storage/InfoTables.h"
    10 10
    11 11 
     StgWord stackFrameSize(StgStack *stack, StgWord offset) {
    12 
    -  StgClosure *c = (StgClosure *)stack->sp + offset;
    12 
    +  StgClosure *c = (StgClosure *)(stack->sp + offset);
    13 13 
       ASSERT(LOOKS_LIKE_CLOSURE_PTR(c));
    14 14 
       return stack_frame_sizeW(c);
    15 15 
     }
    16 16
    17 17 
     StgStack *getUnderflowFrameStack(StgStack *stack, StgWord offset) {
    18 
    -  StgClosure *frame = (StgClosure *)stack->sp + offset;
    18 
    +  StgClosure *frame = (StgClosure *)(stack->sp + offset);
    19 19 
       ASSERT(LOOKS_LIKE_CLOSURE_PTR(frame));
    20 20 
       const StgRetInfoTable *info = get_ret_itbl((StgClosure *)frame);
    21 21

  • libraries/ghc-internal/ghc-internal.cabal.in
    ... ... @@ -299,6 +299,7 @@ Library
    299 299 
             GHC.Internal.Stack.CCS
    300 300 
             GHC.Internal.Stack.CloneStack
    301 301 
             GHC.Internal.Stack.Constants
    302 
    +        GHC.Internal.Stack.ConstantsProf
    302 303 
             GHC.Internal.Stack.Decode
    303 304 
             GHC.Internal.Stack.Types
    304 305 
             GHC.Internal.Stats

  • libraries/ghc-internal/src/GHC/Internal/Stack/ConstantsProf.hsc
    1 
    +{-# LANGUAGE CPP #-}
    2 
    +{-# LANGUAGE DerivingStrategies #-}
    3 
    +{-# LANGUAGE GeneralizedNewtypeDeriving #-}
    4 
    +module GHC.Internal.Stack.ConstantsProf where
    5 
    +
    6 
    +import GHC.Internal.Base
    7 
    +import GHC.Internal.Enum
    8 
    +import GHC.Internal.Num
    9 
    +import GHC.Internal.Show
    10 
    +import GHC.Internal.Real
    11 
    +
    12 
    +#define PROFILING
    13 
    +#include "Rts.h"
    14 
    +#undef BLOCK_SIZE
    15 
    +#undef MBLOCK_SIZE
    16 
    +#undef BLOCKS_PER_MBLOCK
    17 
    +#include "DerivedConstants.h"
    18 
    +
    19 
    +newtype ByteOffset = ByteOffset { offsetInBytes :: Int }
    20 
    +  deriving newtype (Eq, Show, Integral, Real, Num, Enum, Ord)
    21 
    +
    22 
    +newtype WordOffset = WordOffset { offsetInWords :: Int }
    23 
    +  deriving newtype (Eq, Show, Integral, Real, Num, Enum, Ord)
    24 
    +
    25 
    +offsetStgCatchFrameHandler :: WordOffset
    26 
    +offsetStgCatchFrameHandler = byteOffsetToWordOffset $
    27 
    +  (#const OFFSET_StgCatchFrame_handler) + (#size StgHeader)
    28 
    +
    29 
    +sizeStgCatchFrame :: Int
    30 
    +sizeStgCatchFrame = bytesToWords $
    31 
    +  (#const SIZEOF_StgCatchFrame_NoHdr) + (#size StgHeader)
    32 
    +
    33 
    +offsetStgCatchSTMFrameCode :: WordOffset
    34 
    +offsetStgCatchSTMFrameCode = byteOffsetToWordOffset $
    35 
    +  (#const OFFSET_StgCatchSTMFrame_code) + (#size StgHeader)
    36 
    +
    37 
    +offsetStgCatchSTMFrameHandler :: WordOffset
    38 
    +offsetStgCatchSTMFrameHandler = byteOffsetToWordOffset $
    39 
    +  (#const OFFSET_StgCatchSTMFrame_handler) + (#size StgHeader)
    40 
    +
    41 
    +sizeStgCatchSTMFrame :: Int
    42 
    +sizeStgCatchSTMFrame = bytesToWords $
    43 
    +  (#const SIZEOF_StgCatchSTMFrame_NoHdr) + (#size StgHeader)
    44 
    +
    45 
    +offsetStgUpdateFrameUpdatee :: WordOffset
    46 
    +offsetStgUpdateFrameUpdatee = byteOffsetToWordOffset $
    47 
    +  (#const OFFSET_StgUpdateFrame_updatee) + (#size StgHeader)
    48 
    +
    49 
    +sizeStgUpdateFrame :: Int
    50 
    +sizeStgUpdateFrame = bytesToWords $
    51 
    +  (#const SIZEOF_StgUpdateFrame_NoHdr) + (#size StgHeader)
    52 
    +
    53 
    +offsetStgAtomicallyFrameCode :: WordOffset
    54 
    +offsetStgAtomicallyFrameCode = byteOffsetToWordOffset $
    55 
    +  (#const OFFSET_StgAtomicallyFrame_code) + (#size StgHeader)
    56 
    +
    57 
    +offsetStgAtomicallyFrameResult :: WordOffset
    58 
    +offsetStgAtomicallyFrameResult = byteOffsetToWordOffset $
    59 
    +  (#const OFFSET_StgAtomicallyFrame_result) + (#size StgHeader)
    60 
    +
    61 
    +sizeStgAtomicallyFrame :: Int
    62 
    +sizeStgAtomicallyFrame = bytesToWords $
    63 
    +  (#const SIZEOF_StgAtomicallyFrame_NoHdr) + (#size StgHeader)
    64 
    +
    65 
    +offsetStgCatchRetryFrameRunningAltCode :: WordOffset
    66 
    +offsetStgCatchRetryFrameRunningAltCode = byteOffsetToWordOffset $
    67 
    +  (#const OFFSET_StgCatchRetryFrame_running_alt_code) + (#size StgHeader)
    68 
    +
    69 
    +offsetStgCatchRetryFrameRunningFirstCode :: WordOffset
    70 
    +offsetStgCatchRetryFrameRunningFirstCode = byteOffsetToWordOffset $
    71 
    +  (#const OFFSET_StgCatchRetryFrame_first_code) + (#size StgHeader)
    72 
    +
    73 
    +offsetStgCatchRetryFrameAltCode :: WordOffset
    74 
    +offsetStgCatchRetryFrameAltCode = byteOffsetToWordOffset $
    75 
    +  (#const OFFSET_StgCatchRetryFrame_alt_code) + (#size StgHeader)
    76 
    +
    77 
    +sizeStgCatchRetryFrame :: Int
    78 
    +sizeStgCatchRetryFrame = bytesToWords $
    79 
    +  (#const SIZEOF_StgCatchRetryFrame_NoHdr) + (#size StgHeader)
    80 
    +
    81 
    +offsetStgRetFunFrameSize :: WordOffset
    82 
    +-- StgRetFun has no header, but only a pointer to the info table at the beginning.
    83 
    +offsetStgRetFunFrameSize = byteOffsetToWordOffset (#const OFFSET_StgRetFun_size)
    84 
    +
    85 
    +offsetStgRetFunFrameFun :: WordOffset
    86 
    +offsetStgRetFunFrameFun = byteOffsetToWordOffset (#const OFFSET_StgRetFun_fun)
    87 
    +
    88 
    +offsetStgRetFunFramePayload :: WordOffset
    89 
    +offsetStgRetFunFramePayload = byteOffsetToWordOffset (#const OFFSET_StgRetFun_payload)
    90 
    +
    91 
    +sizeStgRetFunFrame :: Int
    92 
    +sizeStgRetFunFrame = bytesToWords (#const SIZEOF_StgRetFun)
    93 
    +
    94 
    +sizeStgAnnFrame :: Int
    95 
    +sizeStgAnnFrame = bytesToWords $
    96 
    +  (#const SIZEOF_StgAnnFrame_NoHdr) + (#size StgHeader)
    97 
    +
    98 
    +offsetStgAnnFrameAnn :: WordOffset
    99 
    +offsetStgAnnFrameAnn = byteOffsetToWordOffset $
    100 
    +  (#const OFFSET_StgAnnFrame_ann) + (#size StgHeader)
    101 
    +
    102 
    +offsetStgBCOFrameInstrs :: ByteOffset
    103 
    +offsetStgBCOFrameInstrs = (#const OFFSET_StgBCO_instrs) + (#size StgHeader)
    104 
    +
    105 
    +offsetStgBCOFrameLiterals :: ByteOffset
    106 
    +offsetStgBCOFrameLiterals = (#const OFFSET_StgBCO_literals) + (#size StgHeader)
    107 
    +
    108 
    +offsetStgBCOFramePtrs :: ByteOffset
    109 
    +offsetStgBCOFramePtrs = (#const OFFSET_StgBCO_ptrs) + (#size StgHeader)
    110 
    +
    111 
    +offsetStgBCOFrameArity :: ByteOffset
    112 
    +offsetStgBCOFrameArity = (#const OFFSET_StgBCO_arity) + (#size StgHeader)
    113 
    +
    114 
    +offsetStgBCOFrameSize :: ByteOffset
    115 
    +offsetStgBCOFrameSize = (#const OFFSET_StgBCO_size) + (#size StgHeader)
    116 
    +
    117 
    +offsetStgClosurePayload :: WordOffset
    118 
    +offsetStgClosurePayload = byteOffsetToWordOffset $
    119 
    +  (#const OFFSET_StgClosure_payload) + (#size StgHeader)
    120 
    +
    121 
    +sizeStgClosure :: Int
    122 
    +sizeStgClosure = bytesToWords (#size StgHeader)
    123 
    +
    124 
    +byteOffsetToWordOffset :: ByteOffset -> WordOffset
    125 
    +byteOffsetToWordOffset = WordOffset . bytesToWords . fromInteger . toInteger
    126 
    +
    127 
    +bytesToWords :: Int -> Int
    128 
    +bytesToWords b =
    129 
    +  if b `mod` bytesInWord == 0 then
    130 
    +      fromIntegral $ b `div` bytesInWord
    131 
    +    else
    132 
    +      error "Unexpected struct alignment!"
    133 
    +
    134 
    +bytesInWord :: Int
    135 
    +bytesInWord = (#const SIZEOF_VOID_P)
    136 
    +

  • libraries/ghc-internal/src/GHC/Internal/Stack/Decode.hs
    ... ... @@ -54,9 +54,18 @@ import GHC.Internal.Heap.Closures
    54 54 
         GenStackField(..)
    55 55 
       )
    56 56 
     import GHC.Internal.Heap.Constants (wORD_SIZE_IN_BITS)
    57 
    -import GHC.Internal.Heap.InfoTable
    58 57 
     import GHC.Internal.Stack.Annotation
    58 
    +#if defined(PROFILING)
    59 
    +import GHC.Internal.Stack.Constants ()
    60 
    +import GHC.Internal.Stack.ConstantsProf
    61 
    +import GHC.Internal.Heap.InfoTable ()
    62 
    +import GHC.Internal.Heap.InfoTableProf
    63 
    +#else
    64 
    +import GHC.Internal.Heap.InfoTable
    65 
    +import GHC.Internal.Heap.InfoTableProf ()
    59 66 
     import GHC.Internal.Stack.Constants
    67 
    +import GHC.Internal.Stack.ConstantsProf ()
    68 
    +#endif
    60 69 
     import GHC.Internal.Stack.CloneStack
    61 70 
     import GHC.Internal.InfoProv.Types (InfoProv (..), ipLoc, lookupIPE)
    62 71

  • libraries/ghc-internal/tests/stack-annotation/all.T
    1 1 
     # Javascript backend don't support annotation frames, yet
    2 2 
     setTestOpts(when(js_arch(), skip))
    3 3
    4 
    -test('ann_frame001', [extra_files(['TestUtils.hs'])], compile_and_run, [''])
    4 
    +test('ann_frame001', [when(have_profiling(), extra_ways(['prof'])), extra_files(['TestUtils.hs'])], compile_and_run, [''])
    5 5 
     test('ann_frame002', [extra_files(['TestUtils.hs'])], compile_and_run, [''])
    6 6 
     test('ann_frame003', [extra_files(['TestUtils.hs'])], compile_and_run, [''])
    7 7 
     test('ann_frame004', [extra_files(['TestUtils.hs'])], compile_and_run, [''])

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.haskell.org. Manage all notifications · Help