//===- llvm/InstrTypes.h - Important Instruction subclasses -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines various meta classes of instructions that exist in the VM // representation. Specific concrete subclasses of these may be found in the // i*.h files... // //===----------------------------------------------------------------------===// #ifndef LLVM_IR_INSTRTYPES_H #define LLVM_IR_INSTRTYPES_H #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/Sequence.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/Twine.h" #include "llvm/ADT/iterator_range.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/CallingConv.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/FMF.h" #include "llvm/IR/Function.h" #include "llvm/IR/Instruction.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/OperandTraits.h" #include "llvm/IR/User.h" #include <algorithm> #include <cassert> #include <cstddef> #include <cstdint> #include <iterator> #include <optional> #include <string> #include <vector> namespace llvm { class StringRef; class Type; class Value; class ConstantRange; namespace Intrinsic { ID; } //===----------------------------------------------------------------------===// // UnaryInstruction Class //===----------------------------------------------------------------------===// class UnaryInstruction : public Instruction { … }; template <> struct OperandTraits<UnaryInstruction> : public FixedNumOperandTraits<UnaryInstruction, 1> { … }; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(…) //===----------------------------------------------------------------------===// // UnaryOperator Class //===----------------------------------------------------------------------===// class UnaryOperator : public UnaryInstruction { … }; //===----------------------------------------------------------------------===// // BinaryOperator Class //===----------------------------------------------------------------------===// class BinaryOperator : public Instruction { … }; template <> struct OperandTraits<BinaryOperator> : public FixedNumOperandTraits<BinaryOperator, 2> { … }; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(…) /// An or instruction, which can be marked as "disjoint", indicating that the /// inputs don't have a 1 in the same bit position. Meaning this instruction /// can also be treated as an add. class PossiblyDisjointInst : public BinaryOperator { … }; BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name) { … } BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, InsertPosition InsertBefore) { … } //===----------------------------------------------------------------------===// // CastInst Class //===----------------------------------------------------------------------===// /// This is the base class for all instructions that perform data /// casts. It is simply provided so that instruction category testing /// can be performed with code like: /// /// if (isa<CastInst>(Instr)) { ... } /// Base class of casting instructions. class CastInst : public UnaryInstruction { … }; /// Instruction that can have a nneg flag (zext/uitofp). class PossiblyNonNegInst : public CastInst { … }; //===----------------------------------------------------------------------===// // CmpInst Class //===----------------------------------------------------------------------===// /// This class is the base class for the comparison instructions. /// Abstract base class of comparison instructions. class CmpInst : public Instruction { … }; // FIXME: these are redundant if CmpInst < BinaryOperator template <> struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> { … }; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(…) raw_ostream &operator<<(raw_ostream &OS, CmpInst::Predicate Pred); /// A lightweight accessor for an operand bundle meant to be passed /// around by value. struct OperandBundleUse { … }; /// A container for an operand bundle being viewed as a set of values /// rather than a set of uses. /// /// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and /// so it is possible to create and pass around "self-contained" instances of /// OperandBundleDef and ConstOperandBundleDef. template <typename InputTy> class OperandBundleDefT { … }; OperandBundleDef; ConstOperandBundleDef; //===----------------------------------------------------------------------===// // CallBase Class //===----------------------------------------------------------------------===// /// Base class for all callable instructions (InvokeInst and CallInst) /// Holds everything related to calling a function. /// /// All call-like instructions are required to use a common operand layout: /// - Zero or more arguments to the call, /// - Zero or more operand bundles with zero or more operand inputs each /// bundle, /// - Zero or more subclass controlled operands /// - The called function. /// /// This allows this base class to easily access the called function and the /// start of the arguments without knowing how many other operands a particular /// subclass requires. Note that accessing the end of the argument list isn't /// as cheap as most other operations on the base class. class CallBase : public Instruction { … }; template <> struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase> { … }; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(…) //===----------------------------------------------------------------------===// // FuncletPadInst Class //===----------------------------------------------------------------------===// class FuncletPadInst : public Instruction { … }; template <> struct OperandTraits<FuncletPadInst> : public VariadicOperandTraits<FuncletPadInst> { … }; DEFINE_TRANSPARENT_OPERAND_ACCESSORS(…) } // end namespace llvm #endif // LLVM_IR_INSTRTYPES_H