C++ const_iterator::isEHPad方法代码示例

//.........这里部分代码省略.........
        assert(DI->getVariable() && "Missing variable");
        assert(DI->getDebugLoc() && "Missing location");
        if (MMI.hasDebugInfo()) {
          // Don't handle byval struct arguments or VLAs, for example.
          // Non-byval arguments are handled here (they refer to the stack
          // temporary alloca at this point).
          const Value *Address = DI->getAddress();
          if (Address) {
            if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Address))
              Address = BCI->getOperand(0);
            if (const AllocaInst *AI = dyn_cast<AllocaInst>(Address)) {
              DenseMap<const AllocaInst *, int>::iterator SI =
                StaticAllocaMap.find(AI);
              if (SI != StaticAllocaMap.end()) { // Check for VLAs.
                int FI = SI->second;
                MMI.setVariableDbgInfo(DI->getVariable(), DI->getExpression(),
                                       FI, DI->getDebugLoc());
              }
            }
          }
        }
      }

      // Decide the preferred extend type for a value.
      PreferredExtendType[&*I] = getPreferredExtendForValue(&*I);
    }

  // Create an initial MachineBasicBlock for each LLVM BasicBlock in F.  This
  // also creates the initial PHI MachineInstrs, though none of the input
  // operands are populated.
  for (BB = Fn->begin(); BB != EB; ++BB) {
    // Don't create MachineBasicBlocks for imaginary EH pad blocks. These blocks
    // are really data, and no instructions can live here.
    if (BB->isEHPad()) {
      const Instruction *I = BB->getFirstNonPHI();
      // If this is a non-landingpad EH pad, mark this function as using
      // funclets.
      // FIXME: SEH catchpads do not create funclets, so we could avoid setting
      // this in such cases in order to improve frame layout.
      if (!isa<LandingPadInst>(I)) {
        MMI.setHasEHFunclets(true);
        MF->getFrameInfo().setHasOpaqueSPAdjustment(true);
      }
      if (isa<CatchSwitchInst>(I)) {
        assert(&*BB->begin() == I &&
               "WinEHPrepare failed to remove PHIs from imaginary BBs");
        continue;
      }
      if (isa<FuncletPadInst>(I))
        assert(&*BB->begin() == I && "WinEHPrepare failed to demote PHIs");
    }

    MachineBasicBlock *MBB = mf.CreateMachineBasicBlock(&*BB);
    MBBMap[&*BB] = MBB;
    MF->push_back(MBB);

    // Transfer the address-taken flag. This is necessary because there could
    // be multiple MachineBasicBlocks corresponding to one BasicBlock, and only
    // the first one should be marked.
    if (BB->hasAddressTaken())
      MBB->setHasAddressTaken();

    // Create Machine PHI nodes for LLVM PHI nodes, lowering them as
    // appropriate.
    for (BasicBlock::const_iterator I = BB->begin();
         const PHINode *PN = dyn_cast<PHINode>(I); ++I) {

//.........这里部分代码省略.........
                                StaticAllocaMap.find(AI);
                            if (SI != StaticAllocaMap.end()) { // Check for VLAs.
                                int FI = SI->second;
                                MMI.setVariableDbgInfo(DI->getVariable(), DI->getExpression(),
                                                       FI, DI->getDebugLoc());
                            }
                        }
                    }
                }
            }

            // Decide the preferred extend type for a value.
            PreferredExtendType[I] = getPreferredExtendForValue(I);
        }

    // Create an initial MachineBasicBlock for each LLVM BasicBlock in F.  This
    // also creates the initial PHI MachineInstrs, though none of the input
    // operands are populated.
    for (BB = Fn->begin(); BB != EB; ++BB) {
        MachineBasicBlock *MBB = mf.CreateMachineBasicBlock(BB);
        MBBMap[BB] = MBB;
        MF->push_back(MBB);

        // Transfer the address-taken flag. This is necessary because there could
        // be multiple MachineBasicBlocks corresponding to one BasicBlock, and only
        // the first one should be marked.
        if (BB->hasAddressTaken())
            MBB->setHasAddressTaken();

        // Create Machine PHI nodes for LLVM PHI nodes, lowering them as
        // appropriate.
        for (BasicBlock::const_iterator I = BB->begin();
                const PHINode *PN = dyn_cast<PHINode>(I); ++I) {
            if (PN->use_empty()) continue;

            // Skip empty types
            if (PN->getType()->isEmptyTy())
                continue;

            DebugLoc DL = PN->getDebugLoc();
            unsigned PHIReg = ValueMap[PN];
            assert(PHIReg && "PHI node does not have an assigned virtual register!");

            SmallVector<EVT, 4> ValueVTs;
            ComputeValueVTs(*TLI, MF->getDataLayout(), PN->getType(), ValueVTs);
            for (unsigned vti = 0, vte = ValueVTs.size(); vti != vte; ++vti) {
                EVT VT = ValueVTs[vti];
                unsigned NumRegisters = TLI->getNumRegisters(Fn->getContext(), VT);
                const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
                for (unsigned i = 0; i != NumRegisters; ++i)
                    BuildMI(MBB, DL, TII->get(TargetOpcode::PHI), PHIReg + i);
                PHIReg += NumRegisters;
            }
        }
    }

    // Mark landing pad blocks.
    SmallVector<const LandingPadInst *, 4> LPads;
    for (BB = Fn->begin(); BB != EB; ++BB) {
        if (BB->isEHPad())
            MBBMap[BB]->setIsEHPad();
        const Instruction *FNP = BB->getFirstNonPHI();
        if (const auto *LPI = dyn_cast<LandingPadInst>(FNP))
            LPads.push_back(LPI);
    }

    // If this is an MSVC EH personality, we need to do a bit more work.
    if (!Fn->hasPersonalityFn())
        return;
    EHPersonality Personality = classifyEHPersonality(Fn->getPersonalityFn());
    if (!isMSVCEHPersonality(Personality))
        return;

    if (Personality == EHPersonality::MSVC_Win64SEH ||
            Personality == EHPersonality::MSVC_X86SEH) {
        addSEHHandlersForLPads(LPads);
    }

    WinEHFuncInfo &EHInfo = MMI.getWinEHFuncInfo(&fn);
    if (Personality == EHPersonality::MSVC_CXX) {
        // Calculate state numbers and then map from funclet BBs to MBBs.
        const Function *WinEHParentFn = MMI.getWinEHParent(&fn);
        calculateWinCXXEHStateNumbers(WinEHParentFn, EHInfo);
        for (WinEHTryBlockMapEntry &TBME : EHInfo.TryBlockMap)
            for (WinEHHandlerType &H : TBME.HandlerArray)
                if (const auto *BB = dyn_cast<BasicBlock>(H.Handler))
                    H.HandlerMBB = MBBMap[BB];
    }

    // Copy the state numbers to LandingPadInfo for the current function, which
    // could be a handler or the parent. This should happen for 32-bit SEH and
    // C++ EH.
    if (Personality == EHPersonality::MSVC_CXX ||
            Personality == EHPersonality::MSVC_X86SEH) {
        for (const LandingPadInst *LP : LPads) {
            MachineBasicBlock *LPadMBB = MBBMap[LP->getParent()];
            MMI.addWinEHState(LPadMBB, EHInfo.EHPadStateMap[LP]);
        }
    }
}