bool HexagonRemoveExtendArgs::runOnFunction(Function &F) {
unsigned Idx = 1;
for (Function::arg_iterator AI = F.arg_begin(), AE = F.arg_end(); AI != AE;
++AI, ++Idx) {
if (F.getAttributes().hasAttribute(Idx, Attribute::SExt)) {
Argument* Arg = AI;
if (!isa<PointerType>(Arg->getType())) {
for (Instruction::use_iterator UI = Arg->use_begin();
UI != Arg->use_end();) {
if (isa<SExtInst>(*UI)) {
Instruction* Use = cast<Instruction>(*UI);
SExtInst* SI = new SExtInst(Arg, Use->getType());
assert (EVT::getEVT(SI->getType()) ==
(EVT::getEVT(Use->getType())));
++UI;
Use->replaceAllUsesWith(SI);
Instruction* First = F.getEntryBlock().begin();
SI->insertBefore(First);
Use->eraseFromParent();
} else {
++UI;
}
}
}
}
}
return true;
}
/*
* Instrument switch instructions to log the index of the taken branch.
*/
void PandaInstrumentVisitor::visitSwitchInst(SwitchInst &I){
SExtInst *SEI;
CallInst *CI;
std::vector<Value*> argValues;
Function *F = mod->getFunction("log_dynval");
if (!F) {
printf("Instrumentation function not found\n");
assert(1==0);
}
if (I.getCondition()->getType() != wordType){
SEI = static_cast<SExtInst*>(IRB.CreateSExt(I.getCondition(), wordType));
argValues.push_back(ConstantInt::get(ptrType, (uintptr_t)dynval_buffer));
argValues.push_back(ConstantInt::get(intType, SWITCHENTRY));
argValues.push_back(ConstantInt::get(intType, SWITCH));
argValues.push_back(static_cast<Value*>(SEI));
CI = IRB.CreateCall(F, ArrayRef<Value*>(argValues));
CI->insertBefore(static_cast<Instruction*>(&I));
SEI->insertBefore(static_cast<Instruction*>(CI));
}
else {
argValues.push_back(ConstantInt::get(ptrType, (uintptr_t)dynval_buffer));
argValues.push_back(ConstantInt::get(intType, SWITCHENTRY));
argValues.push_back(ConstantInt::get(intType, SWITCH));
argValues.push_back(static_cast<Value*>(I.getCondition()));
CI = IRB.CreateCall(F, ArrayRef<Value*>(argValues));
CI->insertBefore(static_cast<Instruction*>(&I));
}
}
// -- handle SExt instruction --
void UnsafeTypeCastingCheck::handleSExtInstruction (Instruction *inst) {
SExtInst *finst = dyn_cast<SExtInst>(inst);
if (finst == NULL)
utccAbort("handleSExtInstruction cannot process with a non-sext instruction");
assert(finst->getNumOperands() == 1);
UTCC_TYPE fromt = queryExprType(finst->getOperand(0));
setExprType(finst, fromt);
}
bool HexagonOptimizeSZextends::runOnFunction(Function &F) {
unsigned Idx = 1;
// Try to optimize sign extends in formal parameters. It's relying on
// callee already sign extending the values. I'm not sure if our ABI
// requires callee to sign extend though.
for (auto &Arg : F.args()) {
if (F.getAttributes().hasAttribute(Idx, Attribute::SExt)) {
if (!isa<PointerType>(Arg.getType())) {
for (auto UI = Arg.use_begin(); UI != Arg.use_end();) {
if (isa<SExtInst>(*UI)) {
Instruction* Use = cast<Instruction>(*UI);
SExtInst* SI = new SExtInst(&Arg, Use->getType());
assert (EVT::getEVT(SI->getType()) ==
(EVT::getEVT(Use->getType())));
++UI;
Use->replaceAllUsesWith(SI);
Instruction* First = &F.getEntryBlock().front();
SI->insertBefore(First);
Use->eraseFromParent();
} else {
++UI;
}
}
}
}
++Idx;
}
// Try to remove redundant sext operations on Hexagon. The hardware
// already sign extends many 16 bit intrinsic operations to 32 bits.
// For example:
// %34 = tail call i32 @llvm.hexagon.A2.addh.l16.sat.ll(i32 %x, i32 %y)
// %sext233 = shl i32 %34, 16
// %conv52 = ashr exact i32 %sext233, 16
for (auto &B : F) {
for (auto &I : B) {
// Look for arithmetic shift right by 16.
BinaryOperator *Ashr = dyn_cast<BinaryOperator>(&I);
if (!(Ashr && Ashr->getOpcode() == Instruction::AShr))
continue;
Value *AshrOp1 = Ashr->getOperand(1);
ConstantInt *C = dyn_cast<ConstantInt>(AshrOp1);
// Right shifted by 16.
if (!(C && C->getSExtValue() == 16))
continue;
// The first operand of Ashr comes from logical shift left.
Instruction *Shl = dyn_cast<Instruction>(Ashr->getOperand(0));
if (!(Shl && Shl->getOpcode() == Instruction::Shl))
continue;
Value *Intr = Shl->getOperand(0);
Value *ShlOp1 = Shl->getOperand(1);
C = dyn_cast<ConstantInt>(ShlOp1);
// Left shifted by 16.
if (!(C && C->getSExtValue() == 16))
continue;
// The first operand of Shl comes from an intrinsic.
if (IntrinsicInst *I = dyn_cast<IntrinsicInst>(Intr)) {
if (!intrinsicAlreadySextended(I->getIntrinsicID()))
continue;
// All is well. Replace all uses of AShr with I.
for (auto UI = Ashr->user_begin(), UE = Ashr->user_end();
UI != UE; ++UI) {
const Use &TheUse = UI.getUse();
if (Instruction *J = dyn_cast<Instruction>(TheUse.getUser())) {
J->replaceUsesOfWith(Ashr, I);
}
}
}
}
}
return true;
}
void ArrayIndexChecker::visitSExtInst(SExtInst& I) {
DEBUG(dbgs() << "ArrayIndexChecker: visiting SExtInst " << I << "\n");
visitValue(*I.getOperand(0));
DEBUG(dbgs() << "ArrayIndexChecker: visited SExtInst\n");
}
