[Git][ghc/ghc][wip/decode_cloned_stack] 2 commits: Same test with prims (small bitmap)
Sven Tennie (@supersven)
gitlab at gitlab.haskell.org
Tue Dec 27 19:31:01 UTC 2022
Sven Tennie pushed to branch wip/decode_cloned_stack at Glasgow Haskell Compiler / GHC
Commits:
1b45c8c6 by Sven Tennie at 2022-12-27T12:07:00+00:00
Same test with prims (small bitmap)
- - - - -
17902c75 by Sven Tennie at 2022-12-27T19:30:37+00:00
Make test GC safe
- - - - -
3 changed files:
- libraries/ghc-heap/tests/stack_misc_closures.hs
- libraries/ghc-heap/tests/stack_misc_closures_c.c
- libraries/ghc-heap/tests/stack_misc_closures_prim.cmm
Changes:
=====================================
libraries/ghc-heap/tests/stack_misc_closures.hs
=====================================
@@ -21,49 +21,62 @@ import GHC.Stack.CloneStack (StackSnapshot (..))
import TestUtils
import Unsafe.Coerce (unsafeCoerce)
import GHC.Exts.Heap (GenClosure(wordVal))
+import System.Mem
+import Debug.Trace
+import GHC.IO (IO (..))
-foreign import prim "any_update_framezh" any_update_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_update_framezh" any_update_frame# :: SetupFunction
-foreign import prim "any_catch_framezh" any_catch_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_catch_framezh" any_catch_frame# :: SetupFunction
-foreign import prim "any_catch_stm_framezh" any_catch_stm_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_catch_stm_framezh" any_catch_stm_frame# :: SetupFunction
-foreign import prim "any_catch_retry_framezh" any_catch_retry_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_catch_retry_framezh" any_catch_retry_frame# :: SetupFunction
-foreign import prim "any_atomically_framezh" any_atomically_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_atomically_framezh" any_atomically_frame# :: SetupFunction
-foreign import prim "any_ret_small_prim_framezh" any_ret_small_prim_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_ret_small_prim_framezh" any_ret_small_prim_frame# :: SetupFunction
-foreign import prim "any_ret_small_closure_framezh" any_ret_small_closure_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_ret_small_prims_framezh" any_ret_small_prims_frame# :: SetupFunction
-foreign import prim "any_ret_small_closures_framezh" any_ret_small_closures_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_ret_small_closure_framezh" any_ret_small_closure_frame# :: SetupFunction
-foreign import prim "any_ret_big_prims_framezh" any_ret_big_prims_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_ret_small_closures_framezh" any_ret_small_closures_frame# :: SetupFunction
-foreign import prim "any_ret_big_closures_framezh" any_ret_big_closures_frame# :: Word# -> (# StackSnapshot# #)
+foreign import prim "any_ret_big_prims_framezh" any_ret_big_prims_frame# :: SetupFunction
+
+foreign import prim "any_ret_big_prim_framezh" any_ret_big_prim_frame# :: SetupFunction
+
+foreign import prim "any_ret_big_closures_framezh" any_ret_big_closures_frame# :: SetupFunction
foreign import ccall "maxSmallBitmapBits" maxSmallBitmapBits_c :: Word
+foreign import ccall "belchStack" belchStack# :: StackSnapshot# -> IO ()
+
main :: HasCallStack => IO ()
main = do
+ traceM "test any_update_frame#"
test any_update_frame# 42## $
\case
UpdateFrame {..} -> do
assertEqual knownUpdateFrameType NormalUpdateFrame
- assertConstrClosure 42 =<< getBoxedClosureData updatee
+ assertEqual 42 =<< (getWordFromBlackhole =<< getBoxedClosureData updatee)
e -> error $ "Wrong closure type: " ++ show e
+ traceM "test any_catch_frame#"
test any_catch_frame# 43## $
\case
CatchFrame {..} -> do
assertEqual exceptions_blocked 1
assertConstrClosure 43 =<< getBoxedClosureData handler
e -> error $ "Wrong closure type: " ++ show e
+ traceM "test any_catch_stm_frame#"
test any_catch_stm_frame# 44## $
\case
CatchStmFrame {..} -> do
assertConstrClosure 44 =<< getBoxedClosureData catchFrameCode
assertConstrClosure 45 =<< getBoxedClosureData handler
e -> error $ "Wrong closure type: " ++ show e
+ traceM "test any_catch_retry_frame#"
test any_catch_retry_frame# 46## $
\case
CatchRetryFrame {..} -> do
@@ -71,6 +84,7 @@ main = do
assertConstrClosure 46 =<< getBoxedClosureData first_code
assertConstrClosure 47 =<< getBoxedClosureData alt_code
e -> error $ "Wrong closure type: " ++ show e
+ traceM "test any_atomically_frame#"
test any_atomically_frame# 48## $
\case
AtomicallyFrame {..} -> do
@@ -78,6 +92,7 @@ main = do
assertConstrClosure 49 =<< getBoxedClosureData result
e -> error $ "Wrong closure type: " ++ show e
-- TODO: Test for UnderflowFrame once it points to a Box payload
+ traceM "test any_ret_small_prim_frame#"
test any_ret_small_prim_frame# 50## $
\case
RetSmall {..} -> do
@@ -86,6 +101,7 @@ main = do
assertEqual (length pCs) 1
assertUnknownTypeWordSizedPrimitive 50 (head pCs)
e -> error $ "Wrong closure type: " ++ show e
+ traceM "test any_ret_small_closure_frame#"
test any_ret_small_closure_frame# 51## $
\case
RetSmall {..} -> do
@@ -94,6 +110,7 @@ main = do
assertEqual (length pCs) 1
assertConstrClosure 51 (head pCs)
e -> error $ "Wrong closure type: " ++ show e
+ traceM "test any_ret_small_closures_frame#"
test any_ret_small_closures_frame# 1## $
\case
RetSmall {..} -> do
@@ -105,17 +122,33 @@ main = do
let wds = map getWordFromConstr01 pCs
assertEqual wds [1..58]
e -> error $ "Wrong closure type: " ++ show e
- test any_ret_big_prims_frame# 52## $
+ traceM "test any_ret_small_prims_frame#"
+ test any_ret_small_prims_frame# 1## $
+ \case
+ RetSmall {..} -> do
+ assertEqual knownRetSmallType None
+ pCs <- mapM getBoxedClosureData payload
+ assertEqual (length pCs) (fromIntegral maxSmallBitmapBits_c)
+ assertUnknownTypeWordSizedPrimitive 1 (head pCs)
+ assertUnknownTypeWordSizedPrimitive 58 (last pCs)
+ let wds = map getWordFromUnknownTypeWordSizedPrimitive pCs
+ assertEqual wds [1..58]
+ e -> error $ "Wrong closure type: " ++ show e
+ traceM "test any_ret_big_prim_frame#"
+ test any_ret_big_prim_frame# 52## $
\case
RetBig {..} -> do
pCs <- mapM getBoxedClosureData payload
- assertEqual (length pCs) 1
+ assertEqual (length pCs) 59
assertUnknownTypeWordSizedPrimitive 52 (head pCs)
e -> error $ "Wrong closure type: " ++ show e
-test :: HasCallStack => (Word# -> (# StackSnapshot# #)) -> Word# -> (Closure -> IO ()) -> IO ()
+type SetupFunction = Word# -> State# RealWorld -> (# State# RealWorld, StackSnapshot# #)
+
+test :: HasCallStack => SetupFunction -> Word# -> (Closure -> IO ()) -> IO ()
test setup w assertion = do
- let sn = StackSnapshot (unboxSingletonTuple (setup w))
+ sn <- getStackSnapshot setup w
+ performGC
stack <- decodeStack' sn
assertStackInvariants sn stack
assertEqual (length stack) 2
@@ -129,6 +162,10 @@ test setup w assertion = do
assertion $ head stack
+getStackSnapshot :: SetupFunction -> Word# -> IO StackSnapshot
+getStackSnapshot action# w# = IO $ \s ->
+ case action# w# s of (# s1, stack #) -> (# s1, StackSnapshot stack #)
+
assertConstrClosure :: HasCallStack => Word -> Closure -> IO ()
assertConstrClosure w c = case c of
ConstrClosure {..} -> do
@@ -142,6 +179,16 @@ getWordFromConstr01 c = case c of
ConstrClosure {..} -> head dataArgs
e -> error $ "Wrong closure type: " ++ show e
+getWordFromBlackhole :: HasCallStack => Closure -> IO Word
+getWordFromBlackhole c = case c of
+ BlackholeClosure {..} -> getWordFromConstr01 <$> getBoxedClosureData indirectee
+ e -> error $ "Wrong closure type: " ++ show e
+
+getWordFromUnknownTypeWordSizedPrimitive :: HasCallStack => Closure -> Word
+getWordFromUnknownTypeWordSizedPrimitive c = case c of
+ UnknownTypeWordSizedPrimitive {..} -> wordVal
+ e -> error $ "Wrong closure type: " ++ show e
+
assertUnknownTypeWordSizedPrimitive :: HasCallStack => Word -> Closure -> IO ()
assertUnknownTypeWordSizedPrimitive w c = case c of
UnknownTypeWordSizedPrimitive {..} -> do
=====================================
libraries/ghc-heap/tests/stack_misc_closures_c.c
=====================================
@@ -1,6 +1,7 @@
#include "MachDeps.h"
#include "Rts.h"
#include "RtsAPI.h"
+#include "alloca.h"
#include "rts/Messages.h"
#include "rts/Types.h"
#include "rts/storage/ClosureMacros.h"
@@ -18,11 +19,18 @@ extern void printStack(StgStack *stack);
#define SIZEOF_W SIZEOF_VOID_P
#define WDS(n) ((n)*SIZEOF_W)
+// Update frames are interpreted by the garbage collector. We play it some
+// tricks here with a fake blackhole.
+RTS_RET(test_fake_blackhole);
void create_any_update_frame(Capability *cap, StgStack *stack, StgWord w) {
StgUpdateFrame *updF = (StgUpdateFrame *)stack->sp;
SET_HDR(updF, &stg_upd_frame_info, CCS_SYSTEM);
+ // StgInd and a BLACKHOLE have the same structure
+ StgInd* blackhole = allocate(cap, sizeofW(StgInd));
+ SET_HDR(blackhole, &test_fake_blackhole_info, CCS_SYSTEM);
StgClosure *payload = rts_mkWord(cap, w);
- updF->updatee = payload;
+ blackhole->indirectee = payload;
+ updF->updatee = (StgClosure*) blackhole;
}
void create_any_catch_frame(Capability *cap, StgStack *stack, StgWord w) {
@@ -81,39 +89,61 @@ void create_any_ret_small_closure_frame(Capability *cap, StgStack *stack,
#define MAX_SMALL_BITMAP_BITS (BITS_IN(W_) - BITMAP_BITS_SHIFT)
-StgWord maxSmallBitmapBits(){
- return MAX_SMALL_BITMAP_BITS;
-}
+StgWord maxSmallBitmapBits() { return MAX_SMALL_BITMAP_BITS; }
RTS_RET(test_small_ret_full_p);
void create_any_ret_small_closures_frame(Capability *cap, StgStack *stack,
- StgWord w) {
+ StgWord w) {
StgClosure *c = (StgClosure *)stack->sp;
SET_HDR(c, &test_small_ret_full_p_info, CCS_SYSTEM);
- for(int i = 0; i < MAX_SMALL_BITMAP_BITS; i++) {
- StgClosure *payload1 = rts_mkWord(cap, w);
+ for (int i = 0; i < MAX_SMALL_BITMAP_BITS; i++) {
+ StgClosure *payload1 = UNTAG_CLOSURE(rts_mkWord(cap, w));
w++;
c->payload[i] = payload1;
}
}
+RTS_RET(test_small_ret_full_n);
+void create_any_ret_small_prims_frame(Capability *cap, StgStack *stack,
+ StgWord w) {
+ StgClosure *c = (StgClosure *)stack->sp;
+ SET_HDR(c, &test_small_ret_full_n_info, CCS_SYSTEM);
+ for (int i = 0; i < MAX_SMALL_BITMAP_BITS; i++) {
+ c->payload[i] = (StgClosure *)w;
+ w++;
+ }
+}
+
+RTS_RET(test_big_ret_n);
+void create_any_ret_big_prim_frame(Capability *cap, StgStack *stack,
+ StgWord w) {
+ StgClosure *c = (StgClosure *)stack->sp;
+ SET_HDR(c, &test_big_ret_n_info, CCS_SYSTEM);
+ c->payload[0] = (StgClosure *)w;
+ debugBelch("Yolo size %lu\n", GET_LARGE_BITMAP(get_itbl(c))->size);
+ debugBelch("Yolo bitmap %lu\n", GET_LARGE_BITMAP(get_itbl(c))->bitmap[0]);
+}
+
void create_any_ret_big_prims_frame(Capability *cap, StgStack *stack,
StgWord w) {
StgClosure *c = (StgClosure *)stack->sp;
StgWord bitmapCount = 1;
StgWord memSizeInfo = sizeofW(StgRetInfoTable);
- StgWord memSizeBitmap = sizeofW(StgLargeBitmap) + bitmapCount * sizeofW(StgWord);
+ StgWord memSizeBitmap =
+ sizeofW(StgLargeBitmap) + bitmapCount * sizeofW(StgWord);
StgRetInfoTable *info = allocate(cap, memSizeInfo);
memset(info, 0, WDS(memSizeInfo));
StgLargeBitmap *largeBitmap = allocate(cap, memSizeBitmap);
memset(largeBitmap, 0, WDS(memSizeBitmap));
info->i.type = RET_BIG;
#if !defined(TABLES_NEXT_TO_CODE)
- info->i.layout.large_bitmap = largeBitmap; /* pointer to large bitmap structure */
+ info->i.layout.large_bitmap =
+ largeBitmap; /* pointer to large bitmap structure */
SET_HDR(c, info, CCS_SYSTEM);
#else
- info->i.layout.large_bitmap_offset = ((StgWord) largeBitmap) - ((StgWord) (info + 1));
- SET_HDR(c, (StgInfoTable*) info + 1 , CCS_SYSTEM);
+ info->i.layout.large_bitmap_offset =
+ ((StgWord)largeBitmap) - ((StgWord)(info + 1));
+ SET_HDR(c, (StgInfoTable *)info + 1, CCS_SYSTEM);
#endif
largeBitmap->size = 1;
largeBitmap->bitmap[0] = 1;
@@ -125,14 +155,14 @@ void create_any_ret_big_prims_frame(Capability *cap, StgStack *stack,
printStack(stack);
}
-StgStack *setup(StgWord closureSizeWords, StgWord w,
+void checkSTACK (StgStack *stack);
+StgStack *setup(Capability *cap, StgWord closureSizeWords, StgWord w,
void (*f)(Capability *, StgStack *, StgWord)) {
- Capability *cap = rts_lock();
StgWord totalSizeWords =
sizeofW(StgStack) + closureSizeWords + MIN_STACK_WORDS;
StgStack *stack = (StgStack *)allocate(cap, totalSizeWords);
StgWord totalSizeBytes = WDS(totalSizeWords);
- SET_HDR(stack, &stg_upd_frame_info, CCS_SYSTEM);
+ SET_HDR(stack, &stg_STACK_info, CCS_SYSTEM);
stack->stack_size = totalSizeBytes;
stack->dirty = 0;
stack->marking = 0;
@@ -145,52 +175,66 @@ StgStack *setup(StgWord closureSizeWords, StgWord w,
f(cap, stack, w);
- rts_unlock(cap);
+ checkSTACK(stack);
return stack;
}
-StgStack *any_update_frame(StgWord w) {
- return setup(sizeofW(StgUpdateFrame), w, &create_any_update_frame);
+StgStack *any_update_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgUpdateFrame), w, &create_any_update_frame);
}
-StgStack *any_catch_frame(StgWord w) {
- return setup(sizeofW(StgCatchFrame), w, &create_any_catch_frame);
+StgStack *any_catch_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgCatchFrame), w, &create_any_catch_frame);
}
-StgStack *any_catch_stm_frame(StgWord w) {
- return setup(sizeofW(StgCatchSTMFrame), w, &create_any_catch_stm_frame);
+StgStack *any_catch_stm_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgCatchSTMFrame), w, &create_any_catch_stm_frame);
}
-StgStack *any_catch_retry_frame(StgWord w) {
- return setup(sizeofW(StgCatchRetryFrame), w, &create_any_catch_retry_frame);
+StgStack *any_catch_retry_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgCatchRetryFrame), w, &create_any_catch_retry_frame);
}
-StgStack *any_atomically_frame(StgWord w) {
- return setup(sizeofW(StgAtomicallyFrame), w, &create_any_atomically_frame);
+StgStack *any_atomically_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgAtomicallyFrame), w, &create_any_atomically_frame);
}
-StgStack *any_ret_small_prim_frame(StgWord w) {
- return setup(sizeofW(StgClosure) + sizeofW(StgWord), w,
+StgStack *any_ret_small_prim_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgClosure) + sizeofW(StgWord), w,
&create_any_ret_small_prim_frame);
}
-StgStack *any_ret_small_closure_frame(StgWord w) {
- return setup(sizeofW(StgClosure) + sizeofW(StgClosurePtr), w,
+StgStack *any_ret_small_closure_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgClosure) + sizeofW(StgClosurePtr), w,
&create_any_ret_small_closure_frame);
}
-StgStack *any_ret_small_closures_frame(StgWord w) {
- return setup(sizeofW(StgClosure) + MAX_SMALL_BITMAP_BITS * sizeofW(StgClosurePtr), w,
- &create_any_ret_small_closures_frame);
+StgStack *any_ret_small_closures_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgClosure) +
+ MAX_SMALL_BITMAP_BITS * sizeofW(StgClosurePtr),
+ w, &create_any_ret_small_closures_frame);
+}
+
+StgStack *any_ret_small_prims_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgClosure) +
+ MAX_SMALL_BITMAP_BITS * sizeofW(StgWord),
+ w, &create_any_ret_small_prims_frame);
}
-StgStack *any_ret_big_closures_frame(StgWord w) {
+StgStack *any_ret_big_closures_frame(Capability *cap, StgWord w) {
return NULL; // TODO: Implement
// return setup(sizeofW(StgClosure) + sizeofW(StgClosurePtr), w,
// &create_any_ret_closures_closure_frame);
}
-StgStack *any_ret_big_prims_frame(StgWord w) {
- return setup(sizeofW(StgClosure) + sizeofW(StgWord), w,
+StgStack *any_ret_big_prim_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgClosure) + 59 * sizeofW(StgWord), w,
+ &create_any_ret_big_prim_frame);
+}
+
+StgStack *any_ret_big_prims_frame(Capability *cap, StgWord w) {
+ return setup(cap, sizeofW(StgClosure) + sizeofW(StgWord), w,
&create_any_ret_big_prims_frame);
}
+
+void belchStack(StgStack *stack) { printStack(stack); }
=====================================
libraries/ghc-heap/tests/stack_misc_closures_prim.cmm
=====================================
@@ -2,72 +2,83 @@
any_update_framezh(W_ w){
P_ stack;
- (stack) = ccall any_update_frame(w);
+ ("ptr" stack) = ccall any_update_frame(MyCapability() "ptr", w);
return (stack);
}
any_catch_framezh(W_ w){
P_ stack;
- (stack) = ccall any_catch_frame(w);
+ (stack) = ccall any_catch_frame(MyCapability() "ptr", w);
return (stack);
}
any_catch_stm_framezh(W_ w){
P_ stack;
- (stack) = ccall any_catch_stm_frame(w);
+ (stack) = ccall any_catch_stm_frame(MyCapability() "ptr", w);
return (stack);
}
any_catch_retry_framezh(W_ w){
P_ stack;
- (stack) = ccall any_catch_retry_frame(w);
+ (stack) = ccall any_catch_retry_frame(MyCapability() "ptr", w);
return (stack);
}
any_atomically_framezh(W_ w){
P_ stack;
- (stack) = ccall any_atomically_frame(w);
+ (stack) = ccall any_atomically_frame(MyCapability() "ptr", w);
return (stack);
}
any_ret_small_prim_framezh(W_ w){
P_ stack;
- (stack) = ccall any_ret_small_prim_frame(w);
+ (stack) = ccall any_ret_small_prim_frame(MyCapability() "ptr", w);
+ return (stack);
+}
+
+any_ret_small_prims_framezh(W_ w){
+ P_ stack;
+ (stack) = ccall any_ret_small_prims_frame(MyCapability() "ptr", w);
return (stack);
}
any_ret_small_closure_framezh(W_ w){
P_ stack;
- (stack) = ccall any_ret_small_closure_frame(w);
+ (stack) = ccall any_ret_small_closure_frame(MyCapability() "ptr", w);
return (stack);
}
any_ret_small_closures_framezh(W_ w){
P_ stack;
- (stack) = ccall any_ret_small_closures_frame(w);
+ (stack) = ccall any_ret_small_closures_frame(MyCapability() "ptr", w);
return (stack);
}
any_ret_big_prims_framezh(W_ w){
P_ stack;
- (stack) = ccall any_ret_big_prims_frame(w);
+ (stack) = ccall any_ret_big_prims_frame(MyCapability() "ptr", w);
+ return (stack);
+}
+
+any_ret_big_prim_framezh(W_ w){
+ P_ stack;
+ (stack) = ccall any_ret_big_prim_frame(MyCapability() "ptr", w);
return (stack);
}
any_ret_big_closures_framezh(W_ w){
P_ stack;
- (stack) = ccall any_ret_big_closures_frame(w);
+ (stack) = ccall any_ret_big_closures_frame(MyCapability() "ptr", w);
return (stack);
}
-#if SIZEOF_VOID_P == 4
INFO_TABLE_RET ( test_small_ret_full_p, RET_SMALL, W_ info_ptr,
+#if SIZEOF_VOID_P == 4
P_ ptr1, P_ ptr2, P_ ptr3, P_ ptr4, P_ ptr5, P_ ptr6, P_ ptr7, P_ ptr8, P_ ptr9, P_ ptr10,
P_ ptr11, P_ ptr12, P_ ptr13, P_ ptr14, P_ ptr15, P_ ptr16, P_ ptr17, P_ ptr18, P_ ptr19, P_ ptr20,
P_ ptr21, P_ ptr22, P_ ptr23, P_ ptr24, P_ ptr25, P_ ptr26, P_ ptr27
)
#elif SIZEOF_VOID_P == 8
-INFO_TABLE_RET ( test_small_ret_full_p, RET_SMALL, W_ info_ptr,
P_ ptr1, P_ ptr2, P_ ptr3, P_ ptr4, P_ ptr5, P_ ptr6, P_ ptr7, P_ ptr8, P_ ptr9, P_ ptr10,
P_ ptr11, P_ ptr12, P_ ptr13, P_ ptr14, P_ ptr15, P_ ptr16, P_ ptr17, P_ ptr18, P_ ptr19, P_ ptr20,
P_ ptr21, P_ ptr22, P_ ptr23, P_ ptr24, P_ ptr25, P_ ptr26, P_ ptr27, P_ ptr28, P_ ptr29, P_ ptr30,
@@ -80,3 +91,42 @@ P_ ptr51, P_ ptr52, P_ ptr53, P_ ptr54, P_ ptr55, P_ ptr56, P_ ptr57, P_ ptr58
{
return ();
}
+
+INFO_TABLE_RET ( test_small_ret_full_n, RET_SMALL, W_ info_ptr,
+#if SIZEOF_VOID_P == 4
+W_ n1, W_ n2, W_ n3, W_ n4, W_ n5, W_ n6, W_ n7, W_ n8, W_ n9, W_ n10,
+W_ n11, W_ n12, W_ n13, W_ n14, W_ n15, W_ n16, W_ n17, W_ n18, W_ n19, W_ n20,
+W_ n21, W_ n22, W_ n23, W_ n24, W_ n25, W_ n26, W_ n27
+)
+#elif SIZEOF_VOID_P == 8
+W_ n1, W_ n2, W_ n3, W_ n4, W_ n5, W_ n6, W_ n7, W_ n8, W_ n9, W_ n10,
+W_ n11, W_ n12, W_ n13, W_ n14, W_ n15, W_ n16, W_ n17, W_ n18, W_ n19, W_ n20,
+W_ n21, W_ n22, W_ n23, W_ n24, W_ n25, W_ n26, W_ n27, W_ n28, W_ n29, W_ n30,
+W_ n31, W_ n32, W_ n33, W_ n34, W_ n35, W_ n36, W_ n37, W_ n38, W_ n39, W_ n40,
+W_ n41, W_ n42, W_ n43, W_ n44, W_ n45, W_ n46, W_ n47, W_ n48, W_ n49, W_ n50,
+W_ n51, W_ n52, W_ n53, W_ n54, W_ n55, W_ n56, W_ n57, W_ n58
+)
+#endif
+ return (/* no return values */)
+{
+ return ();
+}
+
+INFO_TABLE_RET ( test_big_ret_n, RET_BIG, W_ info_ptr,
+W_ n1, W_ n2, W_ n3, W_ n4, W_ n5, W_ n6, W_ n7, W_ n8, W_ n9, W_ n10,
+W_ n11, W_ n12, W_ n13, W_ n14, W_ n15, W_ n16, W_ n17, W_ n18, W_ n19, W_ n20,
+W_ n21, W_ n22, W_ n23, W_ n24, W_ n25, W_ n26, W_ n27, W_ n28, W_ n29, W_ n30,
+W_ n31, W_ n32, W_ n33, W_ n34, W_ n35, W_ n36, W_ n37, W_ n38, W_ n39, W_ n40,
+W_ n41, W_ n42, W_ n43, W_ n44, W_ n45, W_ n46, W_ n47, W_ n48, W_ n49, W_ n50,
+W_ n51, W_ n52, W_ n53, W_ n54, W_ n55, W_ n56, W_ n57, W_ n58, W_ n59
+)
+ return (/* no return values */)
+{
+ return ();
+}
+
+INFO_TABLE(test_fake_blackhole,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE")
+ (P_ node)
+{
+ return ();
+}
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/57f856f9a16ae21a50756538afc4dc2b038ff4fd...17902c75c8bb069ae63a80ed33d7cfb9708abcf1
--
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/57f856f9a16ae21a50756538afc4dc2b038ff4fd...17902c75c8bb069ae63a80ed33d7cfb9708abcf1
You're receiving this email because of your account on gitlab.haskell.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-commits/attachments/20221227/dd6b4a9c/attachment-0001.html>
More information about the ghc-commits
mailing list