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

References

include/llvm/CodeGen/MachineInstrBuilder.h

  290         return addConstantPoolIndex(Disp.getIndex(), Disp.getOffset() + off,
  293         return addGlobalAddress(Disp.getGlobal(), Disp.getOffset() + off,
  296         return addBlockAddress(Disp.getBlockAddress(), Disp.getOffset() + off,

lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

  606   printOffset(MO.getOffset(), OS);

lib/CodeGen/BranchFolding.cpp

  284       OperandHash = Op.getOffset();

lib/CodeGen/MachineOperand.cpp

  295     return getIndex() == Other.getIndex() && getOffset() == Other.getOffset();
  295     return getIndex() == Other.getIndex() && getOffset() == Other.getOffset();
  299     return getGlobal() == Other.getGlobal() && getOffset() == Other.getOffset();
  299     return getGlobal() == Other.getGlobal() && getOffset() == Other.getOffset();
  302            getOffset() == Other.getOffset();
  302            getOffset() == Other.getOffset();
  305            getOffset() == Other.getOffset();
  305            getOffset() == Other.getOffset();
  361                         MO.getOffset());
  365     return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getOffset(),
  369                         MO.getOffset());
  372                         MO.getOffset());
  828     printOperandOffset(OS, getOffset());
  837     printOperandOffset(OS, getOffset());
  845     printOperandOffset(OS, getOffset());
  855     printOperandOffset(OS, getOffset());
  865     MachineOperand::printOperandOffset(OS, getOffset());

lib/Target/AArch64/AArch64ExpandPseudoInsts.cpp

  494         MIB.addConstantPoolIndex(MO1.getIndex(), MO1.getOffset(), Flags);
  531         MIB1.addConstantPoolIndex(MO1.getIndex(), MO1.getOffset(),
  533         MIB2.addConstantPoolIndex(MO1.getIndex(), MO1.getOffset(),

lib/Target/AArch64/AArch64InstructionSelector.cpp

 1137                                GV, MovZ->getOperand(1).getOffset(), Flags));
 1141                                        MovZ->getOperand(1).getOffset(), Flags));
 1710       MIB.addGlobalAddress(GV, I.getOperand(1).getOffset(),

lib/Target/AArch64/AArch64MCInstLower.cpp

  108   if (!MO.isJTI() && MO.getOffset())
  110         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
  180   if (!MO.isJTI() && MO.getOffset())
  182         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
  229   if (!MO.isJTI() && MO.getOffset())
  231         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);

lib/Target/AMDGPU/AMDGPUMCInstLower.cpp

  155     int64_t Offset = MO.getOffset();

lib/Target/AMDGPU/R600ControlFlowFinalizer.cpp

  449                                    Literals[i]->getOffset());
  456                                    Literals[i + 1]->getOffset());

lib/Target/AMDGPU/SIFoldOperands.cpp

  291     Old.ChangeToGA(Fold.OpToFold->getGlobal(), Fold.OpToFold->getOffset(),

lib/Target/AMDGPU/SIShrinkInstructions.cpp

   99           Src0.ChangeToGA(MovSrc.getGlobal(), MovSrc.getOffset(),

lib/Target/ARC/ARCMCInstLower.cpp

   41     Offset += MO.getOffset();
   45     Offset += MO.getOffset();
   49     Offset += MO.getOffset();
   56     Offset += MO.getOffset();

lib/Target/ARM/ARMAsmPrinter.cpp

  196   printOffset(MO.getOffset(), O);

lib/Target/ARM/ARMBaseInstrInfo.cpp

 1765     if (MO0.getOffset() != MO1.getOffset())
 1765     if (MO0.getOffset() != MO1.getOffset())

lib/Target/ARM/ARMExpandPseudoInsts.cpp

  902     LO16 = LO16.addGlobalAddress(GV, MO.getOffset(), TF | ARMII::MO_LO16);
  903     HI16 = HI16.addGlobalAddress(GV, MO.getOffset(), TF | ARMII::MO_HI16);
 1184           MIB.addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),
 1545         .addGlobalAddress(GV, MO1.getOffset(), TF | LO16TF)
 1550         .addGlobalAddress(GV, MO1.getOffset(), TF | HI16TF)

lib/Target/ARM/ARMMCInstLower.cpp

   63   if (!MO.isJTI() && MO.getOffset())
   65                                    MCConstantExpr::create(MO.getOffset(),

lib/Target/AVR/AVRExpandPseudoInsts.cpp

  292     int64_t Offs = MI.getOperand(2).getOffset();
  503     int64_t Offs = MI.getOperand(1).getOffset();
  552     int64_t Offs = MI.getOperand(1).getOffset();
  984     int64_t Offs = MI.getOperand(0).getOffset();

lib/Target/AVR/AVRMCInstLower.cpp

   34   if (!MO.isJTI() && MO.getOffset()) {
   36         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);

lib/Target/BPF/BPFMCInstLower.cpp

   41   if (!MO.isJTI() && MO.getOffset())

lib/Target/Hexagon/HexagonConstExtenders.cpp

  759     Offset = Op.getOffset();

lib/Target/Hexagon/HexagonCopyToCombine.cpp

  673       .addGlobalAddress(HiOperand.getGlobal(), HiOperand.getOffset(),
  681       .addGlobalAddress(LoOperand.getGlobal(), LoOperand.getOffset(),
  689       .addBlockAddress(HiOperand.getBlockAddress(), HiOperand.getOffset(),
  697       .addBlockAddress(LoOperand.getBlockAddress(), LoOperand.getOffset(),
  719       .addConstantPoolIndex(HiOperand.getIndex(), HiOperand.getOffset(),
  727       .addConstantPoolIndex(LoOperand.getIndex(), LoOperand.getOffset(),
  770       .addGlobalAddress(HiOperand.getGlobal(), HiOperand.getOffset(),
  778       .addBlockAddress(HiOperand.getBlockAddress(), HiOperand.getOffset(),
  793       .addConstantPoolIndex(HiOperand.getIndex(), HiOperand.getOffset(),
  819       .addGlobalAddress(LoOperand.getGlobal(), LoOperand.getOffset(),
  827       .addBlockAddress(LoOperand.getBlockAddress(), LoOperand.getOffset(),
  842       .addConstantPoolIndex(LoOperand.getIndex(), LoOperand.getOffset(),

lib/Target/Hexagon/HexagonInstrInfo.cpp

 4030         isUInt<2>(MI.getOperand(1).getOffset()))) &&
 4033         isUInt<2>(MI.getOperand(2).getOffset()))))
 4042         (MI.getOperand(2).isGlobal() && MI.getOperand(2).getOffset() == 0)))
 4051         (MI.getOperand(1).isGlobal() && MI.getOperand(1).getOffset() == 0)))

lib/Target/Hexagon/HexagonMCInstLower.cpp

   87   if (!MO.isJTI() && MO.getOffset())
   88     ME = MCBinaryExpr::createAdd(ME, MCConstantExpr::create(MO.getOffset(), MC),

lib/Target/Hexagon/HexagonOptAddrMode.cpp

  511       int64_t Offset = ImmOp.getOffset() + OldMI->getOperand(2).getImm();
  568       int64_t Offset = ImmOp.getOffset() + OldMI->getOperand(1).getImm();
  644       MIB.addGlobalAddress(GV, UseMI->getOperand(2).getImm()+ImmOp.getOffset(),
  651       MIB.addGlobalAddress(GV, UseMI->getOperand(1).getImm()+ImmOp.getOffset(),

lib/Target/Lanai/LanaiMCInstLower.cpp

   86   if (!MO.isJTI() && MO.getOffset())
   88         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);

lib/Target/MSP430/MSP430AsmPrinter.cpp

   68   uint64_t Offset = MO.getOffset();

lib/Target/MSP430/MSP430MCInstLower.cpp

  105   if (!MO.isJTI() && MO.getOffset())
  107                                    MCConstantExpr::create(MO.getOffset(), Ctx),

lib/Target/Mips/MipsAsmPrinter.cpp

  709       if (MO.getOffset())
  710         O << "+" << MO.getOffset();

lib/Target/Mips/MipsMCInstLower.cpp

  130     Offset += MO.getOffset();
  135     Offset += MO.getOffset();
  140     Offset += MO.getOffset();
  145     Offset += MO.getOffset();
  154     Offset += MO.getOffset();

lib/Target/PowerPC/PPCAsmPrinter.cpp

  202   printOffset(MO.getOffset(), O);
  852     if (!MO.isJTI() && MO.getOffset())
  854                                     MCConstantExpr::create(MO.getOffset(),

lib/Target/PowerPC/PPCFrameLowering.cpp

 1739       addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset());
 1752       addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset());

lib/Target/PowerPC/PPCMCInstLower.cpp

  124   if (!MO.isJTI() && MO.getOffset())
  126                                    MCConstantExpr::create(MO.getOffset(), Ctx),

lib/Target/RISCV/RISCVMCInstLower.cpp

   80   if (!MO.isJTI() && !MO.isMBB() && MO.getOffset())
   82         ME, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);

lib/Target/RISCV/RISCVMergeBaseOffset.cpp

   85       HiLUI.getOperand(1).getOffset() != 0 ||
   93       LoADDI->getOperand(2).getOffset() != 0 ||

lib/Target/SystemZ/SystemZMCInstLower.cpp

   72     if (int64_t Offset = MO.getOffset()) {

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

  391       printOffset(MO.getOffset(), OS);

lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

  148   if (MO.getOffset() != 0) {
  160         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);

lib/Target/X86/X86AsmPrinter.cpp

  117     printOffset(MO.getOffset(), O);
  155     printOffset(MO.getOffset(), O);

lib/Target/X86/X86ExpandPseudo.cpp

  247         MIB.addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),

lib/Target/X86/X86MCInstLower.cpp

  284   if (!MO.isJTI() && !MO.isMBB() && MO.getOffset())
  286         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
 1606   if (!Op.isCPI() || Op.getOffset() != 0)

lib/Target/X86/X86OptimizeLEAs.cpp

  406                      : Op1.getOffset() - Op2.getOffset();
  406                      : Op1.getOffset() - Op2.getOffset();
  647             Op.setOffset(Op.getOffset() + AddrDispShift);

lib/Target/X86/X86RegisterInfo.cpp

  788       (uint64_t)MI.getOperand(FIOperandNum+3).getOffset();

lib/Target/XCore/XCoreMCInstLower.cpp

   43       Offset += MO.getOffset();
   47       Offset += MO.getOffset();
   51       Offset += MO.getOffset();
   58       Offset += MO.getOffset();

unittests/CodeGen/MachineOperandTest.cpp

   43   ASSERT_TRUE(MO.getOffset() == 57);
  132   ASSERT_TRUE(MO.getOffset() == 8);
  164   ASSERT_TRUE(MO.getOffset() == 8);
  255   ASSERT_TRUE(MO.getOffset() == 12);