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

Derived Classes

include/llvm/IR/Operator.h

  407 class ConcreteOperator : public SuperClass {

References

include/llvm/Analysis/InstructionSimplify.h

   84     if (UseInstrInfo && isa<PossiblyExactOperator>(Op))
   85       return cast<PossiblyExactOperator>(Op)->isExact();

include/llvm/IR/Operator.h

  407 class ConcreteOperator : public SuperClass {
  435   : public ConcreteOperator<PossiblyExactOperator, Instruction::SDiv> {
  438   : public ConcreteOperator<PossiblyExactOperator, Instruction::UDiv> {
  441   : public ConcreteOperator<PossiblyExactOperator, Instruction::AShr> {
  444   : public ConcreteOperator<PossiblyExactOperator, Instruction::LShr> {

include/llvm/IR/PatternMatch.h

 1106     if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))
 1106     if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))

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;

lib/Analysis/InstructionSimplify.cpp

 3693     if (isa<PossiblyExactOperator>(B) && Q.IIQ.isExact(B))

lib/Analysis/ScalarEvolution.cpp

 3891     } else if (isa<PossiblyExactOperator>(I) && I->isExact())

lib/Analysis/ScalarEvolutionExpander.cpp

  200         if (isa<PossiblyExactOperator>(I) && I->isExact())

lib/Analysis/ValueTracking.cpp

 2142     const PossiblyExactOperator *BO = cast<PossiblyExactOperator>(V);
 2142     const PossiblyExactOperator *BO = cast<PossiblyExactOperator>(V);

lib/AsmParser/LLParser.cpp

 3511     if (Exact) Flags |= PossiblyExactOperator::IsExact;

lib/Bitcode/Writer/BitcodeWriter.cpp

 1397   } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
 1397   } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {

lib/CodeGen/MachineInstr.cpp

  538   if (const PossiblyExactOperator *PE = dyn_cast<PossiblyExactOperator>(&I))
  538   if (const PossiblyExactOperator *PE = dyn_cast<PossiblyExactOperator>(&I))

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3117   if (auto *ExactOp = dyn_cast<PossiblyExactOperator>(&I)) {
 3172     if (const PossiblyExactOperator *ExactOp =
 3173             dyn_cast<const PossiblyExactOperator>(&I))
 3190   Flags.setExact(isa<PossiblyExactOperator>(&I) &&
 3191                  cast<PossiblyExactOperator>(&I)->isExact());

lib/IR/AsmWriter.cpp

 1279   } else if (const PossiblyExactOperator *Div =
 1280                dyn_cast<PossiblyExactOperator>(U)) {

lib/IR/Constants.cpp

 2285              isExact ? PossiblyExactOperator::IsExact : 0);
 2290              isExact ? PossiblyExactOperator::IsExact : 0);
 2330              isExact ? PossiblyExactOperator::IsExact : 0);
 2335              isExact ? PossiblyExactOperator::IsExact : 0);
 3043     if (isa<PossiblyExactOperator>(BO))
 3044       BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact);

lib/IR/Instruction.cpp

  109   cast<PossiblyExactOperator>(this)->setIsExact(b);
  134     cast<PossiblyExactOperator>(this)->setIsExact(false);
  146   return cast<PossiblyExactOperator>(this)->isExact();
  253   if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
  254     if (isa<PossiblyExactOperator>(this))
  275   if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
  276     if (isa<PossiblyExactOperator>(this))

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  318     if (const auto *ExactOp = dyn_cast<PossiblyExactOperator>(&I))
  318     if (const auto *ExactOp = dyn_cast<PossiblyExactOperator>(&I))

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

 1244       if (isa<PossiblyExactOperator>(BO)) {