d36cd1dbc7
Some classes have docstrings, and lack rST docs (e.g. Module), few others vice versa. It's unclear what is the best way to deal with this. IMHO, docstrings should prevail, i.e. existing docs would rather be moved to docstings. Anyway, for now just make sure that users don't miss documentation, even if it's just list of classmembers.
362 lines
8.9 KiB
ReStructuredText
362 lines
8.9 KiB
ReStructuredText
+-------------------------------+
|
|
| layout: page |
|
|
+-------------------------------+
|
|
| title: Constant (llvm.core) |
|
|
+-------------------------------+
|
|
|
|
llvm.core.Constant
|
|
==================
|
|
|
|
``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)
|
|
|
|
|
|
Automatically Generated Documentation
|
|
-------------------------------------
|
|
.. autoclass:: llvm.core.Constant
|
|
:members:
|
|
:undoc-members:
|