+    -- See Note [Pointer tagging of unlifted boxed primitives].  Untag by the

+    -- primop's DECLARED signature type, so only a container argument is untagged

+    -- while a polymorphic value/element argument keeps its tag.  The declared arg

+    -- types line up with the (unarised) Cmm arguments only when the primop has no

+    -- unboxed-tuple argument; the primops that do (e.g. VecPackOp) take no boxed

+    -- unlifted container, so leaving their arguments untouched is correct.

+    let (_, arg_tys, _, _, _) = primOpSig primop

+        nonVoid_arg_tys = [ ty | (arg, ty) <- zip args arg_tys

+                               , not (null (stgArgRep arg)) ]

+        cmm_args'

+          | length nonVoid_arg_tys == length cmm_args

+          = zipWith (untagPrimArg platform) nonVoid_arg_tys cmm_args

+          | otherwise = cmm_args

+untagPrimArg :: Platform -> Type -> CmmExpr -> CmmExpr

+untagPrimArg platform arg_ty e

+  | isUnliftedBoxedTy arg_ty = cmmOffsetB platform e (negate 1)

+  | otherwise                = e

+  -- Match the tycon head first: it is total and yields Nothing for a (possibly

+  -- representation-polymorphic) type variable, for which isUnliftedType panics.

+  -- Look through newtypes (e.g. the ArrayArray# wrappers, newtypes over

+  -- MutableArray#) so a wrapped primitive container is still recognised.

+  case tyConAppTyCon_maybe (unwrapType ty) of

+    Just tc -> isPrimTyCon tc && isUnliftedType ty && isBoxedType ty

+    Nothing -> False

+  In the result direction the callee is a producer: an unlifted boxed value

+  returned by a 'foreign import prim' callee carries tag 1, following the

+  convention of the out-of-line primops in rts/PrimOps.cmm. Callers read the

+  result through that tag (see e.g. T21305).

+

+  // The stable pointer's referent (an MVar#) carries the boxed-unlifted-

+  // primitive pointer tag; strip it before the RTS dereferences it.

+  msg->result = (StgMVar*)UNTAG_CLOSURE((StgClosure*)deRefStablePtr(mvar));

+        if (should == SHOULDCOMPACT_IN_CNF) { P_[pp] = tag | p; return(); }

+        P_[pp] = tag | to;

+        if (should == SHOULDCOMPACT_IN_CNF) { P_[pp] = tag | p; return(); }

+        if (should == SHOULDCOMPACT_IN_CNF) { P_[pp] = tag | p; return(); }

+  // Tag the freshly allocated Array# with the boxed-unlifted-primitive tag.

+  return (arr + 1);

+        // The label is a ByteArray#, stored untagged; tag it for the consumer.

+        return (1, r + 1);

+    // The stable pointer's referent (an MVar#) carries the boxed-unlifted-

+    // primitive pointer tag; strip it before the RTS dereferences it.

+    performTryPutMVar(cap, (StgMVar*)UNTAG_CLOSURE((StgClosure*)deRefStablePtr(mvar)), value);

+        // The stable pointer's referent (an MVar#) carries the boxed-unlifted-

+        // primitive pointer tag; strip it before the RTS dereferences it.

+        performTryPutMVar(cap, (StgMVar*)UNTAG_CLOSURE((StgClosure*)deRefStablePtr(mvar)), value);

+            performTryPutMVar(cap,

+                              (StgMVar*)UNTAG_CLOSURE((StgClosure*)deRefStablePtr(p->mvar)),

+          // The handler receives the offending thread as a ThreadId#, which

+          // carries the boxed-unlifted-primitive pointer tag.

+          StgClosure* c = rts_apply(cap, runAllocationLimitHandler_closure,

+                                    TAG_CLOSURE(1, (StgClosure*)t));

+            // The array elements are ThreadId#s, which carry the

+            // boxed-unlifted-primitive pointer tag.

+            arr->payload[i] = TAG_CLOSURE(1, (StgClosure *) t);

+    // The key is a ThreadId#, which carries the boxed-unlifted-primitive tag.

+    ASSERT(UNTAG_CLOSURE(weak->key)->header.info == &stg_TSO_info);

+        StgClosure *key = UNTAG_CLOSURE(((StgWeak*)weak)->key);

+                           // runFinalizerBatch indexes this as an Array#, so it

+                           // must carry the boxed-unlifted-primitive pointer tag.

+                           TAG_CLOSURE(1, (StgClosure *)arr))

+    case ARR_WORDS:

+    case MUT_ARR_PTRS_CLEAN:

+    case MUT_ARR_PTRS_DIRTY:

+    case MUT_ARR_PTRS_FROZEN_CLEAN:

+    case MUT_ARR_PTRS_FROZEN_DIRTY:

+    case SMALL_MUT_ARR_PTRS_CLEAN:

+    case SMALL_MUT_ARR_PTRS_DIRTY:

+    case SMALL_MUT_ARR_PTRS_FROZEN_CLEAN:

+    case SMALL_MUT_ARR_PTRS_FROZEN_DIRTY:

+    case MUT_VAR_CLEAN:

+    case MUT_VAR_DIRTY:

+    case MVAR_CLEAN:

+    case MVAR_DIRTY:

+    case TVAR:

+    case WEAK:

+    case PRIM:

+    case MUT_PRIM:

+    case TSO:

+    case STACK:

+    case TREC_CHUNK:

+    case CONTINUATION:

+        // Boxed unlifted primitives carry the pointer tag 1; restore it (this is

+        // only consulted for references that were tagged before threading).

+        return 1;

+

+         uint32_t size_to_copy, uint32_t gen_no, StgWord tag)

+    RELEASE_STORE(p, TAG_CLOSURE(tag, (StgClosure *) to));

+      // These boxed unlifted primitives carry the pointer tag 1; preserve it

+      // across evacuation.

+      copy_tag(p,info,q,sizeW_fromITBL(INFO_PTR_TO_STRUCT(info)),gen_no,tag);

+      copy_tag(p,info,q,bco_sizeW((StgBCO *)q),gen_no,tag);

+      // just copy the block, preserving the pointer tag

+      copy_tag(p,info,q,arr_words_sizeW((StgArrBytes *)q),gen_no,tag);

+      // just copy the block, preserving the pointer tag

+      copy_tag(p,info,q,mut_arr_ptrs_sizeW((StgMutArrPtrs *)q),gen_no,tag);

+      // just copy the block, preserving the pointer tag

+      copy_tag(p,info,q,small_mut_arr_ptrs_sizeW((StgSmallMutArrPtrs *)q),gen_no,tag);

+      copy_tag(p,info,q,sizeofW(StgTSO),gen_no,tag);

+                          sizeofW(StgStack), gen_no, tag);

+      copy_tag(p,info,q,sizeofW(StgTRecChunk),gen_no,tag);

+      copy_tag(p,info,q,continuation_sizeW((StgContinuation*)q),gen_no,tag);

+  // c is a MutableByteArray#; unlifted boxed results carry tag 1.

+  // See Note [Pointer tagging of unlifted boxed primitives] in GHC.StgToCmm.Prim.

+  return (b, a, c + 1);