reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/CodeGen/AsmPrinter.h

   37 class BlockAddress;

include/llvm/CodeGen/MachineFunction.h

   49 class BlockAddress;

include/llvm/CodeGen/MachineOperand.h

   25 class BlockAddress;

include/llvm/CodeGen/SelectionDAG.h

   60 class BlockAddress;

lib/Target/ARM/ARMConstantPoolValue.h

   26 class BlockAddress;

References

include/llvm/Analysis/LazyCallGraph.h

 1089       if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
 1089       if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) {

include/llvm/CodeGen/AsmPrinter.h

  467   MCSymbol *GetBlockAddressSymbol(const BlockAddress *BA) const;

include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

 1212   MachineInstrBuilder buildBlockAddress(Register Res, const BlockAddress *BA);

include/llvm/CodeGen/MachineFunction.h

  207   const BlockAddress *RecoverBA;
  892                           const BlockAddress *RecoverBA);

include/llvm/CodeGen/MachineInstrBuilder.h

  181   const MachineInstrBuilder &addBlockAddress(const BlockAddress *BA,

include/llvm/CodeGen/MachineOperand.h

  192         const BlockAddress *BA;   // For MO_BlockAddress.
  561   const BlockAddress *getBlockAddress() const {
  849   static MachineOperand CreateBA(const BlockAddress *BA, int64_t Offset,

include/llvm/CodeGen/SelectionDAG.h

  688   SDValue getBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset = 0,
  690   SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT,

include/llvm/CodeGen/SelectionDAGNodes.h

 2086   const BlockAddress *BA;
 2090   BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
 2096   const BlockAddress *getBlockAddress() const { return BA; }

include/llvm/IR/Constants.h

  851   static BlockAddress *get(Function *F, BasicBlock *BB);
  855   static BlockAddress *get(BasicBlock *BB);
  860   static BlockAddress *lookup(const BasicBlock *BB);
  876   public FixedNumOperandTraits<BlockAddress, 2> {

include/llvm/IR/OperandTraits.h

   31   static Use *op_begin(SubClass* U) {
   33         !std::is_polymorphic<SubClass>::value,
   37   static Use *op_end(SubClass* U) {

include/llvm/IR/User.h

  127   template <int Idx, typename U> static Use &OpFrom(const U *that) {
  129       ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
  130       : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];

include/llvm/Support/Casting.h

   58     return To::classof(&Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  360                             typename cast_retty<X, Y>::ret_type>::type
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

lib/Analysis/InlineCost.cpp

 1848       for (User *U : BlockAddress::get(&*BB)->users())
 2101       for (User *U : BlockAddress::get(&*BI)->users())

lib/Analysis/ModuleSummaryAnalysis.cpp

  107       if (isa<BlockAddress>(Operand)) {

lib/AsmParser/LLParser.cpp

 3301     ID.ConstantVal = BlockAddress::get(F, BB);
 5567     GV->replaceAllUsesWith(BlockAddress::get(&F, BB));

lib/Bitcode/Reader/BitcodeReader.cpp

 2817       V = BlockAddress::get(Fn, BB);

lib/Bitcode/Writer/BitcodeWriter.cpp

 2516     } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
 2516     } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 2177   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
 2177   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
 2780 MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const {

lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

  432               const BlockAddress *BA = MI->getOperand(OpNo).getBlockAddress();

lib/CodeGen/GlobalISel/IRTranslator.cpp

 2165   } else if (auto *BA = dyn_cast<BlockAddress>(&C)) {

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

  910 MachineIRBuilder::buildBlockAddress(Register Res, const BlockAddress *BA) {

lib/CodeGen/IndirectBrExpandPass.cpp

  124       return isa<BlockAddress>(U.getUser());
  135     auto *BA = cast<BlockAddress>(BlockAddressUseIt->getUser());
  135     auto *BA = cast<BlockAddress>(BlockAddressUseIt->getUser());

lib/CodeGen/MIRParser/MIParser.cpp

 2198   Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);

lib/CodeGen/MachineFunction.cpp

  768                                          const BlockAddress *RecoverBA) {

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 1805 SDValue SelectionDAG::getBlockAddress(const BlockAddress *BA, EVT VT,

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 1526     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
 1526     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
 8073         const auto *BA = cast<BlockAddress>(OpInfo.CallOperandVal);
 8073         const auto *BA = cast<BlockAddress>(OpInfo.CallOperandVal);

lib/IR/AsmWriter.cpp

  198   if (auto *BA = dyn_cast<BlockAddress>(V))
 1386   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
 1386   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {

lib/IR/BasicBlock.cpp

   75       BlockAddress *BA = cast<BlockAddress>(user_back());
   75       BlockAddress *BA = cast<BlockAddress>(user_back());

lib/IR/ConstantFold.cpp

 1542       !isa<BlockAddress>(V1)) {
 1544         !isa<BlockAddress>(V2)) {
 1585     } else if (isa<BlockAddress>(V2)) {
 1599   } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(V1)) {
 1599   } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(V1)) {
 1611     if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {
 1611     if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {

lib/IR/Constants.cpp

  517   if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
  517   if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
  533         if (isa<BlockAddress>(LHSOp0) && isa<BlockAddress>(RHSOp0) &&
  533         if (isa<BlockAddress>(LHSOp0) && isa<BlockAddress>(RHSOp0) &&
  534             cast<BlockAddress>(LHSOp0)->getFunction() ==
  535                 cast<BlockAddress>(RHSOp0)->getFunction())
 1460 BlockAddress *BlockAddress::get(BasicBlock *BB) {
 1465 BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) {
 1466   BlockAddress *&BA =
 1469     BA = new BlockAddress(F, BB);
 1483 BlockAddress *BlockAddress::lookup(const BasicBlock *BB) {
 1489   BlockAddress *BA =
 1517   BlockAddress *&NewBA =

lib/IR/Core.cpp

 1815   return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB)));

lib/IR/Function.cpp

 1423     if (isa<BlockAddress>(FU))
 1448     if (!isa<BlockAddress>(U))

lib/IR/Instructions.cpp

  823     BlockAddress *Old = BlockAddress::get(OldBB);
  823     BlockAddress *Old = BlockAddress::get(OldBB);
  824     BlockAddress *New = BlockAddress::get(B);
  824     BlockAddress *New = BlockAddress::get(B);
  826       if (dyn_cast<BlockAddress>(getArgOperand(ArgNo)) == Old)

lib/IR/LLVMContextImpl.h

 1308   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>

lib/IR/Verifier.cpp

 2511       if (auto *BA = dyn_cast<BlockAddress>(V))
 2511       if (auto *BA = dyn_cast<BlockAddress>(V))

lib/Target/AArch64/AArch64InstructionSelector.cpp

 1140           MF, MachineOperand::CreateBA(cast<BlockAddress>(V),

lib/Target/ARM/ARMAsmPrinter.cpp

  890     const BlockAddress *BA =

lib/Target/ARM/ARMConstantPoolValue.cpp

  187 const BlockAddress *ARMConstantPoolConstant::getBlockAddress() const {
  188   return dyn_cast_or_null<BlockAddress>(CVal);

lib/Target/ARM/ARMConstantPoolValue.h

  177   const BlockAddress *getBlockAddress() const;

lib/Target/ARM/ARMISelLowering.cpp

 3028   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();

lib/Target/AVR/AVRExpandPseudoInsts.cpp

  511     const BlockAddress *BA = MI.getOperand(1).getBlockAddress();

lib/Target/AVR/AVRISelLowering.cpp

  414   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();

lib/Target/Hexagon/HexagonConstExtenders.cpp

  343         const BlockAddress *BA; // MO_BlockAddress

lib/Target/Hexagon/HexagonHardwareLoops.cpp

 1276   BlockAddress::get(const_cast<BasicBlock *>(LoopStart->getBasicBlock()));

lib/Target/Hexagon/HexagonISelLowering.cpp

 1050   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();

lib/Target/Lanai/LanaiISelLowering.cpp

 1195   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();

lib/Target/MSP430/MSP430ISelDAGToDAG.cpp

   50     const BlockAddress *BlockAddr;

lib/Target/MSP430/MSP430ISelLowering.cpp

 1021   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();

lib/Target/PowerPC/PPCISelLowering.cpp

 2814   const BlockAddress *BA = BASDN->getBlockAddress();

lib/Target/SystemZ/SystemZISelLowering.cpp

 3017   const BlockAddress *BA = Node->getBlockAddress();

lib/Target/X86/X86ISelDAGToDAG.cpp

   70     const BlockAddress *BlockAddr;

lib/Target/X86/X86ISelLowering.cpp

17840   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();

lib/Target/XCore/XCoreISelLowering.cpp

  314   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();

lib/Transforms/IPO/GlobalOpt.cpp

 2105     if (isa<BlockAddress>(U))
 2123     if (isa<BlockAddress>(U))
 2146     if (isa<BlockAddress>(U))
 2187     if (isa<BlockAddress>(U))
 2204     if (isa<BlockAddress>(U))

lib/Transforms/IPO/IPConstantPropagation.cpp

   62     if (isa<BlockAddress>(UR)) continue;

lib/Transforms/IPO/LowerTypeTests.cpp

 1721     if (isa<BlockAddress>(U.getUser()))

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  856           BlockAddress *BA = dyn_cast<BlockAddress>(*UI);
  856           BlockAddress *BA = dyn_cast<BlockAddress>(*UI);
  860                 BlockAddress::get(NewF, BA->getBasicBlock()));
 1198     if (isa<Function>(Obj) || isa<BlockAddress>(Obj))

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  680           BlockAddress::get(AllBlocks[i]), IntptrPtrTy));

lib/Transforms/Scalar/JumpThreading.cpp

  582     return dyn_cast<BlockAddress>(Val->stripPointerCasts());
  987   BlockAddress *BA = BlockAddress::get(BB);
  987   BlockAddress *BA = BlockAddress::get(BB);
 1646       DestBB = cast<BlockAddress>(Val)->getBasicBlock();

lib/Transforms/Scalar/SCCP.cpp

  166   BlockAddress *getBlockAddress() const {
  168       return dyn_cast<BlockAddress>(getConstant());
  720     BlockAddress *Addr = IBRValue.getBlockAddress();
 1708         IBR->setAddress(BlockAddress::get(IBR->getSuccessor(0)));
 1987     if (!isa<BlockAddress>(IBR->getAddress()->stripPointerCasts())) {
 1990       C = BlockAddress::get(IBR->getSuccessor(0));

lib/Transforms/Utils/CloneFunction.cpp

  182       Constant *OldBBAddr = BlockAddress::get(const_cast<Function*>(OldFunc),
  184       VMap[OldBBAddr] = BlockAddress::get(NewFunc, CBB);
  324     Constant *OldBBAddr = BlockAddress::get(const_cast<Function*>(OldFunc),
  326     VMap[OldBBAddr] = BlockAddress::get(NewFunc, NewBB);

lib/Transforms/Utils/CodeExtractor.cpp

  104     if (isa<BlockAddress const>(Curr))

lib/Transforms/Utils/Evaluator.cpp

   70   if (C->getNumOperands() == 0 || isa<BlockAddress>(C))
  627         if (BlockAddress *BA = dyn_cast<BlockAddress>(Val))
  627         if (BlockAddress *BA = dyn_cast<BlockAddress>(Val))

lib/Transforms/Utils/FunctionComparator.cpp

  357     const BlockAddress *LBA = cast<BlockAddress>(L);
  357     const BlockAddress *LBA = cast<BlockAddress>(L);
  358     const BlockAddress *RBA = cast<BlockAddress>(R);
  358     const BlockAddress *RBA = cast<BlockAddress>(R);

lib/Transforms/Utils/Local.cpp

  303     if (auto *BA =
  304           dyn_cast<BlockAddress>(IBI->getAddress()->stripPointerCasts())) {
  706     BlockAddress *BA = BlockAddress::get(DestBB);
  706     BlockAddress *BA = BlockAddress::get(DestBB);

lib/Transforms/Utils/SimplifyCFG.cpp

 3559   BlockAddress *TBA = dyn_cast<BlockAddress>(SI->getTrueValue());
 3559   BlockAddress *TBA = dyn_cast<BlockAddress>(SI->getTrueValue());
 3560   BlockAddress *FBA = dyn_cast<BlockAddress>(SI->getFalseValue());
 3560   BlockAddress *FBA = dyn_cast<BlockAddress>(SI->getFalseValue());

lib/Transforms/Utils/SplitModule.cpp

  136         BlockAddress *BA = BlockAddress::lookup(&BB);
  136         BlockAddress *BA = BlockAddress::lookup(&BB);

lib/Transforms/Utils/ValueMapper.cpp

   60   DelayedBasicBlock(const BlockAddress &Old)
  181   Value *mapBlockAddress(const BlockAddress &BA);
  415   if (BlockAddress *BA = dyn_cast<BlockAddress>(C))
  415   if (BlockAddress *BA = dyn_cast<BlockAddress>(C))
  490 Value *Mapper::mapBlockAddress(const BlockAddress &BA) {
  504   return getVM()[&BA] = BlockAddress::get(F, BB ? BB : BA.getBasicBlock());

tools/bugpoint/ExtractFunction.cpp

   67     if (BlockAddress *BA = dyn_cast<BlockAddress>(V)) {
   67     if (BlockAddress *BA = dyn_cast<BlockAddress>(V)) {

tools/clang/lib/CodeGen/CGDecl.cpp

  867       isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
  904       isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||

tools/clang/lib/CodeGen/CGStmt.cpp

 2224         llvm::BlockAddress *BA =
 2225             llvm::BlockAddress::get(CurFn, Dest.getBlock());

tools/clang/lib/CodeGen/CodeGenFunction.cpp

 1691 llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) {
 1700   return llvm::BlockAddress::get(CurFn, BB);

tools/clang/lib/CodeGen/CodeGenFunction.h

 2383   llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);

tools/llvm-diff/DifferenceEngine.cpp

  406     if (isa<BlockAddress>(L))
  407       return Blocks[cast<BlockAddress>(L)->getBasicBlock()]
  408                  == cast<BlockAddress>(R)->getBasicBlock();

unittests/IR/InstructionsTest.cpp

 1106   BlockAddress *IndirectBA = BlockAddress::get(CBI.getIndirectDest(0));
 1106   BlockAddress *IndirectBA = BlockAddress::get(CBI.getIndirectDest(0));
 1107   BlockAddress *ArgBA = cast<BlockAddress>(CBI.getArgOperand(0));
 1107   BlockAddress *ArgBA = cast<BlockAddress>(CBI.getArgOperand(0));

unittests/Linker/LinkModulesTest.cpp

   47     Constant *SwitchCase1BA = BlockAddress::get(SwitchCase1BB);
   50     Constant *SwitchCase2BA = BlockAddress::get(SwitchCase2BB);

utils/unittest/googletest/include/gtest/gtest-printers.h

  407                     T* p, ::std::ostream* os) {
  416     if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {