+/// 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();
+ 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::WeakLinkage);
+
+ // If we haven't defined the impl function yet, do so now
+ if (F->isDeclaration()) {
+
+ // Get the arguments to the function
+ Function::arg_iterator args = F->arg_begin();
+ Value* Val = args++; Val->setName("Val");
+ Value* Lo = args++; Lo->setName("Lo");
+ Value* Hi = args++; Hi->setName("High");
+
+ // We want to select a range of bits here such that [Hi, Lo] is shifted
+ // down to the low bits. However, it is quite possible that Hi is smaller
+ // than Lo in which case the bits have to be reversed.
+
+ // Create the blocks we will need for the two cases (forward, reverse)
+ BasicBlock* CurBB = BasicBlock::Create("entry", F);
+ BasicBlock *RevSize = BasicBlock::Create("revsize", CurBB->getParent());
+ BasicBlock *FwdSize = BasicBlock::Create("fwdsize", CurBB->getParent());
+ BasicBlock *Compute = BasicBlock::Create("compute", CurBB->getParent());
+ BasicBlock *Reverse = BasicBlock::Create("reverse", CurBB->getParent());
+ BasicBlock *RsltBlk = BasicBlock::Create("result", CurBB->getParent());
+
+ // Cast Hi and Lo to the size of Val so the widths are all the same
+ if (Hi->getType() != Val->getType())
+ Hi = CastInst::CreateIntegerCast(Hi, Val->getType(), false,
+ "tmp", CurBB);
+ if (Lo->getType() != Val->getType())
+ Lo = CastInst::CreateIntegerCast(Lo, 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 Hi and Lo bit positions. This is used to determine
+ // which case we have (forward or reverse)
+ ICmpInst *Cmp = new ICmpInst(ICmpInst::ICMP_ULT, Hi, Lo, "less",CurBB);
+ BranchInst::Create(RevSize, FwdSize, Cmp, CurBB);
+
+ // First, copmute the number of bits in the forward case.
+ Instruction* FBitSize =
+ BinaryOperator::CreateSub(Hi, Lo,"fbits", FwdSize);
+ BranchInst::Create(Compute, FwdSize);
+
+ // Second, compute the number of bits in the reverse case.
+ Instruction* RBitSize =
+ BinaryOperator::CreateSub(Lo, Hi, "rbits", RevSize);
+ BranchInst::Create(Compute, RevSize);
+
+ // Now, compute the bit range. Start by getting the bitsize and the shift
+ // amount (either Hi or Lo) 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 = PHINode::Create(Val->getType(), "bits", Compute);
+ BitSize->reserveOperandSpace(2);
+ BitSize->addIncoming(FBitSize, FwdSize);
+ BitSize->addIncoming(RBitSize, RevSize);
+
+ // Get the ShiftAmount as the smaller of Hi/Lo
+ PHINode *ShiftAmt = PHINode::Create(Val->getType(), "shiftamt", Compute);
+ ShiftAmt->reserveOperandSpace(2);
+ ShiftAmt->addIncoming(Lo, FwdSize);
+ ShiftAmt->addIncoming(Hi, 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);
+ BranchInst::Create(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 = PHINode::Create(Val->getType(), "count", Reverse);
+ Count->reserveOperandSpace(2);
+ Count->addIncoming(BitSizePlusOne, Compute);
+
+ // Next, get the value that we are shifting.
+ PHINode *BitsToShift = PHINode::Create(Val->getType(), "val", Reverse);
+ BitsToShift->reserveOperandSpace(2);
+ BitsToShift->addIncoming(FRes, Compute);
+
+ // Finally, get the result of the last computation
+ PHINode *RRes = PHINode::Create(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);
+ BranchInst::Create(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 = PHINode::Create(Val->getType(), "part_select", CurBB);
+ BitSelect->reserveOperandSpace(2);
+ BitSelect->addIncoming(FRes, Compute);
+ BitSelect->addIncoming(NewRes, Reverse);
+ ReturnInst::Create(BitSelect, CurBB);
+ }
+
+ // Return a call to the implementation function
+ Value *Args[] = {
+ CI->getOperand(1),
+ CI->getOperand(2),
+ CI->getOperand(3)
+ };
+ return CallInst::Create(F, Args, array_endof(Args), 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::WeakLinkage);
+
+ // If we haven't defined the impl function yet, do so now
+ if (F->isDeclaration()) {
+ // 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);
+ ConstantInt* One = ConstantInt::get(Type::Int32Ty, 1);
+ ConstantInt* ValOne = ConstantInt::get(ValTy, 1);
+ ConstantInt* Zero = ConstantInt::get(Type::Int32Ty, 0);
+ ConstantInt* ValZero = ConstantInt::get(ValTy, 0);
+
+ // Basic blocks we fill in below.
+ BasicBlock* entry = BasicBlock::Create("entry", F, 0);
+ BasicBlock* large = BasicBlock::Create("large", F, 0);
+ BasicBlock* small = BasicBlock::Create("small", F, 0);
+ BasicBlock* reverse = BasicBlock::Create("reverse", F, 0);
+ BasicBlock* result = BasicBlock::Create("result", F, 0);
+
+ // BASIC BLOCK: entry
+ // First, get the number of bits that we're placing as an i32
+ ICmpInst* is_forward =
+ new ICmpInst(ICmpInst::ICMP_ULT, Lo, Hi, "", entry);
+ SelectInst* Hi_pn = SelectInst::Create(is_forward, Hi, Lo, "", entry);
+ SelectInst* Lo_pn = SelectInst::Create(is_forward, Lo, Hi, "", entry);
+ BinaryOperator* NumBits = BinaryOperator::CreateSub(Hi_pn, Lo_pn, "",entry);
+ NumBits = BinaryOperator::CreateAdd(NumBits, One, "", entry);
+ // Now, convert Lo and Hi to ValTy bit width
+ if (ValBits > 32) {
+ Lo = new ZExtInst(Lo_pn, ValTy, "", entry);
+ } else if (ValBits < 32) {
+ Lo = new TruncInst(Lo_pn, ValTy, "", entry);
+ } else {
+ Lo = Lo_pn;
+ }
+ // Determine if the replacement bits are larger than the number of bits we
+ // are replacing and deal with it.
+ ICmpInst* is_large =
+ new ICmpInst(ICmpInst::ICMP_ULT, NumBits, RepBitWidth, "", entry);
+ BranchInst::Create(large, small, is_large, entry);
+
+ // BASIC BLOCK: large
+ Instruction* MaskBits =
+ BinaryOperator::CreateSub(RepBitWidth, NumBits, "", large);
+ MaskBits = CastInst::CreateIntegerCast(MaskBits, RepMask->getType(),
+ false, "", large);
+ BinaryOperator* Mask1 =
+ BinaryOperator::CreateLShr(RepMask, MaskBits, "", large);
+ BinaryOperator* Rep2 = BinaryOperator::CreateAnd(Mask1, Rep, "", large);
+ BranchInst::Create(small, large);
+
+ // BASIC BLOCK: small
+ PHINode* Rep3 = PHINode::Create(RepTy, "", small);
+ Rep3->reserveOperandSpace(2);
+ Rep3->addIncoming(Rep2, large);
+ Rep3->addIncoming(Rep, entry);
+ Value* Rep4 = Rep3;
+ if (ValBits > RepBits)
+ Rep4 = new ZExtInst(Rep3, ValTy, "", small);
+ else if (ValBits < RepBits)
+ Rep4 = new TruncInst(Rep3, ValTy, "", small);
+ BranchInst::Create(result, reverse, is_forward, small);
+
+ // BASIC BLOCK: reverse (reverses the bits of the replacement)
+ // Set up our loop counter as a PHI so we can decrement on each iteration.
+ // We will loop for the number of bits in the replacement value.
+ PHINode *Count = PHINode::Create(Type::Int32Ty, "count", reverse);
+ Count->reserveOperandSpace(2);
+ Count->addIncoming(NumBits, small);
+
+ // Get the value that we are shifting bits out of as a PHI because
+ // we'll change this with each iteration.
+ PHINode *BitsToShift = PHINode::Create(Val->getType(), "val", reverse);
+ BitsToShift->reserveOperandSpace(2);
+ BitsToShift->addIncoming(Rep4, small);
+
+ // Get the result of the last computation or zero on first iteration
+ PHINode *RRes = PHINode::Create(Val->getType(), "rres", reverse);
+ RRes->reserveOperandSpace(2);
+ RRes->addIncoming(ValZero, small);
+
+ // Decrement the loop counter by one
+ Instruction *Decr = BinaryOperator::CreateSub(Count, One, "", reverse);
+ Count->addIncoming(Decr, reverse);
+
+ // Get the bit that we want to move into the result
+ Value *Bit = BinaryOperator::CreateAnd(BitsToShift, ValOne, "", reverse);
+
+ // Compute the new value of the bits to shift for the next iteration.
+ Value *NewVal = BinaryOperator::CreateLShr(BitsToShift, ValOne,"", reverse);
+ BitsToShift->addIncoming(NewVal, reverse);
+
+ // Shift the bit we extracted into the low bit of the result.
+ Instruction *NewRes = BinaryOperator::CreateShl(RRes, ValOne, "", reverse);
+ NewRes = BinaryOperator::CreateOr(NewRes, Bit, "", reverse);
+ RRes->addIncoming(NewRes, reverse);
+
+ // Terminate loop if we've moved all the bits.
+ ICmpInst *Cond = new ICmpInst(ICmpInst::ICMP_EQ, Decr, Zero, "", reverse);
+ BranchInst::Create(result, reverse, Cond, reverse);
+
+ // BASIC BLOCK: result
+ PHINode *Rplcmnt = PHINode::Create(Val->getType(), "", result);
+ Rplcmnt->reserveOperandSpace(2);
+ Rplcmnt->addIncoming(NewRes, reverse);
+ Rplcmnt->addIncoming(Rep4, small);
+ Value* t0 = CastInst::CreateIntegerCast(NumBits,ValTy,false,"",result);
+ Value* t1 = BinaryOperator::CreateShl(ValMask, Lo, "", result);
+ Value* t2 = BinaryOperator::CreateNot(t1, "", result);
+ Value* t3 = BinaryOperator::CreateShl(t1, t0, "", result);
+ Value* t4 = BinaryOperator::CreateOr(t2, t3, "", result);
+ Value* t5 = BinaryOperator::CreateAnd(t4, Val, "", result);
+ Value* t6 = BinaryOperator::CreateShl(Rplcmnt, Lo, "", result);
+ Value* Rslt = BinaryOperator::CreateOr(t5, t6, "part_set", result);
+ ReturnInst::Create(Rslt, result);
+ }
+
+ // Return a call to the implementation function
+ Value *Args[] = {
+ CI->getOperand(1),
+ CI->getOperand(2),
+ CI->getOperand(3),
+ CI->getOperand(4)
+ };
+ return CallInst::Create(F, Args, array_endof(Args), CI->getName(), CI);
+}