C++ iterator::hasMetadata方法代码示例

void DebugDatabase::addIRInstructions(GenerateRTL *hw) {
    Function *F = hw->getFunction();
    int instr_count = 0;
    for (Function::iterator b = F->begin(), be = F->end(); b != be; b++) {
        for (BasicBlock::iterator i = b->begin(), ie = b->end(); i != ie; i++) {

            instr_count++;

            bool isDummyDbgCall = false;
            if (isa<DbgDeclareInst>(i) || isa<DbgValueInst>(i))
                isDummyDbgCall = true;

            if (i->hasMetadata()) {
                MDNode *n = i->getMetadata("dbg");
                DILocation loc(n);
                int lineNumber = loc.getLineNumber();
                int columnNumber = loc.getColumnNumber();
                std::string filePath =
                    loc.getDirectory().str() + "/" + loc.getFilename().str();

                addIRInstruction(hw, i, instr_count, isDummyDbgCall, filePath,
                                 lineNumber, columnNumber);
            } else {
                addIRInstruction(hw, i, instr_count, isDummyDbgCall, "", 0, 0);
            }
        }
    }
}

/// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto,
/// except that it does some simple constant prop and DCE on the fly.  The
/// effect of this is to copy significantly less code in cases where (for
/// example) a function call with constant arguments is inlined, and those
/// constant arguments cause a significant amount of code in the callee to be
/// dead.  Since this doesn't produce an exact copy of the input, it can't be
/// used for things like CloneFunction or CloneModule.
void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
                                     DenseMap<const Value*, Value*> &ValueMap,
                                     SmallVectorImpl<ReturnInst*> &Returns,
                                     const char *NameSuffix, 
                                     ClonedCodeInfo *CodeInfo,
                                     const TargetData *TD,
                                     Instruction *TheCall) {
  assert(NameSuffix && "NameSuffix cannot be null!");
  
#ifndef NDEBUG
  for (Function::const_arg_iterator II = OldFunc->arg_begin(), 
       E = OldFunc->arg_end(); II != E; ++II)
    assert(ValueMap.count(II) && "No mapping from source argument specified!");
#endif

  PruningFunctionCloner PFC(NewFunc, OldFunc, ValueMap, Returns,
                            NameSuffix, CodeInfo, TD);

  // Clone the entry block, and anything recursively reachable from it.
  std::vector<const BasicBlock*> CloneWorklist;
  CloneWorklist.push_back(&OldFunc->getEntryBlock());
  while (!CloneWorklist.empty()) {
    const BasicBlock *BB = CloneWorklist.back();
    CloneWorklist.pop_back();
    PFC.CloneBlock(BB, CloneWorklist);
  }
  
  // Loop over all of the basic blocks in the old function.  If the block was
  // reachable, we have cloned it and the old block is now in the value map:
  // insert it into the new function in the right order.  If not, ignore it.
  //
  // Defer PHI resolution until rest of function is resolved.
  SmallVector<const PHINode*, 16> PHIToResolve;
  for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end();
       BI != BE; ++BI) {
    BasicBlock *NewBB = cast_or_null<BasicBlock>(ValueMap[BI]);
    if (NewBB == 0) continue;  // Dead block.

    // Add the new block to the new function.
    NewFunc->getBasicBlockList().push_back(NewBB);
    
    // Loop over all of the instructions in the block, fixing up operand
    // references as we go.  This uses ValueMap to do all the hard work.
    //
    BasicBlock::iterator I = NewBB->begin();

    LLVMContext &Context = OldFunc->getContext();
    unsigned DbgKind = Context.getMetadata().getMDKind("dbg");
    MDNode *TheCallMD = NULL;
    SmallVector<Value *, 4> MDVs;
    if (TheCall && TheCall->hasMetadata()) 
      TheCallMD = Context.getMetadata().getMD(DbgKind, TheCall);
    
    // Handle PHI nodes specially, as we have to remove references to dead
    // blocks.
    if (PHINode *PN = dyn_cast<PHINode>(I)) {
      // Skip over all PHI nodes, remembering them for later.
      BasicBlock::const_iterator OldI = BI->begin();
      for (; (PN = dyn_cast<PHINode>(I)); ++I, ++OldI) {
        if (I->hasMetadata()) {
          if (TheCallMD) {
            if (MDNode *IMD = Context.getMetadata().getMD(DbgKind, I)) {
              MDNode *NewMD = UpdateInlinedAtInfo(IMD, TheCallMD, Context);
              Context.getMetadata().addMD(DbgKind, NewMD, I);
            }
          } else {
            // The cloned instruction has dbg info but the call instruction
            // does not have dbg info. Remove dbg info from cloned instruction.
            Context.getMetadata().removeMD(DbgKind, I);
          }
        }
        PHIToResolve.push_back(cast<PHINode>(OldI));
      }
    }
    
    // Otherwise, remap the rest of the instructions normally.
    for (; I != NewBB->end(); ++I) {
      if (I->hasMetadata()) {
        if (TheCallMD) {
          if (MDNode *IMD = Context.getMetadata().getMD(DbgKind, I)) {
            MDNode *NewMD = UpdateInlinedAtInfo(IMD, TheCallMD, Context);
            Context.getMetadata().addMD(DbgKind, NewMD, I);
          }
        } else {
          // The cloned instruction has dbg info but the call instruction
          // does not have dbg info. Remove dbg info from cloned instruction.
          Context.getMetadata().removeMD(DbgKind, I);
        }
      }
      RemapInstruction(I, ValueMap);
    }
  }
  
//.........这里部分代码省略.........