break;
}
- unsigned FirstZeroHighBit = 32 - countLeadingZeros(*VScaleMax);
+ unsigned FirstZeroHighBit = llvm::bit_width(*VScaleMax);
if (FirstZeroHighBit < BitWidth)
Known.Zero.setBitsFrom(FirstZeroHighBit);
size_t W = std::min(kMaxWidth, Width.value_or(0u));
- unsigned Nibbles = (64 - countLeadingZeros(N) + 3) / 4;
+ unsigned Nibbles = (llvm::bit_width(N) + 3) / 4;
bool Prefix = (Style == HexPrintStyle::PrefixLower ||
Style == HexPrintStyle::PrefixUpper);
bool Upper =
Register TmpReg = MRI.createGenericVirtualRegister(LLT::scalar(32));
if (!loadInputValue(TmpReg, B, ArgType))
return false;
- B.buildAssertZExt(DstReg, TmpReg, 32 - countLeadingZeros(MaxID));
+ B.buildAssertZExt(DstReg, TmpReg, llvm::bit_width(MaxID));
}
MI.eraseFromParent();
return Val;
// Preserve the known bits after expansion to a copy.
- EVT SmallVT =
- EVT::getIntegerVT(*DAG.getContext(), 32 - countLeadingZeros(MaxID));
+ EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), llvm::bit_width(MaxID));
return DAG.getNode(ISD::AssertZext, SL, MVT::i32, Val,
DAG.getValueType(SmallVT));
}
return SDValue();
unsigned InvMask = cast<ConstantSDNode>(N->getOperand(2))->getZExtValue();
unsigned LSB = countTrailingZeros(~InvMask);
- unsigned Width = (32 - countLeadingZeros(~InvMask)) - LSB;
+ unsigned Width = llvm::bit_width<unsigned>(~InvMask) - LSB;
assert(Width <
static_cast<unsigned>(std::numeric_limits<unsigned>::digits) &&
"undefined behavior");
const MCOperand &MO = MI->getOperand(OpNum);
uint32_t v = ~MO.getImm();
int32_t lsb = countTrailingZeros(v);
- int32_t width = (32 - countLeadingZeros(v)) - lsb;
+ int32_t width = llvm::bit_width(v) - lsb;
assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!");
O << markup("<imm:") << '#' << lsb << markup(">") << ", " << markup("<imm:")
<< '#' << width << markup(">");
for (uint32_t Regs : {VFPRegSave & 0xffff0000u, VFPRegSave & 0x0000ffffu}) {
while (Regs) {
// Now look for a run of set bits. Remember the MSB and LSB of the run.
- auto RangeMSB = 32 - countLeadingZeros(Regs);
+ auto RangeMSB = llvm::bit_width(Regs);
auto RangeLen = countLeadingOnes(Regs << (32 - RangeMSB));
auto RangeLSB = RangeMSB - RangeLen;
return false;
break;
case RISCV::ANDI:
- if (Bits >= (64 - countLeadingZeros(User->getConstantOperandVal(1))))
+ if (Bits >= (unsigned)llvm::bit_width(User->getConstantOperandVal(1)))
break;
goto RecCheck;
case RISCV::ORI: {
uint64_t Imm = cast<ConstantSDNode>(User->getOperand(1))->getSExtValue();
- if (Bits >= (64 - countLeadingOnes(Imm)))
+ if (Bits >= (unsigned)llvm::bit_width<uint64_t>(~Imm))
break;
[[fallthrough]];
}
break;
Worklist.push_back(std::make_pair(UserMI, Bits));
break;
- case RISCV::ANDI:
- if (Bits >=
- (64 - countLeadingZeros((uint64_t)UserMI->getOperand(2).getImm())))
+ case RISCV::ANDI: {
+ uint64_t Imm = UserMI->getOperand(2).getImm();
+ if (Bits >= (unsigned)llvm::bit_width(Imm))
break;
Worklist.push_back(std::make_pair(UserMI, Bits));
break;
- case RISCV::ORI:
- if (Bits >=
- (64 - countLeadingOnes((uint64_t)UserMI->getOperand(2).getImm())))
+ }
+ case RISCV::ORI: {
+ uint64_t Imm = UserMI->getOperand(2).getImm();
+ if (Bits >= (unsigned)llvm::bit_width<uint64_t>(~Imm))
break;
Worklist.push_back(std::make_pair(UserMI, Bits));
break;
+ }
case RISCV::SLL:
case RISCV::BSET:
if (!isMask_32(value)) {
return false;
}
- int msksize = 32 - countLeadingZeros(value);
+ int msksize = llvm::bit_width(value);
return (msksize >= 1 && msksize <= 8) ||
msksize == 16 || msksize == 24 || msksize == 32;
}
if (immMskBitp(N)) {
// Transformation function: get the size of a mask
// Look for the first non-zero bit
- SDValue MskSize = getI32Imm(32 - countLeadingZeros((uint32_t)Val), dl);
- ReplaceNode(N, CurDAG->getMachineNode(XCore::MKMSK_rus, dl,
- MVT::i32, MskSize));
+ SDValue MskSize = getI32Imm(llvm::bit_width((uint32_t)Val), dl);
+ ReplaceNode(
+ N, CurDAG->getMachineNode(XCore::MKMSK_rus, dl, MVT::i32, MskSize));
return;
}
else if (!isUInt<16>(Val)) {
// Transformation function: get the size of a mask
assert(isMask_32(N->getZExtValue()));
// look for the first non-zero bit
- return getI32Imm(32 - countLeadingZeros((uint32_t)N->getZExtValue()),
+ return getI32Imm(llvm::bit_width((uint32_t)N->getZExtValue()),
SDLoc(N));
}]>;