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

Declarations

include/llvm/IR/Instruction.def
  142 HANDLE_UNARY_INST(12, FNeg  , UnaryOperator)

References

include/llvm/IR/IRBuilder.h
 1524     return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
 1534    return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr,
 1550     Instruction *UnOp = UnaryOperator::Create(Opc, V);
include/llvm/IR/InstVisitor.h
  268   RetTy visitUnaryOperator(UnaryOperator &I)      { DELEGATE(UnaryInstruction);}
include/llvm/IR/InstrTypes.h
  115   UnaryOperator *cloneImpl() const;
  124   static UnaryOperator *Create(UnaryOps Op, Value *S,
  132   static UnaryOperator *Create(UnaryOps Op, Value *S,
  157   static UnaryOperator *CreateWithCopiedFlags(UnaryOps Opc,
  161     UnaryOperator *UO = Create(Opc, V, Name);
  166   static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
include/llvm/IR/NoFolder.h
  199     return UnaryOperator::CreateFNeg(C);
  207     return UnaryOperator::Create(Opc, C);
include/llvm/Support/Casting.h
   34   using SimpleType = From; // The real type this represents...
   37   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
   41   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
   47   static RetType getSimplifiedValue(const From& Val) {
   57   static inline bool doit(const From &Val) {
   58     return To::classof(&Val);
   76   static inline bool doit(const From &Val) {
   77     return isa_impl<To, From>::doit(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);
  141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
  142   return isa_impl_wrap<X, const Y,
  142   return isa_impl_wrap<X, const Y,
  143                        typename simplify_type<const Y>::SimpleType>::doit(Val);
  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;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::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) {
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  228     typename cast_retty<To, FromTy>::ret_type Res2
  236       std::is_same<X, typename simplify_type<X>::SimpleType>::value;
  236       std::is_same<X, typename simplify_type<X>::SimpleType>::value;
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  259                           typename simplify_type<Y>::SimpleType>::doit(Val);
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  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;
include/llvm/Support/type_traits.h
   55 struct add_const_past_pointer { using type = const T; };
lib/Analysis/CFLGraph.h
  294     void visitUnaryOperator(UnaryOperator &Inst) {
lib/Analysis/InlineCost.cpp
  276   bool visitFNeg(UnaryOperator &I);
 1103 bool CallAnalyzer::visitFNeg(UnaryOperator &I) {
lib/AsmParser/LLParser.cpp
 6341   Inst = UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);
lib/Bitcode/Reader/BitcodeReader.cpp
 3875       I = UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);
lib/ExecutionEngine/Interpreter/Execution.cpp
   62 void Interpreter::visitUnaryOperator(UnaryOperator &I) {
lib/ExecutionEngine/Interpreter/Interpreter.h
  127   void visitUnaryOperator(UnaryOperator &I);
lib/IR/Constants.cpp
 3031     return UnaryOperator::Create((Instruction::UnaryOps)getOpcode(), Ops[0]);
lib/IR/Instructions.cpp
 2209 UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S,
 2212   return new UnaryOperator(Op, S, S->getType(), Name, InsertBefore);
 2215 UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S,
 2218   UnaryOperator *Res = Create(Op, S, Name);
 4105 UnaryOperator *UnaryOperator::cloneImpl() const {
lib/IR/Verifier.cpp
  452   void visitUnaryOperator(UnaryOperator &U);
 3135 void Verifier::visitUnaryOperator(UnaryOperator &U) {
lib/Transforms/InstCombine/InstCombineAddSub.cpp
 2067 Instruction *InstCombiner::visitFNeg(UnaryOperator &I) {
lib/Transforms/InstCombine/InstCombineCasts.cpp
 1631       return UnaryOperator::CreateFNegFMF(InnerTrunc, Op);
lib/Transforms/InstCombine/InstCombineInternal.h
  369   Instruction *visitFNeg(UnaryOperator &I);
lib/Transforms/InstCombine/InstCombineSelect.cpp
  345     return UnaryOperator::CreateFNeg(NewSel);
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
  440   void visitUnaryOperator(UnaryOperator &UO);
 1402 void DFSanVisitor::visitUnaryOperator(UnaryOperator &UO) {
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 2124   void visitFNeg(UnaryOperator &I) { handleShadowOr(I); }
lib/Transforms/Scalar/EarlyCSE.cpp
  111     return isa<CastInst>(Inst) || isa<UnaryOperator>(Inst) ||
lib/Transforms/Scalar/LICM.cpp
 1037           isa<UnaryOperator>(I) || isa<BinaryOperator>(I) ||
lib/Transforms/Scalar/Reassociate.cpp
 2073   if (!isa<UnaryOperator>(I) && !isa<BinaryOperator>(I))
lib/Transforms/Scalar/Scalarizer.cpp
  130   UnarySplitter(UnaryOperator &uo) : UO(uo) {}
  136   UnaryOperator &UO;
  188   bool visitUnaryOperator(UnaryOperator &UO);
  590 bool ScalarizerVisitor::visitUnaryOperator(UnaryOperator &UO) {
unittests/IR/InstructionsTest.cpp
 1055   UnaryOperator *FNeg = UnaryOperator::CreateFNegFMF(One, FAdd);
 1055   UnaryOperator *FNeg = UnaryOperator::CreateFNegFMF(One, FAdd);
usr/include/c++/7.4.0/type_traits
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;