mirror of
https://github.com/angr/angr
synced 2026-06-08 13:09:39 +00:00
Kevin Phoenix
101 lines
2.9 KiB
ReStructuredText
101 lines
2.9 KiB
ReStructuredText
List of Claripy Operations
|
|
==========================
|
|
|
|
Arithmetic and Logic
|
|
~~~~~~~~~~~~~~~~~~~~
|
|
|
|
.. list-table::
|
|
:header-rows: 1
|
|
|
|
* - Name
|
|
- Description
|
|
- Example
|
|
* - LShR
|
|
- Logically shifts an expression to the right. (the default shifts are
|
|
arithmetic)
|
|
- ``x.LShR(10)``
|
|
* - RotateLeft
|
|
- Rotates an expression left
|
|
- ``x.RotateLeft(8)``
|
|
* - RotateRight
|
|
- Rotates an expression right
|
|
- ``x.RotateRight(8)``
|
|
* - And
|
|
- Logical And (on boolean expressions)
|
|
- ``claripy.And(x == y, x > 0)``
|
|
* - Or
|
|
- Logical Or (on boolean expressions)
|
|
- ``claripy.Or(x == y, y < 10)``
|
|
* - Not
|
|
- Logical Not (on a boolean expression)
|
|
- ``claripy.Not(x == y)`` is the same as ``x != y``
|
|
* - If
|
|
- An If-then-else
|
|
- Choose the maximum of two expressions: ``claripy.If(x > y, x, y)``
|
|
* - ULE
|
|
- Unsigned less than or equal to
|
|
- Check if x is less than or equal to y: ``x.ULE(y)``
|
|
* - ULT
|
|
- Unsigned less than
|
|
- Check if x is less than y: ``x.ULT(y)``
|
|
* - UGE
|
|
- Unsigned greater than or equal to
|
|
- Check if x is greater than or equal to y: ``x.UGE(y)``
|
|
* - UGT
|
|
- Unsigned greater than
|
|
- Check if x is greater than y: ``x.UGT(y)``
|
|
* - SLE
|
|
- Signed less than or equal to
|
|
- Check if x is less than or equal to y: ``x.SLE(y)``
|
|
* - SLT
|
|
- Signed less than
|
|
- Check if x is less than y: ``x.SLT(y)``
|
|
* - SGE
|
|
- Signed greater than or equal to
|
|
- Check if x is greater than or equal to y: ``x.SGE(y)``
|
|
* - SGT
|
|
- Signed greater than
|
|
- Check if x is greater than y: ``x.SGT(y)``
|
|
|
|
|
|
.. todo:: Add the floating point ops
|
|
|
|
Bitvector Manipulation
|
|
~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
.. list-table::
|
|
:header-rows: 1
|
|
|
|
* - Name
|
|
- Description
|
|
- Example
|
|
* - SignExt
|
|
- Pad a bitvector on the left with ``n`` sign bits
|
|
- ``x.sign_extend(n)``
|
|
* - ZeroExt
|
|
- Pad a bitvector on the left with ``n`` zero bits
|
|
- ``x.zero_extend(n)``
|
|
* - Extract
|
|
- Extracts the given bits (zero-indexed from the *right*, inclusive) from
|
|
an expression.
|
|
- Extract the least significant byte of x: ``x[7:0]``
|
|
* - Concat
|
|
- Concatenates any number of expressions together into a new expression.
|
|
- ``x.concat(y, ...)``
|
|
|
|
|
|
Extra Functionality
|
|
~~~~~~~~~~~~~~~~~~~
|
|
|
|
There's a bunch of prepackaged behavior that you *could* implement by analyzing
|
|
the ASTs and composing sets of operations, but here's an easier way to do it:
|
|
|
|
|
|
* You can chop a bitvector into a list of chunks of ``n`` bits with
|
|
``val.chop(n)``
|
|
* You can endian-reverse a bitvector with ``x.reversed``
|
|
* You can get the width of a bitvector in bits with ``val.length``
|
|
* You can test if an AST has any symbolic components with ``val.symbolic``
|
|
* You can get a set of the names of all the symbolic variables implicated in the
|
|
construction of an AST with ``val.variables``
|