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) - ``solver.And(x == y, x > 0)`` * - Or - Logical Or (on boolean expressions) - ``solver.Or(x == y, y < 10)`` * - Not - Logical Not (on a boolean expression) - ``solver.Not(x == y)`` is the same as ``x != y`` * - If - An If-then-else - Choose the maximum of two expressions: ``solver.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``