Lines Matching defs:class
117 an instance of the specified class. This can be very useful for constraint
122 or reference from a base class to a derived class, causing an assertion
164 efficient to use the ``InstVisitor`` class to dispatch over the instruction
187 :doc:`How to set up LLVM-style RTTI for your class hierarchy
196 important APIs which take strings. Two important examples are the Value class
198 class which is used extensively in LLVM and Clang.
208 The ``StringRef`` class
237 You should rarely use the ``StringRef`` class directly, because it contains
239 class (unless you know that the external storage will not be freed).
243 The ``Twine`` class
247 class is an efficient way for APIs to accept concatenated strings. For example,
255 The ``Twine`` class is effectively a lightweight `rope
461 error codes, or C++'s ``std::error_code``. However, the ``Error`` class is
479 Failure values are constructed using ``make_error<T>``, where ``T`` is any class
484 class BadFileFormat : public ErrorInfo<BadFileFormat> {
652 function, lambda, or class with a call operator) with one argument. The
703 sense. LLVM provides the ``StringError`` class for this purpose. It takes two
706 common usage of this class:
797 check and call to exit. The ``ExitOnError`` class supports this pattern by
801 To use this class, declare a global ``ExitOnError`` variable in your program:
886 class Foo {
1010 class FallibleChildIterator {
1043 class Archive {
1095 The ``function_ref`` class template
1099 (`doxygen <https://llvm.org/doxygen/classllvm_1_1function__ref_3_01Ret_07Params_8_8_8_08_4.html>`__) class
1130 is not generally safe to store an instance of the class (unless you know that
1242 The ``Statistic`` class & ``-stats`` option
1246 <https://llvm.org/doxygen/Statistic_8h_source.html>`__) file provides a class
1255 for big programs. Using the ``Statistic`` class makes it very easy to keep
1342 provides a class named ``DebugCounter`` that can be used to create
1524 The ``llvm::ArrayRef`` class is the preferred class to use in an interface that
1558 ``TinyPtrVector<Type>`` is a highly specialized collection class that is
1570 ``SmallVector<Type, N>`` is a simple class that looks and smells just like
1620 class, which is the "vector header" (and methods) without the elements
1737 ``std::list`` is an extremely inefficient class that is rarely useful. It
1746 std::list are stronger than that of a vector class: inserting or removing an
1762 the traits class is informed when an element is inserted or removed from the
1817 publicly derives from this traits class.
1899 The StringRef class is a simple value class that contains a pointer to a
1901 <dss_arrayref>` class (but specialized for arrays of characters). Because
1930 class.
1941 The Twine class is used as an intermediary datatype for APIs that want to take a
2000 The standard C++ std::string class is a very general class that (like
2006 standard library (e.g. libc++ and MSVC provide a highly optimized string class,
2055 The magic of this class is that it handles small sets extremely efficiently, but
2138 FoldingSet is an aggregate class that is really good at uniquing
2168 ``std::set`` is a reasonable all-around set class, which is decent at many
2189 LLVM's ``SetVector<Type>`` is an adapter class that combines your choice of a
2211 ``SetVector`` is an adapter class that defaults to using ``std::vector`` and a
2213 However, ``"llvm/ADT/SetVector.h"`` also provides a ``SmallSetVector`` class,
2431 class. Classes can be joined by passing two class representatives to the
2432 join(a, b) method. Two integers are in the same class when findLeader() returns
2436 integer 0..n-1 maps to an equivalence class number in the range 0..m-1, where m
2762 Turning an iterator into a class pointer (and vice-versa)
2765 Sometimes, it'll be useful to grab a reference (or pointer) to a class instance
2776 It's also possible to turn a class pointer into the corresponding iterator, and
2813 ``FunctionPass``-derived class simply has to override the ``runOnFunction``
2820 class OurFunctionPass : public FunctionPass {
2847 Frequently, we might have an instance of the ``Value`` class (`doxygen
2868 known as a *use-def* chain. Instances of class ``Instruction`` are common
2982 class and ``Instruction``-derived classes provide constructors which take a
3006 methods. The ``IRBuilder`` is a convenience class that can be used to add
3166 ``ManagedStatic`` is a utility class in LLVM used to implement static
3177 ``LLVMContext`` is an opaque class in the LLVM API which clients can use to
3235 The ``ValueSymbolTable`` class
3239 <https://llvm.org/doxygen/classllvm_1_1ValueSymbolTable.html>`__) class provides
3243 Note that the ``SymbolTable`` class should not be directly accessed by most
3251 symbol table (with ``lookup``). The ``ValueSymbolTable`` class exposes no
3261 class provides a basis for expressing the ownership of ``User`` towards other
3264 class is employed to do the bookkeeping and to facilitate *O(1)* addition and
3337 virtual dispatch and inheritance by defining an abstract interface base class
3361 <https://learn.microsoft.com/en-us/shows/goingnative-2013/inheritance-base-class-of-evil>`_
3373 there is some refinement of an abstract base class which is a semantically
3428 The Type class and Derived Types
3435 useful functionality beyond what the ``Type`` class offers except to distinguish
3490 ArrayType but is distinguished because it is a first class type whereas
3515 The ``Module`` class
3524 The ``Module`` class represents the top level structure present in LLVM
3527 linker. The ``Module`` class keeps track of a list of :ref:`Function
3534 Important Public Members of the ``Module`` class
3605 The ``Value`` class
3614 The ``Value`` class is the most important class in the LLVM Source base. It
3622 instance of the Argument_ class) is "used" by every instruction in the function
3624 class keeps a list of all of the ``User``\ s that is using it (the User_ class
3625 is a base class for all nodes in the LLVM graph that can refer to ``Value``\ s).
3650 class that represents this value. Although this may take some getting used to,
3655 Important Public Members of the ``Value`` class
3696 The ``User`` class
3707 The ``User`` class is the common base class of all LLVM nodes that may refer to
3709 that the User is referring to. The ``User`` class itself is a subclass of
3719 Important Public Members of the ``User`` class
3722 The ``User`` class exposes the operand list in two ways: through an index access
3742 The ``Instruction`` class
3755 The ``Instruction`` class is the common base class for all LLVM instructions.
3756 It provides only a few methods, but is a very commonly used class. The primary
3757 data tracked by the ``Instruction`` class itself is the opcode (instruction
3762 Because the ``Instruction`` class subclasses the User_ class, its operands can
3765 An important file for the ``Instruction`` class is the ``llvm/Instruction.def``
3776 Important Subclasses of the ``Instruction`` class
3802 Important Public Members of the ``Instruction`` class
3827 The ``Constant`` class and subclasses
3830 Constant represents a base class for different types of constants. It is
3864 * ConstantFP : This class represents a floating point constant.
3883 The ``GlobalValue`` class
3926 Important Public Members of the ``GlobalValue`` class
3942 The ``Function`` class
3954 The ``Function`` class represents a single procedure in LLVM. It is actually
3956 of a large amount of data. The ``Function`` class keeps track of a list of
3969 In addition to a list of BasicBlock_\ s, the ``Function`` class also keeps track
4045 The ``GlobalVariable`` class
4059 class. Like functions, ``GlobalVariable``\ s are also subclasses of
4069 Important Public Members of the ``GlobalVariable`` class
4103 The ``BasicBlock`` class
4116 This class represents a single entry single exit section of the code, commonly
4117 known as a basic block by the compiler community. The ``BasicBlock`` class
4123 ``BasicBlock`` class also keeps track of the :ref:`Function <c_Function>` that
4132 Important Public Members of the ``BasicBlock`` class
4169 The ``Argument`` class