diff options
author | Reid Spencer <rspencer@reidspencer.com> | 2007-04-04 23:48:25 +0000 |
---|---|---|
committer | Reid Spencer <rspencer@reidspencer.com> | 2007-04-04 23:48:25 +0000 |
commit | addd11d98ee3a3013c66d3fd25ee2cfb09b3c7bd (patch) | |
tree | e4b33b97bc8aa924bef4d52f1c91288a194e01b8 | |
parent | 93a8415cef077edcda62f0d953daf5a7b7b599d1 (diff) | |
download | llvm-addd11d98ee3a3013c66d3fd25ee2cfb09b3c7bd.tar.gz llvm-addd11d98ee3a3013c66d3fd25ee2cfb09b3c7bd.tar.bz2 llvm-addd11d98ee3a3013c66d3fd25ee2cfb09b3c7bd.tar.xz |
Implement the llvm.bit.part_select.iN.iN.iN overloaded intrinsic.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35678 91177308-0d34-0410-b5e6-96231b3b80d8
-rw-r--r-- | include/llvm/Intrinsics.td | 4 | ||||
-rw-r--r-- | lib/CodeGen/IntrinsicLowering.cpp | 175 | ||||
-rw-r--r-- | lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp | 5 | ||||
-rw-r--r-- | lib/VMCore/Verifier.cpp | 2 | ||||
-rw-r--r-- | test/CodeGen/Generic/bit-intrinsics.ll | 14 |
5 files changed, 199 insertions, 1 deletions
diff --git a/include/llvm/Intrinsics.td b/include/llvm/Intrinsics.td index 7b85d62136..915181ac63 100644 --- a/include/llvm/Intrinsics.td +++ b/include/llvm/Intrinsics.td @@ -203,11 +203,13 @@ def int_siglongjmp : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_i32_ty]>; // None of these intrinsics accesses memory at all. let Properties = [IntrNoMem] in { + def int_bit_part_select : + Intrinsic<[llvm_int_ty, llvm_int_ty, llvm_i32_ty, llvm_i32_ty]>; def int_bswap: Intrinsic<[llvm_int_ty, llvm_int_ty]>; def int_ctpop: Intrinsic<[llvm_i32_ty, llvm_int_ty]>; def int_ctlz : Intrinsic<[llvm_i32_ty, llvm_int_ty]>; def int_cttz : Intrinsic<[llvm_i32_ty, llvm_int_ty]>; -} +} //===------------------------ Debugger Intrinsics -------------------------===// // diff --git a/lib/CodeGen/IntrinsicLowering.cpp b/lib/CodeGen/IntrinsicLowering.cpp index 7b772d78f2..359ca00000 100644 --- a/lib/CodeGen/IntrinsicLowering.cpp +++ b/lib/CodeGen/IntrinsicLowering.cpp @@ -236,6 +236,177 @@ static Value *LowerCTLZ(Value *V, Instruction *IP) { return LowerCTPOP(V, IP); } +/// Convert the llvm.bit.part_select.iX.iY.iZ intrinsic. This intrinsic takes +/// three integer operands of arbitrary bit width. The first operand is the +/// value from which to select the bits. The second and third operands define a +/// range of bits to select. The result is the bits selected and has a +/// corresponding width of Left-Right (second operand - third operand). +/// @see IEEE 1666-2005, System C, Section 7.2.6, pg 175. +/// @brief Lowering of llvm.bit.part_select intrinsic. +static Instruction *LowerBitPartSelect(CallInst *CI) { + // Make sure we're dealing with a part select intrinsic here + Function *F = CI->getCalledFunction(); + const FunctionType *FT = F->getFunctionType(); + if (!F->isDeclaration() || !FT->getReturnType()->isInteger() || + FT->getNumParams() != 3 || !FT->getParamType(0)->isInteger() || + !FT->getParamType(1)->isInteger() || !FT->getParamType(2)->isInteger()) + return CI; + + // Get the intrinsic implementation function by converting all the . to _ + // in the intrinsic's function name and then reconstructing the function + // declaration. + std::string Name(F->getName()); + for (unsigned i = 4; i < Name.length(); ++i) + if (Name[i] == '.') + Name[i] = '_'; + Module* M = F->getParent(); + F = cast<Function>(M->getOrInsertFunction(Name, FT)); + F->setLinkage(GlobalValue::InternalLinkage); + + // If we haven't defined the impl function yet, do so now + if (F->isDeclaration()) { + + // Get the arguments to the function + Value* Val = F->getOperand(0); + Value* Left = F->getOperand(1); + Value* Right = F->getOperand(2); + + // We want to select a range of bits here such that [Left, Right] is shifted + // down to the low bits. However, it is quite possible that Left is smaller + // than Right in which case the bits have to be reversed. + + // Create the blocks we will need for the two cases (forward, reverse) + BasicBlock* CurBB = new BasicBlock("entry", F); + BasicBlock *RevSize = new BasicBlock("revsize", CurBB->getParent()); + BasicBlock *FwdSize = new BasicBlock("fwdsize", CurBB->getParent()); + BasicBlock *Compute = new BasicBlock("compute", CurBB->getParent()); + BasicBlock *Reverse = new BasicBlock("reverse", CurBB->getParent()); + BasicBlock *RsltBlk = new BasicBlock("result", CurBB->getParent()); + + // Cast Left and Right to the size of Val so the widths are all the same + if (Left->getType() != Val->getType()) + Left = CastInst::createIntegerCast(Left, Val->getType(), false, + "tmp", CurBB); + if (Right->getType() != Val->getType()) + Right = CastInst::createIntegerCast(Right, Val->getType(), false, + "tmp", CurBB); + + // Compute a few things that both cases will need, up front. + Constant* Zero = ConstantInt::get(Val->getType(), 0); + Constant* One = ConstantInt::get(Val->getType(), 1); + Constant* AllOnes = ConstantInt::getAllOnesValue(Val->getType()); + + // Compare the Left and Right bit positions. This is used to determine + // which case we have (forward or reverse) + ICmpInst *Cmp = new ICmpInst(ICmpInst::ICMP_ULT, Left, Right, "less",CurBB); + new BranchInst(RevSize, FwdSize, Cmp, CurBB); + + // First, copmute the number of bits in the forward case. + Instruction* FBitSize = + BinaryOperator::createSub(Left, Right,"fbits", FwdSize); + new BranchInst(Compute, FwdSize); + + // Second, compute the number of bits in the reverse case. + Instruction* RBitSize = + BinaryOperator::createSub(Right, Left, "rbits", RevSize); + new BranchInst(Compute, RevSize); + + // Now, compute the bit range. Start by getting the bitsize and the shift + // amount (either Left or Right) from PHI nodes. Then we compute a mask for + // the number of bits we want in the range. We shift the bits down to the + // least significant bits, apply the mask to zero out unwanted high bits, + // and we have computed the "forward" result. It may still need to be + // reversed. + + // Get the BitSize from one of the two subtractions + PHINode *BitSize = new PHINode(Val->getType(), "bits", Compute); + BitSize->reserveOperandSpace(2); + BitSize->addIncoming(FBitSize, FwdSize); + BitSize->addIncoming(RBitSize, RevSize); + + // Get the ShiftAmount as the smaller of Left/Right + PHINode *ShiftAmt = new PHINode(Val->getType(), "shiftamt", Compute); + ShiftAmt->reserveOperandSpace(2); + ShiftAmt->addIncoming(Right, FwdSize); + ShiftAmt->addIncoming(Left, RevSize); + + // Increment the bit size + Instruction *BitSizePlusOne = + BinaryOperator::createAdd(BitSize, One, "bits", Compute); + + // Create a Mask to zero out the high order bits. + Instruction* Mask = + BinaryOperator::createShl(AllOnes, BitSizePlusOne, "mask", Compute); + Mask = BinaryOperator::createNot(Mask, "mask", Compute); + + // Shift the bits down and apply the mask + Instruction* FRes = + BinaryOperator::createLShr(Val, ShiftAmt, "fres", Compute); + FRes = BinaryOperator::createAnd(FRes, Mask, "fres", Compute); + new BranchInst(Reverse, RsltBlk, Cmp, Compute); + + // In the Reverse block we have the mask already in FRes but we must reverse + // it by shifting FRes bits right and putting them in RRes by shifting them + // in from left. + + // First set up our loop counters + PHINode *Count = new PHINode(Val->getType(), "count", Reverse); + Count->reserveOperandSpace(2); + Count->addIncoming(BitSizePlusOne, Compute); + + // Next, get the value that we are shifting. + PHINode *BitsToShift = new PHINode(Val->getType(), "val", Reverse); + BitsToShift->reserveOperandSpace(2); + BitsToShift->addIncoming(FRes, Compute); + + // Finally, get the result of the last computation + PHINode *RRes = new PHINode(Val->getType(), "rres", Reverse); + RRes->reserveOperandSpace(2); + RRes->addIncoming(Zero, Compute); + + // Decrement the counter + Instruction *Decr = BinaryOperator::createSub(Count, One, "decr", Reverse); + Count->addIncoming(Decr, Reverse); + + // Compute the Bit that we want to move + Instruction *Bit = + BinaryOperator::createAnd(BitsToShift, One, "bit", Reverse); + + // Compute the new value for next iteration. + Instruction *NewVal = + BinaryOperator::createLShr(BitsToShift, One, "rshift", Reverse); + BitsToShift->addIncoming(NewVal, Reverse); + + // Shift the bit into the low bits of the result. + Instruction *NewRes = + BinaryOperator::createShl(RRes, One, "lshift", Reverse); + NewRes = BinaryOperator::createOr(NewRes, Bit, "addbit", Reverse); + RRes->addIncoming(NewRes, Reverse); + + // Terminate loop if we've moved all the bits. + ICmpInst *Cond = + new ICmpInst(ICmpInst::ICMP_EQ, Decr, Zero, "cond", Reverse); + new BranchInst(RsltBlk, Reverse, Cond, Reverse); + + // Finally, in the result block, select one of the two results with a PHI + // node and return the result; + CurBB = RsltBlk; + PHINode *BitSelect = new PHINode(Val->getType(), "part_select", CurBB); + BitSelect->reserveOperandSpace(2); + BitSelect->addIncoming(FRes, Compute); + BitSelect->addIncoming(NewRes, Reverse); + new ReturnInst(BitSelect, CurBB); + } + + // Return a call to the implementation function + Value *Args[3]; + Args[0] = CI->getOperand(0); + Args[1] = CI->getOperand(1); + Args[2] = CI->getOperand(2); + return new CallInst(F, Args, 3, CI->getName(), CI); +} + + void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { Function *Callee = CI->getCalledFunction(); assert(Callee && "Cannot lower an indirect call!"); @@ -304,6 +475,10 @@ void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { break; } + case Intrinsic::bit_part_select: + CI->replaceAllUsesWith(LowerBitPartSelect(CI)); + break; + case Intrinsic::stacksave: case Intrinsic::stackrestore: { static bool Warned = false; diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp index 8e0660478e..1bd2aae715 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -2438,6 +2438,11 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { DAG.setRoot(Tmp.getValue(1)); return 0; } + case Intrinsic::bit_part_select: { + MVT::ValueType Ty = getValue(I.getOperand(1)).getValueType(); + setValue(&I, DAG.getTargetConstant(0, Ty)); + return 0; + } case Intrinsic::bswap: setValue(&I, DAG.getNode(ISD::BSWAP, getValue(I.getOperand(1)).getValueType(), diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 052c963c15..c2fba29052 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -1027,6 +1027,8 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, ...) { case Intrinsic::bswap: if (GotBits < 16 || GotBits % 16 != 0) CheckFailed("Intrinsic requires even byte width argument", F); + /* FALL THROUGH */ + case Intrinsic::bit_part_select: if (ArgNo == 1) { unsigned ResultBits = cast<IntegerType>(FTy->getReturnType())->getBitWidth(); diff --git a/test/CodeGen/Generic/bit-intrinsics.ll b/test/CodeGen/Generic/bit-intrinsics.ll new file mode 100644 index 0000000000..a260421772 --- /dev/null +++ b/test/CodeGen/Generic/bit-intrinsics.ll @@ -0,0 +1,14 @@ +; Make sure this testcase is supported by all code generators. Either the +; intrinsic is supported natively or IntrinsicLowering provides it. +; RUN: llvm-as < %s | llc + + +declare i32 @llvm.bit.part.select.i32.i32(i32 %x, i32 %hi, i32 %lo) +declare i16 @llvm.bit.part.select.i16.i16(i16 %x, i32 %hi, i32 %lo) +define i32 @bit_part_select(i32 %A, i16 %B) { + %a = call i32 @llvm.bit.part.select.i32.i32(i32 %A, i32 8, i32 0) + %b = call i16 @llvm.bit.part.select.i16.i16(i16 %B, i32 8, i32 0) + %c = zext i16 %b to i32 + %d = add i32 %a, %c + ret i32 %d +} |