// Constants smaller than 256 fit in the immediate field of
// Thumb1 instructions so we return a zero cost and 1 otherwise.
int ARMTTIImpl::getIntImmCodeSizeCost(unsigned Opcode, unsigned Idx,
const APInt &Imm, Type *Ty) {
if (Imm.isNonNegative() && Imm.getLimitedValue() < 256)
return 0;
return 1;
}
static std::string APIntToHexString(const APInt &AI) {
unsigned Width = (AI.getBitWidth() / 8) * 2;
std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
unsigned Size = HexString.size();
assert(Width >= Size && "hex string is too large!");
HexString.insert(HexString.begin(), Width - Size, '0');
return HexString;
}
bool RippleElimination::runOnFunction(Function &F) {
std::vector<Instruction*> **RippleLists;
unsigned ListID = 0;
unsigned NumofLists = 0;
RippleLists = new std::vector<Instruction*>*;
RippleLists[ListID] = new std::vector<Instruction*>;
RippleLists[ListID]->clear();
//errs() << "RippleLists[0] size:" << RippleLists[0]->size() << "\n";
for (Function::iterator BB = F.begin(), BE = F.end(); BB != BE; ++BB) {
BasicBlock *BC = dyn_cast<BasicBlock>(BB); //==> how to get an identifier of a BB?
for (BasicBlock::iterator IB = BB->begin(), IE = BB->end(); IB != IE; ++IB) {
// The dyn_cast<> operator is a "checking cast" operation. It checks to
// see if the operand is of the specified type, and if so, returns a
// pointer to it (this operator does not work with references). If the
// operand is not of the correct type, a null pointer is returned.
Instruction *IT = dyn_cast<Instruction>(IB);
Instruction *BackIT;
ICmpInst * cmpinst = dyn_cast<ICmpInst>(IT);
if(cmpinst!=NULL) { // If not a NULL pointer
errs()<< "!!!! In CMP Oh yeah!!!!"<<"\n";
switch(cmpinst->getPredicate()){
case ICmpInst::ICMP_SLE:
{
errs()<<"QQQQ SLE\n";
}
break;
case ICmpInst::ICMP_SLT:
{
Value *op0 = IT->getOperand(0);
Instruction * op0_inst = dyn_cast<Instruction> (op0);
Value *op0_op1 = op0_inst->getOperand(1);
ConstantInt *op0_op1_const = dyn_cast<ConstantInt>(op0_op1);
APInt b = op0_op1_const->getValue();
ConstantInt *op1 = dyn_cast<ConstantInt>(IT->getOperand(1));
APInt a = op1->getValue();
errs() << "CMP Value0 ::" << b.getLimitedValue() << "\n";
errs() << "CMP Value1 ::" << a.getLimitedValue() << "\n";
int aa = a.getLimitedValue();
int bb = b.getLimitedValue();
// errs()<<a.getBitWidth()<<"\n";
errs()<<"The flag adder should be "<<(int)ceil(log(aa)/log(2))<<" bit adder\n";
errs()<<"QQQQ SLT\n";
}
break;
default:
break;
}
}
// Get Binary Operator Instruction::Add
if(dyn_cast<BinaryOperator>(IT)) { // If not a NULL pointer
BinaryOperator* Inst = dyn_cast<BinaryOperator>(IT);
// errs()<<"Zhuangh put: "<<Inst->getOpcode()<<"\n";
if (Inst->getOpcode() == Instruction::Add) {
Value *Op0 = IT->getOperand(0);
Value *Op1 = IT->getOperand(1);
//errs() << "Add Value0 ::" << *Op0 << "\n";
//errs() << "Add Value1 ::" << *Op1 << "\n";
if(RippleLists[0]->empty()) {
RippleLists[0]->push_back(IT);
}
else {
BackIT = dyn_cast<Instruction>(RippleLists[0]->back());
//errs() << "BackIT :" << *BackIT << "\n";
if(BackIT->getName().equals(Op0->getName()) || BackIT->getName().equals(Op1->getName())) {
RippleLists[0]->push_back(IT);
}
}
}
}
} // End Instruction iterator
if(RippleLists[0]->size() < 2) RippleLists[0]->clear(); // No ripple detected
for(std::vector<Instruction*>::iterator RplIT = RippleLists[0]->begin(); RplIT != RippleLists[0]->end(); ++RplIT){
Instruction *Inst = dyn_cast<Instruction>(*RplIT);
errs() << "Ripple Operations:" << *Inst << "\n";
//errs() << "Name:" << Inst->getName().str() << " ";
//errs() << "Op0:" << Inst->getOperand(0)->getName().str() << " ";
//errs() << "Op1:" << Inst->getOperand(1)->getName().str() << "\n";
//It->eraseFromParent();
}
//errs() << "RippleLists[0] size:" << RippleLists[0]->size() << "\n";
errs() << "\n";
RippleLists[0]->clear();
} // End basic block iterator
return true;
}