C++ APInt::getLimitedValue方法代码示例

// 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;
//.........这里部分代码省略.........