+-------------------------------+
| layout: page                  |
+-------------------------------+
| title: Constant (llvm.core)   |
+-------------------------------+

``Constant``-s represents constants that appear within the code. The
values of such objects are known at creation time. Constants can be
created from Python constants. A constant expression is also a constant
-- given a ``Constant`` object, an operation (like addition, subtraction
etc) can be specified, to yield a new ``Constant`` object. Let's see
some examples:


.. code-block:: python

   #!/usr/bin/env python
   
   ti = Type.int() # a 32-bit int type
   
   k1 = Constant.int(ti, 42) # "int k1 = 42;" k2 = k1.add( Constant.int(
   ti, 10 ) ) # "int k2 = k1 + 10;"
   
   tr = Type.float()
   
   r1 = Constant.real(tr, "3.141592") # create from a string r2 =
   Constant.real(tr, 1.61803399) # create from a Python float {%
   endhighlight %}
   
   # llvm.core.Constant
   -  This will become a table of contents (this text will be scraped).
   {:toc}
   
   Static factory methods
   ----------------------
   
   ``null(ty)``
   ~~~~~~~~~~~~
   
   A null value (all zeros) of type ``ty``
   
   ``all_ones(ty)``
   ~~~~~~~~~~~~~~~~
   
   All 1's value of type ``ty``
   
   ``undef(ty)``
   ~~~~~~~~~~~~~
   
   An undefined value of type ``ty``
   
   ``int(ty, value)``
   ~~~~~~~~~~~~~~~~~~
   
   Integer of type ``ty``, with value ``value`` (a Python int or long)
   
   ``int_signextend(ty, value)``
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   
   Integer of signed type ``ty`` (use for signed types)
   
   ``real(ty, value)``
   ~~~~~~~~~~~~~~~~~~~
   
   Floating point value of type ``ty``, with value ``value`` (a Python
   float)
   
   ``stringz(value)``
   ~~~~~~~~~~~~~~~~~~
   
   A null-terminated string. ``value`` is a Python string
   
   ``string(value)``
   ~~~~~~~~~~~~~~~~~
   
   As ``string(ty)``, but not null terminated
   
   ``array(ty, consts)``
   ~~~~~~~~~~~~~~~~~~~~~
   
   Array of type ``ty``, initialized with ``consts`` (an iterable yielding
   ``Constant`` objects of the appropriate type)
   
   ``struct(ty, consts)``
   ~~~~~~~~~~~~~~~~~~~~~~
   
   Struct (unpacked) of type ``ty``, initialized with ``consts`` (an
   iterable yielding ``Constant`` objects of the appropriate type)
   
   ``packed_struct(ty, consts)``
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   
   As ``struct(ty, consts)`` but packed
   
   ``vector(consts)``
   ~~~~~~~~~~~~~~~~~~
   
   Vector, initialized with ``consts`` (an iterable yielding ``Constant``
   objects of the appropriate type)
   
   ``sizeof(ty)``
   ~~~~~~~~~~~~~~
   
   Constant value representing the sizeof the type ``ty``
   
   Methods
   -------
   
   The following operations on constants are supported. For more details on
   any operation, consult the `Constant
   Expressions <http://www.llvm.org/docs/LangRef.html#constantexprs>`_
   section of the LLVM Language Reference.
   
   ``k.neg()``
   ~~~~~~~~~~~
   
   negation, same as ``0 - k``
   
   ``k.not_()``
   ~~~~~~~~~~~~
   
   1's complement of ``k``. Note trailing underscore.
   
   ``k.add(k2)``
   ~~~~~~~~~~~~~
   
   ``k + k2``, where ``k`` and ``k2`` are integers.
   
   ``k.fadd(k2)``
   ~~~~~~~~~~~~~~
   
   ``k + k2``, where ``k`` and ``k2`` are floating-point.
   
   ``k.sub(k2)``
   ~~~~~~~~~~~~~
   
   ``k - k2``, where ``k`` and ``k2`` are integers.
   
   ``k.fsub(k2)``
   ~~~~~~~~~~~~~~
   
   ``k - k2``, where ``k`` and ``k2`` are floating-point.
   
   ``k.mul(k2)``
   ~~~~~~~~~~~~~
   
   ``k * k2``, where ``k`` and ``k2`` are integers.
   
   ``k.fmul(k2)``
   ~~~~~~~~~~~~~~
   
   ``k * k2``, where ``k`` and ``k2`` are floating-point.
   
   ``k.udiv(k2)``
   ~~~~~~~~~~~~~~
   
   Quotient of unsigned division of ``k`` with ``k2``
   
   ``k.sdiv(k2)``
   ~~~~~~~~~~~~~~
   
   Quotient of signed division of ``k`` with ``k2``
   
   ``k.fdiv(k2)``
   ~~~~~~~~~~~~~~
   
   Quotient of floating point division of ``k`` with ``k2``
   
   ``k.urem(k2)``
   ~~~~~~~~~~~~~~
   
   Reminder of unsigned division of ``k`` with ``k2``
   
   ``k.srem(k2)``
   ~~~~~~~~~~~~~~
   
   Reminder of signed division of ``k`` with ``k2``
   
   ``k.frem(k2)``
   ~~~~~~~~~~~~~~
   
   Reminder of floating point division of ``k`` with ``k2``
   
   ``k.and_(k2)``
   ~~~~~~~~~~~~~~
   
   Bitwise and of ``k`` and ``k2``. Note trailing underscore.
   
   ``k.or_(k2)``
   ~~~~~~~~~~~~~
   
   Bitwise or of ``k`` and ``k2``. Note trailing underscore.
   
   ``k.xor(k2)``
   ~~~~~~~~~~~~~
   
   Bitwise exclusive-or of ``k`` and ``k2``.
   
   ``k.icmp(icmp, k2)``
   ~~~~~~~~~~~~~~~~~~~~
   
   Compare ``k`` with ``k2`` using the predicate ``icmp``. See
   `here <comparision.html#icmp>`_ for list of predicates for integer
   operands.
   
   ``k.fcmp(fcmp, k2)``
   ~~~~~~~~~~~~~~~~~~~~
   
   Compare ``k`` with ``k2`` using the predicate ``fcmp``. See
   `here <comparision.html#fcmp>`_ for list of predicates for real
   operands.
   
   ``k.shl(k2)``
   ~~~~~~~~~~~~~
   
   Shift ``k`` left by ``k2`` bits.
   
   ``k.lshr(k2)``
   ~~~~~~~~~~~~~~
   
   Shift ``k`` logically right by ``k2`` bits (new bits are 0s).
   
   ``k.ashr(k2)``
   ~~~~~~~~~~~~~~
   
   Shift ``k`` arithmetically right by ``k2`` bits (new bits are same as
   previous sign bit).
   
   ``k.gep(indices)``
   ~~~~~~~~~~~~~~~~~~
   
   GEP, see `LLVM docs <http://www.llvm.org/docs/GetElementPtr.html>`_.
   
   ``k.trunc(ty)``
   ~~~~~~~~~~~~~~~
   
   Truncate ``k`` to a type ``ty`` of lower bitwidth.
   
   ``k.sext(ty)``
   ~~~~~~~~~~~~~~
   
   Sign extend ``k`` to a type ``ty`` of higher bitwidth, while extending
   the sign bit.
   
   ``k.zext(ty)``
   ~~~~~~~~~~~~~~
   
   Sign extend ``k`` to a type ``ty`` of higher bitwidth, all new bits are
   0s.
   
   ``k.fptrunc(ty)``
   ~~~~~~~~~~~~~~~~~
   
   Truncate floating point constant ``k`` to floating point type ``ty`` of
   lower size than k's.
   
   ``k.fpext(ty)``
   ~~~~~~~~~~~~~~~
   
   Extend floating point constant ``k`` to floating point type ``ty`` of
   higher size than k's.
   
   ``k.uitofp(ty)``
   ~~~~~~~~~~~~~~~~
   
   Convert an unsigned integer constant ``k`` to floating point constant of
   type ``ty``.
   
   ``k.sitofp(ty)``
   ~~~~~~~~~~~~~~~~
   
   Convert a signed integer constant ``k`` to floating point constant of
   type ``ty``.
   
   ``k.fptoui(ty)``
   ~~~~~~~~~~~~~~~~
   
   Convert a floating point constant ``k`` to an unsigned integer constant
   of type ``ty``.
   
   ``k.fptosi(ty)``
   ~~~~~~~~~~~~~~~~
   
   Convert a floating point constant ``k`` to a signed integer constant of
   type ``ty``.
   
   ``k.ptrtoint(ty)``
   ~~~~~~~~~~~~~~~~~~
   
   Convert a pointer constant ``k`` to an integer constant of type ``ty``.
   
   ``k.inttoptr(ty)``
   ~~~~~~~~~~~~~~~~~~
   
   Convert an integer constant ``k`` to a pointer constant of type ``ty``.
   
   ``k.bitcast(ty)``
   ~~~~~~~~~~~~~~~~~
   
   Convert ``k`` to a (equal-width) constant of type ``ty``.
   
   ``k.select(cond,k2,k3)``
   ~~~~~~~~~~~~~~~~~~~~~~~~
   
   Replace value with ``k2`` if the 1-bit integer constant ``cond`` is 1,
   else with ``k3``.
   
   ``k.extract_element(idx)``
   ~~~~~~~~~~~~~~~~~~~~~~~~~~
   
   Extract value at ``idx`` (integer constant) from a vector constant
   ``k``.
   
   ``k.insert_element(k2,idx)``
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   
   Insert value ``k2`` (scalar constant) at index ``idx`` (integer
   constant) of vector constant ``k``.
   
   ``k.shuffle_vector(k2,mask)``
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   
   Shuffle vector constant ``k`` based on vector constants ``k2`` and
   ``mask``.
   
   --------------
   
   # Other Constant Classes
   The following subclasses of ``Constant`` do not provide additional
   methods, **they serve only to provide richer type information.**
   
   Subclass \| LLVM C++ Class \| Remarks \|
   ---------\|----------------\|---------\| ``ConstantExpr`` \|
   ``llvmConstantExpr`` \| A constant expression \|
   ``ConstantAggregateZero``\ \| ``llvmConstantAggregateZero``\ \| All-zero
   constant \| ``ConstantInt``\ \| ``llvmConstantInt``\ \| An integer
   constant \| ``ConstantFP``\ \| ``llvmConstantFP``\ \| A floating-point
   constant \| ``ConstantArray``\ \| ``llvmConstantArray``\ \| An array
   constant \| ``ConstantStruct``\ \| ``llvmConstantStruct``\ \| A
   structure constant \| ``ConstantVector``\ \| ``llvmConstantVector``\ \|
   A vector constant \| ``ConstantPointerNull``\ \|
   ``llvmConstantPointerNull``\ \| All-zero pointer constant \|
   ``UndefValue``\ \| ``llvmUndefValue``\ \| corresponds to ``undef`` of
   LLVM IR \|
   
   These types are helpful in ``isinstance`` checks, like so:
   
   {% highlight python %} ti = Type.int(32) k1 = Constant.int(ti, 42) #
   int32_t k1 = 42; k2 = Constant.array(ti, [k1, k1]) # int32_t k2[] = {
   k1, k1 };
   
   assert isinstance(k1, ConstantInt) assert isinstance(k2, ConstantArray)
   
