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

References

include/llvm/MC/MCExpr.h
  463   static const MCBinaryExpr *create(Opcode Op, const MCExpr *LHS,
  467   static const MCBinaryExpr *createAdd(const MCExpr *LHS, const MCExpr *RHS,
  472   static const MCBinaryExpr *createAnd(const MCExpr *LHS, const MCExpr *RHS,
  477   static const MCBinaryExpr *createDiv(const MCExpr *LHS, const MCExpr *RHS,
  482   static const MCBinaryExpr *createEQ(const MCExpr *LHS, const MCExpr *RHS,
  487   static const MCBinaryExpr *createGT(const MCExpr *LHS, const MCExpr *RHS,
  492   static const MCBinaryExpr *createGTE(const MCExpr *LHS, const MCExpr *RHS,
  497   static const MCBinaryExpr *createLAnd(const MCExpr *LHS, const MCExpr *RHS,
  502   static const MCBinaryExpr *createLOr(const MCExpr *LHS, const MCExpr *RHS,
  507   static const MCBinaryExpr *createLT(const MCExpr *LHS, const MCExpr *RHS,
  512   static const MCBinaryExpr *createLTE(const MCExpr *LHS, const MCExpr *RHS,
  517   static const MCBinaryExpr *createMod(const MCExpr *LHS, const MCExpr *RHS,
  522   static const MCBinaryExpr *createMul(const MCExpr *LHS, const MCExpr *RHS,
  527   static const MCBinaryExpr *createNE(const MCExpr *LHS, const MCExpr *RHS,
  532   static const MCBinaryExpr *createOr(const MCExpr *LHS, const MCExpr *RHS,
  537   static const MCBinaryExpr *createShl(const MCExpr *LHS, const MCExpr *RHS,
  542   static const MCBinaryExpr *createAShr(const MCExpr *LHS, const MCExpr *RHS,
  547   static const MCBinaryExpr *createLShr(const MCExpr *LHS, const MCExpr *RHS,
  552   static const MCBinaryExpr *createSub(const MCExpr *LHS, const MCExpr *RHS,
  557   static const MCBinaryExpr *createXor(const MCExpr *LHS, const MCExpr *RHS,
include/llvm/Support/Casting.h
   58     return To::classof(&Val);
   77     return isa_impl<To, From>::doit(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,
  168   using ret_type = const To &; // Normal 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) {
  258   return cast_convert_val<X, Y,
  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;
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
 1191     const MCExpr *SizeExp = MCBinaryExpr::createSub(
 1333   if (isa<GlobalAlias>(&GIS) && MAI->hasAltEntry() && isa<MCBinaryExpr>(Expr))
 1837                                     MCBinaryExpr::createSub(LHS, Base,
 1913     Value = MCBinaryExpr::createSub(Value, Base, OutContext);
 2136     Expr = MCBinaryExpr::createAdd(
 2213     return MCBinaryExpr::createAdd(Base, MCConstantExpr::create(Offset, Ctx),
 2260     return MCBinaryExpr::createAnd(OpExpr, MaskExpr, Ctx);
 2275           RelocExpr = MCBinaryExpr::createSub(
 2280           RelocExpr = MCBinaryExpr::createAdd(
 2303     case Instruction::Add: return MCBinaryExpr::createAdd(LHS, RHS, Ctx);
 2304     case Instruction::Sub: return MCBinaryExpr::createSub(LHS, RHS, Ctx);
 2305     case Instruction::Mul: return MCBinaryExpr::createMul(LHS, RHS, Ctx);
 2306     case Instruction::SDiv: return MCBinaryExpr::createDiv(LHS, RHS, Ctx);
 2307     case Instruction::SRem: return MCBinaryExpr::createMod(LHS, RHS, Ctx);
 2308     case Instruction::Shl: return MCBinaryExpr::createShl(LHS, RHS, Ctx);
 2309     case Instruction::And: return MCBinaryExpr::createAnd(LHS, RHS, Ctx);
 2310     case Instruction::Or:  return MCBinaryExpr::createOr (LHS, RHS, Ctx);
 2311     case Instruction::Xor: return MCBinaryExpr::createXor(LHS, RHS, Ctx);
lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
  139   return MCBinaryExpr::createSub(AfterRef, StartRef, MC);
lib/CodeGen/AsmPrinter/WasmException.cpp
   63   const MCExpr *SizeExp = MCBinaryExpr::createSub(
lib/CodeGen/AsmPrinter/WinException.cpp
  317   return MCBinaryExpr::createAdd(create32bitRef(Label),
  324   return MCBinaryExpr::createSub(
  331   return MCBinaryExpr::createAdd(getOffset(OffsetOf, OffsetFrom),
  580   const MCExpr *EntryCount = MCBinaryExpr::createDiv(LabelDiff, EntrySize, Ctx);
lib/CodeGen/FaultMaps.cpp
   37   const MCExpr *FaultingOffset = MCBinaryExpr::createSub(
   41   const MCExpr *HandlerOffset = MCBinaryExpr::createSub(
lib/CodeGen/StackMaps.cpp
  342   const MCExpr *CSOffsetExpr = MCBinaryExpr::createSub(
lib/CodeGen/TargetLoweringObjectFileImpl.cpp
  818   return MCBinaryExpr::createSub(
 1183     return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
 1186     MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx);
 1187   return MCBinaryExpr::createSub(LHS, RHS, Ctx);
 1798   return MCBinaryExpr::createSub(
lib/MC/MCAsmInfo.cpp
  100   return MCBinaryExpr::createSub(Res, PC, Context);
lib/MC/MCAssembler.cpp
 1002       const MCBinaryExpr *ABE = cast<MCBinaryExpr>(&DF.getAddrDelta());
 1002       const MCBinaryExpr *ABE = cast<MCBinaryExpr>(&DF.getAddrDelta());
lib/MC/MCCodeView.cpp
  451       MCBinaryExpr::create(MCBinaryExpr::Sub, EndRef, BeginRef, Ctx);
  451       MCBinaryExpr::create(MCBinaryExpr::Sub, EndRef, BeginRef, Ctx);
  652       const MCBinaryExpr *BE =
  653           MCBinaryExpr::createAdd(SRE, MCConstantExpr::create(Bias, Ctx), Ctx);
lib/MC/MCDisassembler/MCExternalSymbolizer.cpp
  119       LHS = MCBinaryExpr::createSub(Add, Sub, Ctx);
  123       Expr = MCBinaryExpr::createAdd(LHS, Off, Ctx);
  128       Expr = MCBinaryExpr::createAdd(Add, Off, Ctx);
lib/MC/MCDwarf.cpp
  125     MCBinaryExpr::create(MCBinaryExpr::Sub, Res, RHS, MCOS.getContext());
  125     MCBinaryExpr::create(MCBinaryExpr::Sub, Res, RHS, MCOS.getContext());
  129     MCBinaryExpr::create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext());
  129     MCBinaryExpr::create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext());
  141   const MCExpr *Res = MCBinaryExpr::create(MCBinaryExpr::Add, LHS, RHS, Ctx);
  141   const MCExpr *Res = MCBinaryExpr::create(MCBinaryExpr::Add, LHS, RHS, Ctx);
lib/MC/MCELFStreamer.cpp
  391     const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
  391     const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
lib/MC/MCExpr.cpp
   91     const MCBinaryExpr &BE = cast<MCBinaryExpr>(*this);
   91     const MCBinaryExpr &BE = cast<MCBinaryExpr>(*this);
  103     case MCBinaryExpr::Add:
  114     case MCBinaryExpr::AShr: OS << ">>"; break;
  115     case MCBinaryExpr::And:  OS <<  '&'; break;
  116     case MCBinaryExpr::Div:  OS <<  '/'; break;
  117     case MCBinaryExpr::EQ:   OS << "=="; break;
  118     case MCBinaryExpr::GT:   OS <<  '>'; break;
  119     case MCBinaryExpr::GTE:  OS << ">="; break;
  120     case MCBinaryExpr::LAnd: OS << "&&"; break;
  121     case MCBinaryExpr::LOr:  OS << "||"; break;
  122     case MCBinaryExpr::LShr: OS << ">>"; break;
  123     case MCBinaryExpr::LT:   OS <<  '<'; break;
  124     case MCBinaryExpr::LTE:  OS << "<="; break;
  125     case MCBinaryExpr::Mod:  OS <<  '%'; break;
  126     case MCBinaryExpr::Mul:  OS <<  '*'; break;
  127     case MCBinaryExpr::NE:   OS << "!="; break;
  128     case MCBinaryExpr::Or:   OS <<  '|'; break;
  129     case MCBinaryExpr::Shl:  OS << "<<"; break;
  130     case MCBinaryExpr::Sub:  OS <<  '-'; break;
  131     case MCBinaryExpr::Xor:  OS <<  '^'; break;
  158 const MCBinaryExpr *MCBinaryExpr::create(Opcode Opc, const MCExpr *LHS,
  161   return new (Ctx) MCBinaryExpr(Opc, LHS, RHS, Loc);
  783     const MCBinaryExpr *ABE = cast<MCBinaryExpr>(this);
  783     const MCBinaryExpr *ABE = cast<MCBinaryExpr>(this);
  794           case MCBinaryExpr::EQ:
  797           case MCBinaryExpr::NE:
  812       case MCBinaryExpr::Sub:
  819       case MCBinaryExpr::Add:
  833     case MCBinaryExpr::AShr: Result = LHS >> RHS; break;
  834     case MCBinaryExpr::Add:  Result = LHS + RHS; break;
  835     case MCBinaryExpr::And:  Result = LHS & RHS; break;
  836     case MCBinaryExpr::Div:
  837     case MCBinaryExpr::Mod:
  846       if (ABE->getOpcode() == MCBinaryExpr::Div)
  851     case MCBinaryExpr::EQ:   Result = LHS == RHS; break;
  852     case MCBinaryExpr::GT:   Result = LHS > RHS; break;
  853     case MCBinaryExpr::GTE:  Result = LHS >= RHS; break;
  854     case MCBinaryExpr::LAnd: Result = LHS && RHS; break;
  855     case MCBinaryExpr::LOr:  Result = LHS || RHS; break;
  856     case MCBinaryExpr::LShr: Result = uint64_t(LHS) >> uint64_t(RHS); break;
  857     case MCBinaryExpr::LT:   Result = LHS < RHS; break;
  858     case MCBinaryExpr::LTE:  Result = LHS <= RHS; break;
  859     case MCBinaryExpr::Mul:  Result = LHS * RHS; break;
  860     case MCBinaryExpr::NE:   Result = LHS != RHS; break;
  861     case MCBinaryExpr::Or:   Result = LHS | RHS; break;
  862     case MCBinaryExpr::Shl:  Result = uint64_t(LHS) << uint64_t(RHS); break;
  863     case MCBinaryExpr::Sub:  Result = LHS - RHS; break;
  864     case MCBinaryExpr::Xor:  Result = LHS ^ RHS; break;
  871     case MCBinaryExpr::EQ:
  872     case MCBinaryExpr::GT:
  873     case MCBinaryExpr::GTE:
  874     case MCBinaryExpr::LT:
  875     case MCBinaryExpr::LTE:
  876     case MCBinaryExpr::NE:
  908     const MCBinaryExpr *BE = cast<MCBinaryExpr>(this);
  908     const MCBinaryExpr *BE = cast<MCBinaryExpr>(this);
  919     if (BE->getOpcode() == MCBinaryExpr::Sub)
lib/MC/MCObjectStreamer.cpp
  414       MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
  414       MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
lib/MC/MCParser/AsmParser.cpp
  350                               MCBinaryExpr::Opcode &Kind);
 1341     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
 1341     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
 1353     return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, getContext());
 1489                                          MCBinaryExpr::Opcode &Kind,
 1497     Kind = MCBinaryExpr::LAnd;
 1500     Kind = MCBinaryExpr::LOr;
 1507     Kind = MCBinaryExpr::Or;
 1510     Kind = MCBinaryExpr::Xor;
 1513     Kind = MCBinaryExpr::And;
 1518     Kind = MCBinaryExpr::EQ;
 1522     Kind = MCBinaryExpr::NE;
 1525     Kind = MCBinaryExpr::LT;
 1528     Kind = MCBinaryExpr::LTE;
 1531     Kind = MCBinaryExpr::GT;
 1534     Kind = MCBinaryExpr::GTE;
 1539     Kind = MCBinaryExpr::Shl;
 1542     Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
 1542     Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
 1547     Kind = MCBinaryExpr::Add;
 1550     Kind = MCBinaryExpr::Sub;
 1555     Kind = MCBinaryExpr::Mul;
 1558     Kind = MCBinaryExpr::Div;
 1561     Kind = MCBinaryExpr::Mod;
 1567                                       MCBinaryExpr::Opcode &Kind,
 1575     Kind = MCBinaryExpr::LAnd;
 1578     Kind = MCBinaryExpr::LOr;
 1583     Kind = MCBinaryExpr::EQ;
 1587     Kind = MCBinaryExpr::NE;
 1590     Kind = MCBinaryExpr::LT;
 1593     Kind = MCBinaryExpr::LTE;
 1596     Kind = MCBinaryExpr::GT;
 1599     Kind = MCBinaryExpr::GTE;
 1604     Kind = MCBinaryExpr::Add;
 1607     Kind = MCBinaryExpr::Sub;
 1614     Kind = MCBinaryExpr::Or;
 1617     Kind = MCBinaryExpr::Xor;
 1620     Kind = MCBinaryExpr::And;
 1625     Kind = MCBinaryExpr::Mul;
 1628     Kind = MCBinaryExpr::Div;
 1631     Kind = MCBinaryExpr::Mod;
 1634     Kind = MCBinaryExpr::Shl;
 1637     Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
 1637     Kind = ShouldUseLogicalShr ? MCBinaryExpr::LShr : MCBinaryExpr::AShr;
 1643                                        MCBinaryExpr::Opcode &Kind) {
 1655     MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
 1655     MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
 1672     MCBinaryExpr::Opcode Dummy;
 1678     Res = MCBinaryExpr::create(Kind, Res, RHS, getContext(), StartLoc);
 6001     const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Value);
lib/MC/MCStreamer.cpp
  998     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
  998     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
 1025       MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
 1044       MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
lib/MC/MCWin64EH.cpp
   56       MCBinaryExpr::createSub(MCSymbolRefExpr::create(LHS, Context),
  135   const MCExpr *Ofs = MCBinaryExpr::createSub(OtherRef, BaseRef, Context);
  139   streamer.EmitValue(MCBinaryExpr::createAdd(BaseRefRel, Ofs, Context), 4);
  255       MCBinaryExpr::createSub(MCSymbolRefExpr::create(LHS, Context),
lib/MC/MCWinCOFFStreamer.cpp
  236     MCE = MCBinaryExpr::createAdd(
  255     MCE = MCBinaryExpr::createAdd(
lib/Target/AArch64/AArch64AsmPrinter.cpp
  733     Value = MCBinaryExpr::createSub(Value, Base, OutContext);
  738     Value = MCBinaryExpr::createSub(Value, Base, OutContext);
  739     Value = MCBinaryExpr::createLShr(
lib/Target/AArch64/AArch64MCInstLower.cpp
  109     Expr = MCBinaryExpr::createAdd(
  181     Expr = MCBinaryExpr::createAdd(
  230     Expr = MCBinaryExpr::createAdd(
lib/Target/AArch64/AArch64TargetObjectFile.cpp
   48     return MCBinaryExpr::createSub(Res, PC, getContext());
   73   return MCBinaryExpr::createSub(Res, PC, getContext());
lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp
  201       LHS = MCBinaryExpr::createSub(Add, Sub, Ctx);
  205       Expr = MCBinaryExpr::createAdd(LHS, Off, Ctx);
  210       Expr = MCBinaryExpr::createAdd(Add, Off, Ctx);
lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp
   65   return MCBinaryExpr::createSub(Res, PC, Context);
lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp
  122     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
  122     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
lib/Target/AMDGPU/AMDGPUMCInstLower.cpp
  117   SrcBBSym = MCBinaryExpr::createAdd(SrcBBSym, One, Ctx);
  120     return MCBinaryExpr::createSub(DestBBSym, SrcBBSym, Ctx);
  123   return MCBinaryExpr::createSub(SrcBBSym, DestBBSym, Ctx);
  157       Expr = MCBinaryExpr::createAdd(Expr,
lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
  535   auto *DescSZ = MCBinaryExpr::createSub(
  562   auto *DescSZ = MCBinaryExpr::createSub(
  586   auto *DescSZ = MCBinaryExpr::createSub(
  647   Streamer.EmitValue(MCBinaryExpr::createSub(
lib/Target/AMDGPU/MCTargetDesc/SIMCCodeEmitter.cpp
  437     auto *BE = cast<MCBinaryExpr>(Expr);
  438     if (BE->getOpcode() == MCBinaryExpr::Sub)
lib/Target/ARC/ARCMCInstLower.cpp
   72   const MCBinaryExpr *Add = MCBinaryExpr::createAdd(MCSym, OffsetExpr, *Ctx);
   72   const MCBinaryExpr *Add = MCBinaryExpr::createAdd(MCSym, OffsetExpr, *Ctx);
lib/Target/ARC/MCTargetDesc/ARCInstPrinter.cpp
  117   if (const auto *BE = dyn_cast<MCBinaryExpr>(Expr)) {
  117   if (const auto *BE = dyn_cast<MCBinaryExpr>(Expr)) {
lib/Target/ARM/ARMAsmPrinter.cpp
  920       MCBinaryExpr::createAdd(PCRelExpr,
  930       PCRelExpr = MCBinaryExpr::createSub(PCRelExpr, DotExpr, OutContext);
  932     Expr = MCBinaryExpr::createSub(Expr, PCRelExpr, OutContext);
  969       Expr = MCBinaryExpr::createSub(Expr, MCSymbolRefExpr::create(JTISymbol,
  975       Expr = MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(1,OutContext),
 1047     const MCExpr *Expr = MCBinaryExpr::createAdd(
 1050     Expr = MCBinaryExpr::createSub(MBBSymbolExpr, Expr, OutContext);
 1051     Expr = MCBinaryExpr::createDiv(Expr, MCConstantExpr::create(2, OutContext),
 1409       ARMMCExpr::createLower16(MCBinaryExpr::createSub(GVSymExpr,
 1410                                       MCBinaryExpr::createAdd(LabelSymExpr,
 1442         ARMMCExpr::createUpper16(MCBinaryExpr::createSub(GVSymExpr,
 1443                                    MCBinaryExpr::createAdd(LabelSymExpr,
lib/Target/ARM/ARMMCInstLower.cpp
   64     Expr = MCBinaryExpr::createAdd(Expr,
lib/Target/ARM/AsmParser/ARMAsmParser.cpp
 8310       const MCExpr *ReadPC = MCBinaryExpr::createAdd(InstPC, Const8,
 8312       const MCExpr *FixupAddr = MCBinaryExpr::createAdd(ReadPC, OpExpr,
lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
 1913     const MCExpr *DiffExpr = MCBinaryExpr::createSub(
lib/Target/AVR/AVRMCInstLower.cpp
   35     Expr = MCBinaryExpr::createAdd(
lib/Target/BPF/MCTargetDesc/BPFInstPrinter.cpp
   37   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr))
   37   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr))
lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp
 1179           Expr = MCBinaryExpr::createLShr(
 1182           Expr = MCBinaryExpr::createAnd(
 1345         MCBinaryExpr::createSub(MO.getExpr(),
 1369           MCBinaryExpr::createSub(MO.getExpr(),
 1622         MCBinaryExpr::createSub(Imm6.getExpr(),
 1642         MCBinaryExpr::createSub(Imm6.getExpr(),
 1662         MCBinaryExpr::createSub(Imm6.getExpr(),
 1719           MCBinaryExpr::createSub(Imm.getExpr(),
 1757           MCBinaryExpr::createSub(Imm.getExpr(),
 1869           MCBinaryExpr::createSub(Imm.getExpr(),
 1901           MCBinaryExpr::createSub(Imm.getExpr(),
lib/Target/Hexagon/HexagonAsmPrinter.cpp
  443     const MCExpr *Sub = MCBinaryExpr::createSub(Expr, One, OutContext);
  479     const MCExpr *Sub = MCBinaryExpr::createSub(Expr, One, OutContext);
  506     const MCExpr *Sub = MCBinaryExpr::createSub(Expr, One, OutContext);
lib/Target/Hexagon/HexagonMCInstLower.cpp
   88     ME = MCBinaryExpr::createAdd(ME, MCConstantExpr::create(MO.getOffset(), MC),
lib/Target/Hexagon/MCTargetDesc/HexagonMCCodeEmitter.cpp
  616     MCBinaryExpr const *Binary = cast<MCBinaryExpr>(ME);
  616     MCBinaryExpr const *Binary = cast<MCBinaryExpr>(ME);
  708     FixupExpr = MCBinaryExpr::createAdd(FixupExpr, C, MCT);
lib/Target/Hexagon/MCTargetDesc/HexagonMCExpr.cpp
   49     const MCBinaryExpr *be = cast<MCBinaryExpr>(Expr);
   49     const MCBinaryExpr *be = cast<MCBinaryExpr>(Expr);
lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp
  240     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value))
  240     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value))
  277     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value))
  277     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value))
  301     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value))
  301     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value))
  352     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value)) {
  352     if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Imm.Value)) {
  476     } else if (isa<MCBinaryExpr>(getImm())) {
  478       const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(getImm());
  478       const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(getImm());
  507     } else if (isa<MCBinaryExpr>(getImm())) {
  509       const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(getImm());
  509       const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(getImm());
  546     } else if (isa<MCBinaryExpr>(getImm())) {
  548       const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(getImm());
  548       const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(getImm());
  772     Res = MCBinaryExpr::createAdd(Res, RHS, getContext());
  856   if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Op.getImm())) {
  856   if (const MCBinaryExpr *BinaryExpr = dyn_cast<MCBinaryExpr>(Op.getImm())) {
lib/Target/Lanai/LanaiMCInstLower.cpp
   87     Expr = MCBinaryExpr::createAdd(
lib/Target/Lanai/MCTargetDesc/LanaiMCCodeEmitter.cpp
  123     const MCBinaryExpr *BinaryExpr = static_cast<const MCBinaryExpr *>(Expr);
lib/Target/MSP430/MSP430MCInstLower.cpp
  106     Expr = MCBinaryExpr::createAdd(Expr,
lib/Target/Mips/AsmParser/MipsAsmParser.cpp
 1747   if (const MCBinaryExpr *BExpr = dyn_cast<MCBinaryExpr>(Expr)) {
 1747   if (const MCBinaryExpr *BExpr = dyn_cast<MCBinaryExpr>(Expr)) {
 1770   if (const MCBinaryExpr *BExpr = dyn_cast<MCBinaryExpr>(Expr))
 1770   if (const MCBinaryExpr *BExpr = dyn_cast<MCBinaryExpr>(Expr))
 6058     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
 6058     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
 6146       MCBinaryExpr::Opcode Opcode;
 6153         Opcode = MCBinaryExpr::Add;
 6157         Opcode = MCBinaryExpr::Sub;
 6161         Opcode = MCBinaryExpr::Mul;
 6165         Opcode = MCBinaryExpr::Or;
 6169         Opcode = MCBinaryExpr::And;
 6173         Opcode = MCBinaryExpr::Shl;
 6177         Opcode = MCBinaryExpr::LShr;
 6181         Opcode = MCBinaryExpr::Xor;
 6185         Opcode = MCBinaryExpr::Div;
 6189         Opcode = MCBinaryExpr::Mod;
 6199       IdVal = MCBinaryExpr::create(Opcode, IdVal, NextExpr, getContext());
 6228   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(IdVal)) {
 6228   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(IdVal)) {
 6233       IdVal = MCBinaryExpr::create(BE->getOpcode(), BE->getRHS(), BE->getLHS(),
lib/Target/Mips/MCTargetDesc/MipsMCCodeEmitter.cpp
  247   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  269   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  292   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  315   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  401   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  423   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  445   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  467   const MCExpr *FixupExpression = MCBinaryExpr::createAdd(
  603     unsigned Res = getExprOpValue(cast<MCBinaryExpr>(Expr)->getLHS(), Fixups, STI);
  604     Res += getExprOpValue(cast<MCBinaryExpr>(Expr)->getRHS(), Fixups, STI);
lib/Target/Mips/MCTargetDesc/MipsMCExpr.cpp
  231     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
  231     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp
 1056   const MCExpr *Size = MCBinaryExpr::createSub(
lib/Target/Mips/MipsAsmPrinter.cpp
 1113   const MCExpr *T_min_E = MCBinaryExpr::createSub(T, E, OutContext);
lib/Target/Mips/MipsMCInstLower.cpp
  167     Expr = MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(Offset, *Ctx),
  211   const MCBinaryExpr *Sub = MCBinaryExpr::createSub(Sym1, Sym2, *Ctx);
  211   const MCBinaryExpr *Sub = MCBinaryExpr::createSub(Sym1, Sym2, *Ctx);
lib/Target/Mips/MipsTargetObjectFile.cpp
  192   Expr = MCBinaryExpr::createAdd(
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
 2041     return MCBinaryExpr::createAdd(Base, MCConstantExpr::create(Offset, Ctx),
 2085     return MCBinaryExpr::createAnd(OpExpr, MaskExpr, Ctx);
 2095     case Instruction::Add: return MCBinaryExpr::createAdd(LHS, RHS, Ctx);
 2130     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
 2130     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
 2143     case MCBinaryExpr::Add:
lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp
   75     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
   75     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
   85     case MCBinaryExpr::Add: Res = LHSVal + RHSVal; break;
   86     case MCBinaryExpr::Mul: Res = LHSVal * RHSVal; break;
  701   } else if (const MCBinaryExpr *BinExpr = dyn_cast<MCBinaryExpr>(Expr)) {
  701   } else if (const MCBinaryExpr *BinExpr = dyn_cast<MCBinaryExpr>(Expr)) {
  702     if (BinExpr->getOpcode() == MCBinaryExpr::Sub) {
  703       const MCExpr *NE = MCBinaryExpr::createSub(BinExpr->getRHS(),
 1287     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
 1287     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
 1307     return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, Context);
 1353     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
 1353     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
 1358     return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, Context);
lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp
  474   if (const MCBinaryExpr *BinExpr = dyn_cast<MCBinaryExpr>(Op.getExpr())) {
  474   if (const MCBinaryExpr *BinExpr = dyn_cast<MCBinaryExpr>(Op.getExpr())) {
lib/Target/PowerPC/PPCAsmPrinter.cpp
  502     TlsRef = MCBinaryExpr::createAdd(
  590       MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol,
  636       const MCExpr *DeltaExpr = MCBinaryExpr::createSub(
  664           MCOperand::createExpr(MCBinaryExpr::createSub(Exp, PB, OutContext));
  727     Exp = MCBinaryExpr::createSub(Exp, PB, OutContext);
  853       Exp = MCBinaryExpr::createAdd(Exp,
  965       MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol, OutContext),
 1349     MCBinaryExpr::createAdd(MCSymbolRefExpr::create(CurrentPos, OutContext),
 1373         MCBinaryExpr::createSub(
 1398         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
 1516         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
 1535         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCOffset, OutContext),
 1553       MCBinaryExpr::createSub(LocalEntryLabelExp,
lib/Target/PowerPC/PPCMCInstLower.cpp
  122         MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(32768, Ctx), Ctx);
  125     Expr = MCBinaryExpr::createAdd(Expr,
  134     Expr = MCBinaryExpr::createSub(Expr, PB, Ctx);
lib/Target/PowerPC/PPCTargetObjectFile.cpp
   54   return MCBinaryExpr::createAdd(Expr,
lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp
 1195   MCBinaryExpr::Opcode Opcode;
 1201     Opcode = MCBinaryExpr::Add;
 1204     Opcode = MCBinaryExpr::Sub;
 1211   Res = MCBinaryExpr::create(Opcode, Res, Expr, getContext());
 1450   const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr);
 1450   const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr);
 1457   if (BE->getOpcode() != MCBinaryExpr::Add &&
 1458       BE->getOpcode() != MCBinaryExpr::Sub)
 1462   if (BE->getOpcode() == MCBinaryExpr::Sub &&
 1473   if (BE->getOpcode() == MCBinaryExpr::Sub)
lib/Target/RISCV/MCTargetDesc/RISCVMCExpr.cpp
  235     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
  235     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
lib/Target/RISCV/RISCVMCInstLower.cpp
   81     ME = MCBinaryExpr::createAdd(
lib/Target/Sparc/AsmParser/SparcAsmParser.cpp
 1245     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
 1245     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp
  178     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
  178     const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
lib/Target/Sparc/SparcAsmPrinter.cpp
   97   const MCBinaryExpr *Sub = MCBinaryExpr::createSub(Cur, Start, OutContext);
   97   const MCBinaryExpr *Sub = MCBinaryExpr::createSub(Cur, Start, OutContext);
   98   const MCBinaryExpr *Add = MCBinaryExpr::createAdd(GOT, Sub, OutContext);
   98   const MCBinaryExpr *Add = MCBinaryExpr::createAdd(GOT, Sub, OutContext);
lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp
  644   else if (auto *BE = dyn_cast<MCBinaryExpr>(E))
 1319     Expr = Value == 0 ? Base : MCBinaryExpr::createAdd(Base, Expr, Ctx);
lib/Target/SystemZ/MCTargetDesc/SystemZMCCodeEmitter.cpp
  286       Expr = MCBinaryExpr::createAdd(Expr, OffsetExpr, Ctx);
lib/Target/SystemZ/SystemZAsmPrinter.cpp
  485       .addExpr(MCBinaryExpr::createAdd(Expr, ConstExpr, OutContext));
  500       .addExpr(MCBinaryExpr::createAdd(Expr, ConstExpr, OutContext));
lib/Target/SystemZ/SystemZMCInstLower.cpp
   74       Expr = MCBinaryExpr::createAdd(Expr, OffsetExpr, Ctx);
lib/Target/TargetLoweringObjectFile.cpp
  332     return MCBinaryExpr::createSub(Sym, PC, getContext());
lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp
  857         MCBinaryExpr::create(MCBinaryExpr::Sub, End, Start, getContext());
  857         MCBinaryExpr::create(MCBinaryExpr::Sub, End, Start, getContext());
lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp
   53   if (auto BinOp = dyn_cast<MCBinaryExpr>(Expr)) {
lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
  159     Expr = MCBinaryExpr::createAdd(
lib/Target/X86/AsmParser/X86AsmParser.cpp
 1901     Disp = MCBinaryExpr::createAdd(Disp, ImmDisp, getContext());
lib/Target/X86/MCTargetDesc/X86MCAsmInfo.cpp
  119   return MCBinaryExpr::createAdd(Res, Four, Context);
lib/Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp
  257     const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Expr);
  339       const MCBinaryExpr *Bin = static_cast<const MCBinaryExpr*>(Expr);
  368     Expr = MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(ImmOffset, Ctx),
lib/Target/X86/X86MCInstLower.cpp
  214     Expr = MCBinaryExpr::createSub(
  266     Expr = MCBinaryExpr::createSub(
  285     Expr = MCBinaryExpr::createAdd(
 2021     DotExpr = MCBinaryExpr::createSub(DotExpr, PICBase, OutContext);
 2023     DotExpr = MCBinaryExpr::createAdd(
lib/Target/X86/X86TargetObjectFile.cpp
   36     return MCBinaryExpr::createAdd(Res, Four, getContext());
   59   return MCBinaryExpr::createAdd(Res, Off, getContext());
lib/Target/XCore/MCTargetDesc/XCoreInstPrinter.cpp
   54   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr)) {
   54   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr)) {
lib/Target/XCore/XCoreMCInstLower.cpp
   73   const MCBinaryExpr *Add = MCBinaryExpr::createAdd(MCSym, OffsetExpr, *Ctx);
   73   const MCBinaryExpr *Add = MCBinaryExpr::createAdd(MCSym, OffsetExpr, *Ctx);
unittests/DebugInfo/DWARF/DwarfGenerator.cpp
  135     Expr = MCBinaryExpr::createSub(