| ********************************** |
| SMT-LIBv2 Input Language Reference |
| ********************************** |
| |
| .. highlight:: lisp |
| |
| This page contains a short description for the SMTLibv2 input language |
| that STP can parse. For a longer description please read `this |
| PDF <http://www.grammatech.com/resource/smt/SMTLIBTutorial.pdf>`__. |
| |
| Header |
| ====== |
| |
| The SMT-LIBv2 format uses a header to tell the solver which type of |
| problem is coming, the header needed is: |
| |
| :: |
| |
| (set-logic QF_ABV) |
| (set-info :smt-lib-version 2.0) |
| |
| QF_BV is for bitvector problems, QF_ABV is for bitvector and array |
| problems. |
| |
| Declarations |
| ============ |
| |
| Bitvector expressions (or terms) are constructed out of bitvector |
| constants, bitvector variables and the functions listed below. In STP |
| all variables have to declared before the point of use. An example |
| declaration of a bitvector variable of length, say 32, is as follows: |
| |
| :: |
| |
| (declare-fun x () (_ BitVec 32)) |
| |
| An example of an array declaration with 32 bit indices, and 7 bit |
| results is: |
| |
| :: |
| |
| (declare-fun a () (Array (_ BitVec 32) (_ BitVec 7))) |
| |
| Functions and Terms |
| =================== |
| |
| Bitvector variables (or terms) of length 0 are not allowed. Bitvector |
| constants can be represented in binary or hexadecimal format. The |
| rightmost bit is called the least significant bit (LSB), and the |
| leftmost bit is the most significant bit (MSB). The index of the LSB is |
| 0, and the index of the MSB is *n*-1 for an *n*-bit constant. This |
| convention naturally extends to all bitvector expressions. |
| |
| Following are some examples of bitvector constants in binary and hexadecimal: |
| |
| :: |
| |
| #b0000111101010000 |
| #x0f50 |
| |
| The bitvector implementation in STP supports a very large number of |
| functions and predicates. The functions are categorized into word-level |
| functions, bitwise functions, and arithmetic functions. |
| |
| Word-level functions |
| ~~~~~~~~~~~~~~~~~~~~ |
| |
| +----------------+-----------------+----------------------------------+ |
| | Name | Symbol | Example | |
| +================+=================+==================================+ |
| | Concatenation | ``concat`` | ``(concat (_ bv0 16) x)`` | |
| +----------------+-----------------+----------------------------------+ |
| | Extraction | ``extract`` | ``((_ extract 7 0) o277135888)`` | |
| +----------------+-----------------+----------------------------------+ |
| | Left Shift | ``bvlshl`` | ``(bvlshl x y)`` | |
| +----------------+-----------------+----------------------------------+ |
| | Light Shift | ``bvlshr`` | ``(bvlshr x y)`` | |
| +----------------+-----------------+----------------------------------+ |
| | Sign Extension | ``sign_extend`` | ``((_ sign_extend 24) x)`` | |
| +----------------+-----------------+----------------------------------+ |
| | Array READ | ``select`` | ``(select e829 v817)`` | |
| +----------------+-----------------+----------------------------------+ |
| | Array WRITE | ``store`` | ``(store a x y)`` | |
| +----------------+-----------------+----------------------------------+ |
| |
| Notes: |
| |
| - For extraction terms, say ``((_extract i j) t)``, *n* > *i* >= *j* >= 0, where |
| *n* is the length of *t*. |
| |
| - For left shift terms, ``t << k`` is equal to *k* 0’s appended to *t*. The length |
| of ``t << k`` is *n*. |
| |
| - For right shift terms, say ``t >> k``, the term is equal to the bitvector |
| obtained by *k* 0’s followed by ``t[n-1:k]``. The length of ``t >> k`` is *n*. |
| |
| |
| Bitwise functions |
| ~~~~~~~~~~~~~~~~~ |
| |
| +-------------+-----------+--------------------------+ |
| | Name | Symbol | Example | |
| +=============+===========+==========================+ |
| | Bitwise AND | ``bvand`` | ``(bvand o1 o6)`` | |
| +-------------+-----------+--------------------------+ |
| | Bitwise OR | ``bvor`` | ``(bvor var29 var30)`` | |
| +-------------+-----------+--------------------------+ |
| | Bitwise NOT | ``bvnot`` | ``(bvnot (_ bv0 2000))`` | |
| +-------------+-----------+--------------------------+ |
| | Bitwise XOR | ``bvxor`` | ``(bvxor e7015 e7019)`` | |
| +-------------+-----------+--------------------------+ |
| |
| The arguments of bitwise functions have the same length. |
| |
| Footer |
| ====== |
| |
| After defining the problem, tell STP what to do. Usually this is to |
| check the satisfiability, then to exit: |
| |
| :: |
| |
| (check-sat) |
| (exit) |
| |
| Examples |
| ======== |
| |
| There are many SMT-LIBv2 format examples in STP’s source code repository. |
| Look for files with a .smt2 extension here. Signed division of -1/-2 = |
| 0, should be satisfiable: |
| |
| :: |
| |
| (set-logic QF_BV) |
| (set-info :smt-lib-version 2.0) |
| (set-info :status sat) |
| (assert (= (bvsdiv (_ bv3 2) (_ bv2 2)) (_ bv0 2))) |
| (check-sat) |
| (exit) |