Skip to content

JIT: remove unused helpers #135026

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
EgorBo merged 1 commit into from
Oct 1, 2026
Merged

JIT: remove unused helpers #135026

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 1 addition & 8 deletions src/coreclr/jit/codegen.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -674,10 +674,7 @@ class CodeGen final : public CodeGenInterface
//
//-------------------------------------------------------------------------

void genSinglePush();
void genSinglePop();
regMaskTP genPushRegs(regMaskTP regs, regMaskTP* byrefRegs, regMaskTP* noRefRegs);
void genPopRegs(regMaskTP regs, regMaskTP byrefRegs, regMaskTP noRefRegs);
void genSinglePush();

/*
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Expand Down Expand Up @@ -1163,10 +1160,6 @@ class CodeGen final : public CodeGenInterface
void genTransferRegGCState(regNumber dst, regNumber src);
void genConsumeAddress(GenTree* addr);
void genConsumeAddrMode(GenTreeAddrMode* mode);
void genSetBlockSize(GenTreeBlk* blkNode, regNumber sizeReg);
void genConsumeBlockSrc(GenTreeBlk* blkNode);
void genSetBlockSrc(GenTreeBlk* blkNode, regNumber srcReg);
void genConsumeBlockOp(GenTreeBlk* blkNode, regNumber dstReg, regNumber srcReg, regNumber sizeReg);

void genConsumePutStructArgStk(GenTreePutArgStk* putArgStkNode,
regNumber dstReg,
Expand Down
145 changes: 0 additions & 145 deletions src/coreclr/jit/codegencommon.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6410,151 +6410,6 @@ void CodeGen::genSinglePush()
AddStackLevel(REGSIZE_BYTES);
}

//------------------------------------------------------------------------
// genSinglePop: Report a change in stack level caused by a single word-sized pop instruction
//
void CodeGen::genSinglePop()
{
SubtractStackLevel(REGSIZE_BYTES);
}

//------------------------------------------------------------------------
// genPushRegs: Push the given registers.
//
// Arguments:
// regs - mask or registers to push
// byrefRegs - OUT arg. Set to byref registers that were pushed.
// noRefRegs - OUT arg. Set to non-GC ref registers that were pushed.
//
// Return Value:
// Mask of registers pushed.
//
// Notes:
// This function does not check if the register is marked as used, etc.
//
regMaskTP CodeGen::genPushRegs(regMaskTP regs, regMaskTP* byrefRegs, regMaskTP* noRefRegs)
{
*byrefRegs = RBM_NONE;
*noRefRegs = RBM_NONE;

if (regs == RBM_NONE)
{
return RBM_NONE;
}

#if FEATURE_FIXED_OUT_ARGS

NYI("Don't call genPushRegs with real regs!");
return RBM_NONE;

#else // FEATURE_FIXED_OUT_ARGS

noway_assert(genTypeStSz(TYP_REF) == genTypeStSz(TYP_I_IMPL));
noway_assert(genTypeStSz(TYP_BYREF) == genTypeStSz(TYP_I_IMPL));

regMaskTP pushedRegs = regs;
for (regNumber reg = REG_INT_FIRST; reg <= get_REG_INT_LAST(); reg = REG_NEXT(reg))
{
regMaskTP regMask = genRegMask(reg);

if ((regMask & pushedRegs) == RBM_NONE)
continue;

var_types type;
if (regMask & gcInfo.gcRegGCrefSetCur)
{
type = TYP_REF;
}
else if (regMask & gcInfo.gcRegByrefSetCur)
{
*byrefRegs |= regMask;
type = TYP_BYREF;
}
else if (noRefRegs != NULL)
{
*noRefRegs |= regMask;
type = TYP_I_IMPL;
}
else
{
continue;
}

inst_RV(INS_push, reg, type);

genSinglePush();
gcInfo.gcMarkRegSetNpt(regMask);
}

return pushedRegs;

#endif // FEATURE_FIXED_OUT_ARGS
}

//------------------------------------------------------------------------
// genPopRegs: Pop the registers that were pushed by genPushRegs().
//
// Arguments:
// regs - mask of registers to pop
// byrefRegs - The byref registers that were pushed by genPushRegs().
// noRefRegs - The non-GC ref registers that were pushed by genPushRegs().
//
// Return Value:
// None
//
void CodeGen::genPopRegs(regMaskTP regs, regMaskTP byrefRegs, regMaskTP noRefRegs)
{
if (regs == RBM_NONE)
{
return;
}

#if FEATURE_FIXED_OUT_ARGS

NYI("Don't call genPopRegs with real regs!");

#else // FEATURE_FIXED_OUT_ARGS

noway_assert((regs & byrefRegs) == byrefRegs);
noway_assert((regs & noRefRegs) == noRefRegs);
noway_assert((regs & (gcInfo.gcRegGCrefSetCur | gcInfo.gcRegByrefSetCur)) == RBM_NONE);

noway_assert(genTypeStSz(TYP_REF) == genTypeStSz(TYP_INT));
noway_assert(genTypeStSz(TYP_BYREF) == genTypeStSz(TYP_INT));

regMaskTP popedRegs = regs;

// Walk the registers in the reverse order as genPushRegs()
for (regNumber reg = get_REG_INT_LAST(); reg >= REG_INT_FIRST; reg = REG_PREV(reg))
{
regMaskTP regMask = genRegMask(reg);

if ((regMask & popedRegs) == RBM_NONE)
continue;

var_types type;
if (regMask & byrefRegs)
{
type = TYP_BYREF;
}
else if (regMask & noRefRegs)
{
type = TYP_INT;
}
else
{
type = TYP_REF;
}

inst_RV(INS_pop, reg, type);
genSinglePop();

if (type != TYP_INT)
gcInfo.gcMarkRegPtrVal(reg, type);
}

#endif // FEATURE_FIXED_OUT_ARGS
}
#endif // !TARGET_WASM

#ifdef DEBUG
Expand Down
127 changes: 0 additions & 127 deletions src/coreclr/jit/codegenlinear.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1985,133 +1985,6 @@ void CodeGen::genPutArgStkFieldList(GenTreePutArgStk* putArgStk, unsigned outArg
}
#endif // !TARGET_X86

//------------------------------------------------------------------------
// genSetBlockSize: Ensure that the block size is in the given register
//
// Arguments:
// blkNode - The block node
// sizeReg - The register into which the block's size should go
//

void CodeGen::genSetBlockSize(GenTreeBlk* blkNode, regNumber sizeReg)
{
if (sizeReg != REG_NA)
{
assert((internalRegisters.GetAll(blkNode) & genRegMask(sizeReg)) != 0);
// This can go via helper which takes the size as a native uint.
instGen_Set_Reg_To_Imm(EA_PTRSIZE, sizeReg, blkNode->Size());
}
}

//------------------------------------------------------------------------
// genConsumeBlockSrc: Consume the source address register of a block node, if any.
//
// Arguments:
// blkNode - The block node

void CodeGen::genConsumeBlockSrc(GenTreeBlk* blkNode)
{
GenTree* src = blkNode->Data();
if (blkNode->OperIsCopyBlkOp())
{
// For a CopyBlk we need the address of the source.
assert(src->isContained());
if (src->OperIs(GT_IND))
{
src = src->AsOp()->gtOp1;
}
else
{
// This must be a local.
// For this case, there is no source address register, as it is a
// stack-based address.
assert(src->OperIsLocal());
return;
}
}
else
{
if (src->OperIsInitVal())
{
src = src->gtGetOp1();
}
}
genConsumeReg(src);
}

//------------------------------------------------------------------------
// genSetBlockSrc: Ensure that the block source is in its allocated register.
//
// Arguments:
// blkNode - The block node
// srcReg - The register in which to set the source (address or init val).
//
void CodeGen::genSetBlockSrc(GenTreeBlk* blkNode, regNumber srcReg)
{
GenTree* src = blkNode->Data();
if (blkNode->OperIsCopyBlkOp())
{
// For a CopyBlk we need the address of the source.
if (src->OperIs(GT_IND))
{
src = src->AsOp()->gtOp1;
}
else
{
// This must be a local struct.
// Load its address into srcReg.
unsigned varNum = src->AsLclVarCommon()->GetLclNum();
unsigned offset = src->AsLclVarCommon()->GetLclOffs();
GetEmitter()->emitIns_R_S(INS_lea, EA_BYREF, srcReg, varNum, offset);
return;
}
}
else
{
if (src->OperIsInitVal())
{
src = src->gtGetOp1();
}
}
genCopyRegIfNeeded(src, srcReg);
}

//------------------------------------------------------------------------
// genConsumeBlockOp: Ensure that the block's operands are enregistered
// as needed.
// Arguments:
// blkNode - The block node
//
// Notes:
// This ensures that the operands are consumed in the proper order to
// obey liveness modeling.

void CodeGen::genConsumeBlockOp(GenTreeBlk* blkNode, regNumber dstReg, regNumber srcReg, regNumber sizeReg)
{
// We have to consume the registers, and perform any copies, in the actual execution order: dst, src, size.
//
// Note that the register allocator ensures that the registers ON THE NODES will not interfere
// with one another if consumed (i.e. reloaded or moved to their ASSIGNED reg) in execution order.
// Further, it ensures that they will not interfere with one another if they are then copied
// to the REQUIRED register (if a fixed register requirement) in execution order. This requires,
// then, that we first consume all the operands, then do any necessary moves.

GenTree* const dstAddr = blkNode->Addr();

// First, consume all the sources in order, and verify that registers have been allocated appropriately,
// based on the 'gtBlkOpKind'.

// The destination is always in a register; 'genConsumeReg' asserts that.
genConsumeReg(dstAddr);
// The source may be a local or in a register; 'genConsumeBlockSrc' will check that.
genConsumeBlockSrc(blkNode);

// Next, perform any necessary moves.
genCopyRegIfNeeded(dstAddr, dstReg);
genSetBlockSrc(blkNode, srcReg);
genSetBlockSize(blkNode, sizeReg);
}

//-------------------------------------------------------------------------
// genSpillLocal: Generate the actual spill of a local var.
//
Expand Down
Loading
Loading