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) {
+/// Convert the llvm.part.select.iX.iY intrinsic. This intrinsic takes
+/// three integer arguments. The first argument is the Value from which the
+/// bits will be selected. It may be of any bit width. The second and third
+/// arguments specify a range of bits to select with the second argument
+/// specifying the low bit and the third argument specifying the high bit. Both
+/// must be type i32. The result is the corresponding selected bits from the
+/// Value in the same width as the Value (first argument). If the low bit index
+/// is higher than the high bit index then the inverse selection is done and
+/// the bits are returned in inverse order.
+/// @brief Lowering of llvm.part.select intrinsic.
+static Instruction *LowerPartSelect(CallInst *CI) {
// Make sure we're dealing with a part select intrinsic here
Function *F = CI->getCalledFunction();
const FunctionType *FT = F->getFunctionType();
// Get the arguments to the function
Value* Val = F->getOperand(0);
- Value* Left = F->getOperand(1);
- Value* Right = F->getOperand(2);
+ Value* Right = F->getOperand(1);
+ Value* Left = 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
return new CallInst(F, Args, 3, CI->getName(), CI);
}
+/// Convert the llvm.part.set.iX.iY.iZ intrinsic. This intrinsic takes
+/// four integer arguments (iAny %Value, iAny %Replacement, i32 %Low, i32 %High)
+/// The first two arguments can be any bit width. The result is the same width
+/// as %Value. The operation replaces bits between %Low and %High with the value
+/// in %Replacement. If %Replacement is not the same width, it is truncated or
+/// zero extended as appropriate to fit the bits being replaced. If %Low is
+/// greater than %High then the inverse set of bits are replaced.
+/// @brief Lowering of llvm.bit.part.set intrinsic.
+static Instruction *LowerPartSet(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() != 4 || !FT->getParamType(0)->isInteger() ||
+ !FT->getParamType(1)->isInteger() || !FT->getParamType(2)->isInteger() ||
+ !FT->getParamType(3)->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()) {
+ // Note: the following code is based on code generated by llvm2cpp with
+ // the following input. This is just *one* example of a generated function.
+ // The functions vary by bit width of result and first two arguments.
+ // The generated code has been changed to deal with any bit width not just
+ // the 32/64 bitwidths used in the above sample.
+ //
+ // define i64 @part_set(i64 %Val, i32 %Rep, i32 %Lo, i32 %Hi) {
+ // entry:
+ // %is_forward = icmp ult i32 %Lo, %Hi
+ // %Lo.pn = select i1 %is_forward, i32 %Hi, i32 %Lo
+ // %Hi.pn = select i1 %is_forward, i32 %Lo, i32 %Hi
+ // %iftmp.16.0 = sub i32 %Lo.pn, %Hi.pn
+ // icmp ult i32 %iftmp.16.0, 32
+ // br i1 %1, label %cond_true11, label %cond_next19
+ // cond_true11:
+ // %tmp13 = sub i32 32, %iftmp.16.0
+ // %tmp14 = lshr i32 -1, %tmp13
+ // %tmp16 = and i32 %tmp14, %Rep
+ // br label %cond_next19
+ // cond_next19:
+ // %iftmp.17.0 = phi i32 [ %tmp16, %cond_true11 ], [ %Rep, %entry ]
+ // %tmp2021 = zext i32 %iftmp.17.0 to i64
+ // icmp ugt i32 %Lo, %Hi
+ // br i1 %2, label %cond_next60, label %cond_true24
+ // cond_true24:
+ // %tmp25.cast = zext i32 %Hi to i64
+ // %tmp26 = lshr i64 -1, %tmp25.cast
+ // %tmp27.cast = zext i32 %Lo to i64
+ // %tmp28 = shl i64 %tmp26, %tmp27.cast
+ // %tmp28not = xor i64 %tmp28, -1
+ // %tmp31 = shl i64 %tmp2021, %tmp27.cast
+ // %tmp34 = and i64 %tmp28not, %Val
+ // %Val_addr.064 = or i64 %tmp31, %tmp34
+ // ret i64 %Val_addr.064
+ // cond_next60:
+ // %tmp39.cast = zext i32 %Lo to i64
+ // %tmp40 = shl i64 -1, %tmp39.cast
+ // %tmp41.cast = zext i32 %Hi to i64
+ // %tmp42 = shl i64 -1, %tmp41.cast
+ // %tmp45.demorgan = or i64 %tmp42, %tmp40
+ // %tmp45 = xor i64 %tmp45.demorgan, -1
+ // %tmp47 = and i64 %tmp45, %Val
+ // %tmp50 = shl i64 %tmp2021, %tmp39.cast
+ // %tmp52 = sub i32 32, %Hi
+ // %tmp52.cast = zext i32 %tmp52 to i64
+ // %tmp54 = lshr i64 %tmp2021, %tmp52.cast
+ // %tmp57 = or i64 %tmp50, %tmp47
+ // %Val_addr.0 = or i64 %tmp57, %tmp54
+ // ret i64 %Val_addr.0
+ // }
+
+ // Get the arguments for the function.
+ Function::arg_iterator args = F->arg_begin();
+ Value* Val = args++; Val->setName("Val");
+ Value* Rep = args++; Rep->setName("Rep");
+ Value* Lo = args++; Lo->setName("Lo");
+ Value* Hi = args++; Hi->setName("Hi");
+
+ // Get some types we need
+ const IntegerType* ValTy = cast<IntegerType>(Val->getType());
+ const IntegerType* RepTy = cast<IntegerType>(Rep->getType());
+ uint32_t ValBits = ValTy->getBitWidth();
+ uint32_t RepBits = RepTy->getBitWidth();
+
+ // Constant Definitions
+ ConstantInt* RepBitWidth = ConstantInt::get(Type::Int32Ty, RepBits);
+ ConstantInt* RepMask = ConstantInt::getAllOnesValue(RepTy);
+ ConstantInt* ValMask = ConstantInt::getAllOnesValue(ValTy);
+
+ BasicBlock* entry = new BasicBlock("entry",F,0);
+ BasicBlock* large = new BasicBlock("large",F,0);
+ BasicBlock* small = new BasicBlock("small",F,0);
+ BasicBlock* forward = new BasicBlock("cond_true24",F,0);
+ BasicBlock* reverse = new BasicBlock("cond_next60",F,0);
+
+ // Block entry (entry)
+ // First, convert Lo and Hi to ValTy bit width
+ if (ValBits > 32) {
+ Hi = new ZExtInst(Hi, ValTy, "", entry);
+ Lo = new ZExtInst(Lo, ValTy, "", entry);
+ } else if (ValBits < 32) {
+ Hi = new TruncInst(Hi, ValTy, "", entry);
+ Lo = new TruncInst(Lo, ValTy, "", entry);
+ }
+ ICmpInst* is_forward =
+ new ICmpInst(ICmpInst::ICMP_ULT, Lo, Hi, "", entry);
+ SelectInst* Lo_pn = new SelectInst(is_forward, Hi, Lo, "", entry);
+ SelectInst* Hi_pn = new SelectInst(is_forward, Lo, Hi, "", entry);
+ BinaryOperator* NumBits = BinaryOperator::createSub(Lo_pn, Hi_pn, "",entry);
+ ICmpInst* is_large =
+ new ICmpInst(ICmpInst::ICMP_ULT, NumBits, RepBitWidth, "", entry);
+ new BranchInst(large, small, is_large, entry);
+
+ // Block "large"
+ BinaryOperator* MaskBits =
+ BinaryOperator::createSub(RepBitWidth, NumBits, "", large);
+ BinaryOperator* Mask1 =
+ BinaryOperator::createLShr(RepMask, MaskBits, "", large);
+ BinaryOperator* Rep2 = BinaryOperator::createAnd(Mask1, Rep, "", large);
+ new BranchInst(small, large);
+
+ // Block "small"
+ PHINode* Rep3 = new PHINode(RepTy, "", small);
+ Rep3->reserveOperandSpace(2);
+ Rep3->addIncoming(Rep2, small);
+ Rep3->addIncoming(Rep, entry);
+ CastInst* Rep4 = new ZExtInst(Rep3, ValTy, "", small);
+ ICmpInst* is_reverse =
+ new ICmpInst(ICmpInst::ICMP_UGT, Lo, Hi, "", small);
+ new BranchInst(reverse, forward, is_reverse, small);
+
+ // Block "forward"
+ Value* t1 = BinaryOperator::createLShr(ValMask, Hi, "", forward);
+ Value* t2 = BinaryOperator::createShl(t1, Lo, "", forward);
+ Value* nott2 = BinaryOperator::createXor(t2, ValMask, "", forward);
+ Value* t3 = BinaryOperator::createShl(Rep4, Lo, "", forward);
+ Value* t4 = BinaryOperator::createAnd(nott2, Val, "", forward);
+ Value* FRslt = BinaryOperator::createOr(t3, t4, "", forward);
+ new ReturnInst(FRslt, forward);
+
+ // Block "reverse"
+ Value* t5 = BinaryOperator::createShl(ValMask, Lo, "", reverse);
+ Value* t6 = BinaryOperator::createShl(ValMask, Hi, "", reverse);
+ Value* t7 = BinaryOperator::createOr(t6, t5, "", reverse);
+ Value* t8 = BinaryOperator::createXor(t7, ValMask, "", reverse);
+ Value* t9 = BinaryOperator::createAnd(t8, Val, "", reverse);
+ Value* t10 = BinaryOperator::createShl(Rep4, Lo, "", reverse);
+ Value* t11 = BinaryOperator::createSub(RepBitWidth, Hi, "", reverse);
+ Value* t12 = new ZExtInst(t11, ValTy, "", reverse);
+ Value* t13 = BinaryOperator::createLShr(Rep4, t12, "",reverse);
+ Value* t14 = BinaryOperator::createOr(t10, t9, "", reverse);
+ Value* RRslt = BinaryOperator::createOr(t14, t13, "", reverse);
+ new ReturnInst(RRslt, reverse);
+ }
+
+ // 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);
+ Args[3] = CI->getOperand(3);
+ return new CallInst(F, Args, 4, CI->getName(), CI);
+}
+
void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
Function *Callee = CI->getCalledFunction();
}
case Intrinsic::part_select:
- CI->replaceAllUsesWith(LowerBitPartSelect(CI));
+ CI->replaceAllUsesWith(LowerPartSelect(CI));
+ break;
+
+ case Intrinsic::part_set:
+ CI->replaceAllUsesWith(LowerPartSet(CI));
break;
case Intrinsic::stacksave:
projects / oota-llvm.git / commitdiff