-/// 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);
- }
- // 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);