mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-15 13:28:47 +00:00
Code Activity

merge

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2017-10-07 19:24:30 +01:00
parent 6b88446ee8 deba7d4d6e
commit c1b243a8e3
45 changed files with 1345 additions and 699 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
.travis.yml
View file

@ -22,10 +22,17 @@ env:
# 64-bit Clang 3.9 RelWithDebInfo # 64-bit Clang 3.9 RelWithDebInfo
- LINUX_BASE=ubuntu_16.04 C_COMPILER=/usr/bin/clang-3.9 CXX_COMPILER=/usr/bin/clang++-3.9 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=RelWithDebInfo - LINUX_BASE=ubuntu_16.04 C_COMPILER=/usr/bin/clang-3.9 CXX_COMPILER=/usr/bin/clang++-3.9 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=RelWithDebInfo
# Debug builds
#
# Note the unit tests for the debug builds are compiled but **not**
# executed. This is because the debug build of unit tests takes a large
# amount of time to execute compared to the optimized builds. The hope is
# that just running the optimized unit tests is sufficient.
#
# 64-bit GCC 5.4 Debug # 64-bit GCC 5.4 Debug
- LINUX_BASE=ubuntu_16.04 C_COMPILER=/usr/bin/gcc-5 CXX_COMPILER=/usr/bin/g++-5 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=Debug - LINUX_BASE=ubuntu_16.04 C_COMPILER=/usr/bin/gcc-5 CXX_COMPILER=/usr/bin/g++-5 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=Debug RUN_UNIT_TESTS=BUILD_ONLY
# 64-bit Clang Debug # 64-bit Clang Debug
- LINUX_BASE=ubuntu_16.04 C_COMPILER=/usr/bin/clang-3.9 CXX_COMPILER=/usr/bin/clang++-3.9 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=Debug - LINUX_BASE=ubuntu_16.04 C_COMPILER=/usr/bin/clang-3.9 CXX_COMPILER=/usr/bin/clang++-3.9 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=Debug RUN_UNIT_TESTS=BUILD_ONLY
# 32-bit GCC 5.4 RelWithDebInfo # 32-bit GCC 5.4 RelWithDebInfo
- LINUX_BASE=ubuntu32_16.04 C_COMPILER=/usr/bin/gcc-5 CXX_COMPILER=/usr/bin/g++-5 TARGET_ARCH=i686 Z3_BUILD_TYPE=RelWithDebInfo - LINUX_BASE=ubuntu32_16.04 C_COMPILER=/usr/bin/gcc-5 CXX_COMPILER=/usr/bin/g++-5 TARGET_ARCH=i686 Z3_BUILD_TYPE=RelWithDebInfo
@ -57,7 +64,7 @@ env:
# 64-bit GCC 4.8 RelWithDebInfo # 64-bit GCC 4.8 RelWithDebInfo
- LINUX_BASE=ubuntu_14.04 C_COMPILER=/usr/bin/gcc-4.8 CXX_COMPILER=/usr/bin/g++-4.8 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=RelWithDebInfo - LINUX_BASE=ubuntu_14.04 C_COMPILER=/usr/bin/gcc-4.8 CXX_COMPILER=/usr/bin/g++-4.8 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=RelWithDebInfo
# 64-bit GCC 4.8 Debug # 64-bit GCC 4.8 Debug
- LINUX_BASE=ubuntu_14.04 C_COMPILER=/usr/bin/gcc-4.8 CXX_COMPILER=/usr/bin/g++-4.8 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=Debug - LINUX_BASE=ubuntu_14.04 C_COMPILER=/usr/bin/gcc-4.8 CXX_COMPILER=/usr/bin/g++-4.8 TARGET_ARCH=x86_64 Z3_BUILD_TYPE=Debug RUN_UNIT_TESTS=BUILD_ONLY
# macOS (a.k.a OSX) support # macOS (a.k.a OSX) support
matrix: matrix:

6
README.md
View file

@ -12,9 +12,9 @@ See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z
## Build status ## Build status
| Windows x86 | Windows x64 | Ubuntu x64 | Ubuntu x86 | Debian x64 | OSX | TravisCI | | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI |
| ----------- | ----------- | ---------- | ---------- | ---------- | --- | -------- | | ----------- | ----------- | ---------- | ---------- | --- | -------- |
[![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![ubuntu-x86-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/6/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=6) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3)
[1]: #building-z3-on-windows-using-visual-studio-command-prompt [1]: #building-z3-on-windows-using-visual-studio-command-prompt
[2]: #building-z3-using-make-and-gccclang [2]: #building-z3-using-make-and-gccclang

48
contrib/ci/Dockerfiles/z3_build.Dockerfile
View file

@ -2,34 +2,33 @@ ARG DOCKER_IMAGE_BASE
FROM ${DOCKER_IMAGE_BASE} FROM ${DOCKER_IMAGE_BASE}
# Specify defaults. This can be changed when invoking # Build arguments. This can be changed when invoking
# `docker build`. # `docker build`.
ARG ASAN_BUILD=0 ARG ASAN_BUILD
ARG BUILD_DOCS=0 ARG BUILD_DOCS
ARG CC=gcc ARG CC
ARG CXX=g++ ARG CXX
ARG DOTNET_BINDINGS=1 ARG DOTNET_BINDINGS
ARG JAVA_BINDINGS=1 ARG JAVA_BINDINGS
ARG NO_SUPPRESS_OUTPUT=0 ARG NO_SUPPRESS_OUTPUT
ARG PYTHON_BINDINGS=1 ARG PYTHON_BINDINGS
ARG PYTHON_EXECUTABLE=/usr/bin/python2.7 ARG PYTHON_EXECUTABLE=/usr/bin/python2.7
ARG RUN_SYSTEM_TESTS=1 ARG RUN_SYSTEM_TESTS
ARG RUN_UNIT_TESTS=1 ARG RUN_UNIT_TESTS
ARG TARGET_ARCH=x86_64 ARG TARGET_ARCH
ARG TEST_INSTALL=1 ARG TEST_INSTALL
ARG UBSAN_BUILD=0 ARG UBSAN_BUILD
ARG USE_LIBGMP=0 ARG USE_LIBGMP
ARG USE_LTO=0 ARG USE_LTO
ARG USE_OPENMP=1 ARG USE_OPENMP
ARG Z3_SRC_DIR=/home/user/z3_src ARG Z3_SRC_DIR=/home/user/z3_src
ARG Z3_BUILD_TYPE=RelWithDebInfo ARG Z3_BUILD_TYPE
ARG Z3_CMAKE_GENERATOR=Ninja ARG Z3_CMAKE_GENERATOR
ARG Z3_INSTALL_PREFIX=/usr ARG Z3_INSTALL_PREFIX
ARG Z3_STATIC_BUILD=0 ARG Z3_STATIC_BUILD
# Blank default indicates use latest.
ARG Z3_SYSTEM_TEST_GIT_REVISION ARG Z3_SYSTEM_TEST_GIT_REVISION
ARG Z3_WARNINGS_AS_ERRORS=SERIOUS_ONLY ARG Z3_WARNINGS_AS_ERRORS
ARG Z3_VERBOSE_BUILD_OUTPUT=0 ARG Z3_VERBOSE_BUILD_OUTPUT
ENV \ ENV \
ASAN_BUILD=${ASAN_BUILD} \ ASAN_BUILD=${ASAN_BUILD} \
@ -74,6 +73,7 @@ ADD *.txt *.md RELEASE_NOTES ${Z3_SRC_DIR}/
ADD \ ADD \
/contrib/ci/scripts/build_z3_cmake.sh \ /contrib/ci/scripts/build_z3_cmake.sh \
/contrib/ci/scripts/ci_defaults.sh \
/contrib/ci/scripts/set_compiler_flags.sh \ /contrib/ci/scripts/set_compiler_flags.sh \
/contrib/ci/scripts/set_generator_args.sh \ /contrib/ci/scripts/set_generator_args.sh \
${Z3_SRC_DIR}/contrib/ci/scripts/ ${Z3_SRC_DIR}/contrib/ci/scripts/

48
contrib/ci/README.md
View file

@ -31,7 +31,7 @@ the future.
* `NO_SUPPRESS_OUTPUT` - Don't suppress output of some commands (`0` or `1`) * `NO_SUPPRESS_OUTPUT` - Don't suppress output of some commands (`0` or `1`)
* `PYTHON_BINDINGS` - Build and test Python API bindings (`0` or `1`) * `PYTHON_BINDINGS` - Build and test Python API bindings (`0` or `1`)
* `RUN_SYSTEM_TESTS` - Run system tests (`0` or `1`) * `RUN_SYSTEM_TESTS` - Run system tests (`0` or `1`)
* `RUN_UNIT_TESTS` - Run unit tests (`0` or `1`) * `RUN_UNIT_TESTS` - Run unit tests (`BUILD_ONLY` or `BUILD_AND_RUN` or `SKIP`)
* `TARGET_ARCH` - Target architecture (`x86_64` or `i686`) * `TARGET_ARCH` - Target architecture (`x86_64` or `i686`)
* `TEST_INSTALL` - Test running `install` target (`0` or `1`) * `TEST_INSTALL` - Test running `install` target (`0` or `1`)
* `UBSAN_BUILD` - Do [UndefinedBehaviourSanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html) build (`0` or `1`) * `UBSAN_BUILD` - Do [UndefinedBehaviourSanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html) build (`0` or `1`)
@ -58,8 +58,9 @@ The `scripts/travis_ci_linux_entry_point.sh` script
variables (if set) into the build using the `--build-arg` argument of the `docker run` variables (if set) into the build using the `--build-arg` argument of the `docker run`
command. command.
If an environemnt variable is not set a defaults value is used which can be The default values of the configuration environment variables
found in `Dockerfiles/z3_build.Dockerfile`. can be found in
[`scripts/ci_defaults.sh`](scripts/ci_defaults.sh).
#### Linux specific configuration variables #### Linux specific configuration variables
@ -67,8 +68,9 @@ found in `Dockerfiles/z3_build.Dockerfile`.
#### Reproducing a build locally #### Reproducing a build locally
A build can be reproduced locally by using the `scripts/travis_ci_linux_entry_point.sh` A build can be reproduced locally by using the
script and setting the appropriate environment variable. `scripts/travis_ci_linux_entry_point.sh` script and setting the appropriate
environment variable.
For example lets say we wanted to reproduce the build below. For example lets say we wanted to reproduce the build below.
@ -104,11 +106,43 @@ feature might be removed in the future.
It may be better to just build the base image once (outside of TravisCI), upload It may be better to just build the base image once (outside of TravisCI), upload
it to [DockerHub](https://hub.docker.com/) and have the build pull down the pre-built it to [DockerHub](https://hub.docker.com/) and have the build pull down the pre-built
image everytime. image every time.
An [organization](https://hub.docker.com/u/z3prover/) has been created on An [organization](https://hub.docker.com/u/z3prover/) has been created on
DockerHub for this. DockerHub for this.
### macOS ### macOS
Not yet implemented. For macOS we execute directly on TravisCI's macOS environment. The entry point
for the TravisCI builds is the
[`scripts/travis_ci_osx_entry_point.sh`](scripts/travis_ci_osx_entry_point.sh)
scripts.
#### macOS specific configuration variables
* `MACOS_SKIP_DEPS_UPDATE` - If set to `1` installing the necessary build dependencies
is skipped. This is useful for local testing if the dependencies are already installed.
* `MACOS_UPDATE_CMAKE` - If set to `1` the installed version of CMake will be upgraded.
#### Reproducing a build locally
To reproduce a build (e.g. like the one shown below)
```yaml
- os: osx
osx_image: xcode8.3
# Note: Apple Clang does not support OpenMP
env: Z3_BUILD_TYPE=RelWithDebInfo USE_OPENMP=0
```
Run the following:
```bash
TRAVIS_BUILD_DIR=$(pwd) \
Z3_BUILD_TYPE=RelWithDebInfo \
USE_OPEN_MP=0 \
contrib/ci/scripts/travis_ci_osx_entry_point.sh
```
Note this assumes that the current working directory is the root of the Z3
git repository.

54
contrib/ci/scripts/ci_defaults.sh Normal file
View file

@ -0,0 +1,54 @@
# This file should be sourced by other scripts
# and not executed directly
# Set CI build defaults
export ASAN_BUILD="${ASAN_BUILD:-0}"
export BUILD_DOCS="${BUILD_DOCS:-0}"
export DOTNET_BINDINGS="${DOTNET_BINDINGS:-1}"
export JAVA_BINDINGS="${JAVA_BINDINGS:-1}"
export NO_SUPPRESS_OUTPUT="${NO_SUPPRESS_OUTPUT:-0}"
export PYTHON_BINDINGS="${PYTHON_BINDINGS:-1}"
export RUN_SYSTEM_TESTS="${RUN_SYSTEM_TESTS:-1}"
export RUN_UNIT_TESTS="${RUN_UNIT_TESTS:-BUILD_AND_RUN}"
export TARGET_ARCH="${TARGET_ARCH:-x86_64}"
export TEST_INSTALL="${TEST_INSTALL:-1}"
export UBSAN_BUILD="${UBSAN_BUILD:-0}"
export USE_LIBGMP="${USE_LIBGMP:-0}"
export USE_LTO="${USE_LTO:-0}"
export USE_OPENMP="${USE_OPENMP:-1}"
export Z3_BUILD_TYPE="${Z3_BUILD_TYPE:-RelWithDebInfo}"
export Z3_CMAKE_GENERATOR="${Z3_CMAKE_GENERATOR:-Ninja}"
export Z3_STATIC_BUILD="${Z3_STATIC_BUILD:-0}"
# Default is blank which means get latest revision
export Z3_SYSTEM_TEST_GIT_REVISION="${Z3_SYSTEM_TEST_GIT_REVISION:-}"
export Z3_WARNINGS_AS_ERRORS="${Z3_WARNINGS_AS_ERRORS:-SERIOUS_ONLY}"
export Z3_VERBOSE_BUILD_OUTPUT="${Z3_VERBOSE_BUILD_OUTPUT:-0}"
# Platform specific defaults
PLATFORM="$(uname -s)"
case "${PLATFORM}" in
Linux*)
export C_COMPILER="${C_COMPILER:-gcc}"
export CXX_COMPILER="${CXX_COMPILER:-g++}"
export Z3_INSTALL_PREFIX="${Z3_INSTALL_PREFIX:-/usr}"
;;
Darwin*)
export C_COMPILER="${C_COMPILER:-clang}"
export CXX_COMPILER="${CXX_COMPILER:-clang++}"
export Z3_INSTALL_PREFIX="${Z3_INSTALL_PREFIX:-/usr/local}"
;;
*)
echo "Unknown platform \"${PLATFORM}\""
exit 1
;;
esac
unset PLATFORM
# NOTE: The following variables are not set here because
# they are specific to the CI implementation
# PYTHON_EXECUTABLE
# Z3_SRC_DIR
# Z3_BUILD_DIR
# Z3_SYSTEM_TEST_DIR

2
contrib/ci/scripts/set_generator_args.sh
View file

@ -1,4 +1,4 @@
# This script should is intended to be included by other # This script is intended to be included by other
# scripts and should not be executed directly # scripts and should not be executed directly
: ${Z3_CMAKE_GENERATOR?"Z3_CMAKE_GENERATOR must be specified"} : ${Z3_CMAKE_GENERATOR?"Z3_CMAKE_GENERATOR must be specified"}

36
contrib/ci/scripts/test_z3_unit_tests_cmake.sh
View file

@ -10,17 +10,35 @@ set -o pipefail
: ${Z3_BUILD_DIR?"Z3_BUILD_DIR must be specified"} : ${Z3_BUILD_DIR?"Z3_BUILD_DIR must be specified"}
: ${RUN_UNIT_TESTS?"RUN_UNIT_TESTS must be specified"} : ${RUN_UNIT_TESTS?"RUN_UNIT_TESTS must be specified"}
if [ "X${RUN_UNIT_TESTS}" != "X1" ]; then
echo "Skipping unit tests"
exit 0
fi
# Set CMake generator args # Set CMake generator args
source ${SCRIPT_DIR}/set_generator_args.sh source ${SCRIPT_DIR}/set_generator_args.sh
cd "${Z3_BUILD_DIR}" cd "${Z3_BUILD_DIR}"
# Build and run internal tests function build_unit_tests() {
cmake --build $(pwd) --target test-z3 "${GENERATOR_ARGS[@]}" # Build internal tests
# Run all tests that don't require arguments cmake --build $(pwd) --target test-z3 "${GENERATOR_ARGS[@]}"
run_quiet ./test-z3 /a }
function run_unit_tests() {
# Run all tests that don't require arguments
run_quiet ./test-z3 /a
}
case "${RUN_UNIT_TESTS}" in
BUILD_AND_RUN)
build_unit_tests
run_unit_tests
;;
BUILD_ONLY)
build_unit_tests
;;
SKIP)
echo "RUN_UNIT_TESTS set to \"${RUN_UNIT_TESTS}\" so skipping build and run"
exit 0
;;
*)
echo "Error: RUN_UNIT_TESTS set to unhandled value \"${RUN_UNIT_TESTS}\""
exit 1
;;
esac

11
contrib/ci/scripts/travis_ci_linux_entry_point.sh
View file

@ -11,16 +11,21 @@ DOCKER_FILE_DIR="$(cd ${SCRIPT_DIR}/../Dockerfiles; echo $PWD)"
: ${LINUX_BASE?"LINUX_BASE must be specified"} : ${LINUX_BASE?"LINUX_BASE must be specified"}
# Sanity check. Current working directory should be repo root # Sanity check. Current working directory should be repo root
if [ ! -f "./README.md" ]; then if [ ! -f "./README.md" ]; then
echo "Current working directory should be repo root" echo "Current working directory should be repo root"
exit 1 exit 1
fi fi
# Get defaults
source "${SCRIPT_DIR}/ci_defaults.sh"
BUILD_OPTS=() BUILD_OPTS=()
# Override options if they have been provided. # Pass Docker build arguments
# Otherwise the defaults in the Docker file will be used if [ -n "${Z3_BUILD_TYPE}" ]; then
BUILD_OPTS+=("--build-arg" "Z3_BUILD_TYPE=${Z3_BUILD_TYPE}")
fi
if [ -n "${Z3_CMAKE_GENERATOR}" ]; then if [ -n "${Z3_CMAKE_GENERATOR}" ]; then
BUILD_OPTS+=("--build-arg" "Z3_CMAKE_GENERATOR=${Z3_CMAKE_GENERATOR}") BUILD_OPTS+=("--build-arg" "Z3_CMAKE_GENERATOR=${Z3_CMAKE_GENERATOR}")
fi fi

31
contrib/ci/scripts/travis_ci_osx_entry_point.sh
View file

@ -6,26 +6,8 @@ set -x
set -e set -e
set -o pipefail set -o pipefail
# Set defaults # Get defaults
# FIXME: Refactor this so we don't need to stay in sync with source "${SCRIPT_DIR}/ci_defaults.sh"
# `z3_build.Dockerfile`.
export ASAN_BUILD="${ASAN_BUILD:-0}"
export BUILD_DOCS="${BUILD_DOCS:-0}"
export C_COMPILER="${C_COMPILER:-clang}"
export CXX_COMPILER="${CXX_COMPILER:-clang++}"
export DOTNET_BINDINGS="${DOTNET_BINDINGS:-1}"
export JAVA_BINDINGS="${JAVA_BINDINGS:-1}"
export NO_SUPPRESS_OUTPUT="${NO_SUPPRESS_OUTPUT:-0}"
export PYTHON_BINDINGS="${PYTHON_BINDINGS:-1}"
export PYTHON_EXECUTABLE="$(which python)"
export RUN_SYSTEM_TESTS="${RUN_SYSTEM_TESTS:-1}"
export RUN_UNIT_TESTS="${RUN_UNIT_TESTS:-1}"
export TARGET_ARCH="${TARGET_ARCH:-x86_64}"
export TEST_INSTALL="${TEST_INSTALL:-1}"
export UBSAN_BUILD="${UBSAN_BUILD:-0}"
export USE_LIBGMP="${USE_LIBGMP:-0}"
export USE_LTO="${USE_LTO:-0}"
export USE_OPENMP="${USE_OPENMP:-1}"
if [ -z "${TRAVIS_BUILD_DIR}" ]; then if [ -z "${TRAVIS_BUILD_DIR}" ]; then
echo "TRAVIS_BUILD_DIR must be set to root of Z3 repository" echo "TRAVIS_BUILD_DIR must be set to root of Z3 repository"
@ -37,15 +19,12 @@ if [ ! -d "${TRAVIS_BUILD_DIR}" ]; then
exit 1 exit 1
fi fi
# These variables are specific to the macOS TravisCI
# implementation and are not set in `ci_defaults.sh`.
export PYTHON_EXECUTABLE="${PYTHON_EXECUTABLE:-$(which python)}"
export Z3_SRC_DIR="${TRAVIS_BUILD_DIR}" export Z3_SRC_DIR="${TRAVIS_BUILD_DIR}"
export Z3_BUILD_DIR="${Z3_SRC_DIR}/build" export Z3_BUILD_DIR="${Z3_SRC_DIR}/build"
export Z3_BUILD_TYPE="${Z3_BUILD_TYPE:-RelWithDebInfo}"
export Z3_CMAKE_GENERATOR="${Z3_CMAKE_GENERATOR:-Ninja}"
export Z3_INSTALL_PREFIX="${Z3_INSTALL_PREFIX:-/usr/local}"
export Z3_STATIC_BUILD="${Z3_STATIC_BUILD:-0}"
export Z3_SYSTEM_TEST_DIR="${Z3_SRC_DIR}/z3_system_test" export Z3_SYSTEM_TEST_DIR="${Z3_SRC_DIR}/z3_system_test"
export Z3_WARNINGS_AS_ERRORS="${Z3_WARNINGS_AS_ERRORS:-SERIOUS_ONLY}"
export Z3_VERBOSE_BUILD_OUTPUT="${Z3_VERBOSE_BUILD_OUTPUT:-0}"
# Overwrite whatever what set in TravisCI # Overwrite whatever what set in TravisCI
export CC="${C_COMPILER}" export CC="${C_COMPILER}"

19
doc/mk_api_doc.py
View file

@ -188,7 +188,7 @@ try:
if Z3PY_ENABLED: if Z3PY_ENABLED:
print("Z3Py documentation enabled") print("Z3Py documentation enabled")
doxygen_config_substitutions['PYTHON_API_FILES'] = 'z3.py' doxygen_config_substitutions['PYTHON_API_FILES'] = 'z3*.py'
else: else:
print("Z3Py documentation disabled") print("Z3Py documentation disabled")
doxygen_config_substitutions['PYTHON_API_FILES'] = '' doxygen_config_substitutions['PYTHON_API_FILES'] = ''
@ -288,8 +288,21 @@ try:
# Put z3py at the beginning of the search path to try to avoid picking up # Put z3py at the beginning of the search path to try to avoid picking up
# an installed copy of Z3py. # an installed copy of Z3py.
sys.path.insert(0, os.path.dirname(Z3PY_PACKAGE_PATH)) sys.path.insert(0, os.path.dirname(Z3PY_PACKAGE_PATH))
pydoc.writedoc('z3') for modulename in (
shutil.move('z3.html', os.path.join(OUTPUT_DIRECTORY, 'html', 'z3.html')) 'z3',
'z3.z3consts',
'z3.z3core',
'z3.z3num',
'z3.z3poly',
'z3.z3printer',
'z3.z3rcf',
'z3.z3types',
'z3.z3util',
):
pydoc.writedoc(modulename)
doc = modulename + '.html'
shutil.move(doc, os.path.join(OUTPUT_DIRECTORY, 'html', doc))
print("Generated pydoc Z3Py documentation.") print("Generated pydoc Z3Py documentation.")
if ML_ENABLED: if ML_ENABLED:

6
scripts/mk_util.py
View file

@ -1913,7 +1913,11 @@ class MLComponent(Component):
src_dir = self.to_src_dir src_dir = self.to_src_dir
mk_dir(os.path.join(BUILD_DIR, self.sub_dir)) mk_dir(os.path.join(BUILD_DIR, self.sub_dir))
api_src = get_component(API_COMPONENT).to_src_dir api_src = get_component(API_COMPONENT).to_src_dir
out.write('CXXFLAGS_OCAML=$(CXXFLAGS:/GL=)\n') # remove /GL; the ocaml tools don't like it. # remove /GL and -std=c++11; the ocaml tools don't like them.
if IS_WINDOWS:
out.write('CXXFLAGS_OCAML=$(CXXFLAGS:/GL=)\n')
else:
out.write('CXXFLAGS_OCAML=$(subst -std=c++11,,$(CXXFLAGS))\n')
if IS_WINDOWS: if IS_WINDOWS:
prefix_lib = '-L' + os.path.abspath(BUILD_DIR).replace('\\', '\\\\') prefix_lib = '-L' + os.path.abspath(BUILD_DIR).replace('\\', '\\\\')

2
src/api/python/z3/z3.py
View file

@ -120,7 +120,7 @@ def _get_args(args):
try: try:
if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)): if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)):
return args[0] return args[0]
elif len(args) == 1 and isinstance(args[0], set): elif len(args) == 1 and (isinstance(args[0], set) or isinstance(args[0], AstVector)):
return [arg for arg in args[0]] return [arg for arg in args[0]]
else: else:
return args return args

3
src/ast/ast.cpp
View file

@ -471,6 +471,9 @@ bool compare_nodes(ast const * n1, ast const * n2) {
compare_arrays(to_quantifier(n1)->get_decl_sorts(), compare_arrays(to_quantifier(n1)->get_decl_sorts(),
to_quantifier(n2)->get_decl_sorts(), to_quantifier(n2)->get_decl_sorts(),
to_quantifier(n1)->get_num_decls()) && to_quantifier(n1)->get_num_decls()) &&
compare_arrays(to_quantifier(n1)->get_decl_names(),
to_quantifier(n2)->get_decl_names(),
to_quantifier(n1)->get_num_decls()) &&
to_quantifier(n1)->get_expr() == to_quantifier(n2)->get_expr() && to_quantifier(n1)->get_expr() == to_quantifier(n2)->get_expr() &&
to_quantifier(n1)->get_weight() == to_quantifier(n2)->get_weight() && to_quantifier(n1)->get_weight() == to_quantifier(n2)->get_weight() &&
to_quantifier(n1)->get_num_patterns() == to_quantifier(n2)->get_num_patterns() && to_quantifier(n1)->get_num_patterns() == to_quantifier(n2)->get_num_patterns() &&

9
src/ast/expr_abstract.cpp
View file

@ -19,6 +19,7 @@ Notes:
#include "ast/expr_abstract.h" #include "ast/expr_abstract.h"
#include "util/map.h" #include "util/map.h"
#include "ast/ast_pp.h"
void expr_abstractor::operator()(unsigned base, unsigned num_bound, expr* const* bound, expr* n, expr_ref& result) { void expr_abstractor::operator()(unsigned base, unsigned num_bound, expr* const* bound, expr* n, expr_ref& result) {
@ -109,6 +110,9 @@ void expr_abstractor::operator()(unsigned base, unsigned num_bound, expr* const*
void expr_abstract(ast_manager& m, unsigned base, unsigned num_bound, expr* const* bound, expr* n, expr_ref& result) { void expr_abstract(ast_manager& m, unsigned base, unsigned num_bound, expr* const* bound, expr* n, expr_ref& result) {
expr_abstractor abs(m); expr_abstractor abs(m);
abs(base, num_bound, bound, n, result); abs(base, num_bound, bound, n, result);
TRACE("expr_abstract",
tout << expr_ref(n, m) << "\n";
tout << result << "\n";);
} }
expr_ref mk_quantifier(bool is_forall, ast_manager& m, unsigned num_bound, app* const* bound, expr* n) { expr_ref mk_quantifier(bool is_forall, ast_manager& m, unsigned num_bound, app* const* bound, expr* n) {
@ -123,6 +127,11 @@ expr_ref mk_quantifier(bool is_forall, ast_manager& m, unsigned num_bound, app*
} }
result = m.mk_quantifier(is_forall, num_bound, sorts.c_ptr(), names.c_ptr(), result); result = m.mk_quantifier(is_forall, num_bound, sorts.c_ptr(), names.c_ptr(), result);
} }
TRACE("expr_abstract",
tout << expr_ref(n, m) << "\n";
for (unsigned i = 0; i < num_bound; ++i) tout << expr_ref(bound[i], m) << " ";
tout << "\n";
tout << result << "\n";);
return result; return result;
} }

10
src/ast/expr_substitution.cpp
View file

@ -16,8 +16,9 @@ Author:
Notes: Notes:
--*/ --*/
#include "ast/expr_substitution.h"
#include "util/ref_util.h" #include "util/ref_util.h"
#include "ast/expr_substitution.h"
#include "ast/ast_pp.h"
typedef obj_map<expr, proof*> expr2proof; typedef obj_map<expr, proof*> expr2proof;
typedef obj_map<expr, expr_dependency*> expr2expr_dependency; typedef obj_map<expr, expr_dependency*> expr2expr_dependency;
@ -56,6 +57,13 @@ expr_substitution::~expr_substitution() {
reset(); reset();
} }
std::ostream& expr_substitution::display(std::ostream& out) {
for (auto & kv : m_subst) {
out << mk_pp(kv.m_key, m()) << " |-> " << mk_pp(kv.m_value, m()) << "\n";
}
return out;
}
void expr_substitution::insert(expr * c, expr * def, proof * def_pr, expr_dependency * def_dep) { void expr_substitution::insert(expr * c, expr * def, proof * def_pr, expr_dependency * def_dep) {
obj_map<expr, expr*>::obj_map_entry * entry = m_subst.insert_if_not_there2(c, 0); obj_map<expr, expr*>::obj_map_entry * entry = m_subst.insert_if_not_there2(c, 0);
if (entry->get_data().m_value == 0) { if (entry->get_data().m_value == 0) {

3
src/ast/expr_substitution.h
View file

@ -50,6 +50,8 @@ public:
bool contains(expr * s); bool contains(expr * s);
void reset(); void reset();
void cleanup(); void cleanup();
std::ostream& display(std::ostream& out);
}; };
class scoped_expr_substitution { class scoped_expr_substitution {
@ -84,6 +86,7 @@ public:
bool find(expr * s, expr * & def, proof * & def_pr, expr_dependency * & def_dep) { return m_subst.find(s, def, def_pr, def_dep); } bool find(expr * s, expr * & def, proof * & def_pr, expr_dependency * & def_dep) { return m_subst.find(s, def, def_pr, def_dep); }
bool contains(expr * s) { return m_subst.contains(s); } bool contains(expr * s) { return m_subst.contains(s); }
void cleanup() { m_subst.cleanup(); } void cleanup() { m_subst.cleanup(); }
std::ostream& display(std::ostream& out) { return m_subst.display(out); }
}; };
#endif #endif

6
src/ast/fpa/fpa2bv_converter.cpp
View file

@ -1180,8 +1180,6 @@ void fpa2bv_converter::mk_abs(sort * s, expr_ref & x, expr_ref & result) {
void fpa2bv_converter::mk_min(func_decl * f, unsigned num, expr * const * args, expr_ref & result) { void fpa2bv_converter::mk_min(func_decl * f, unsigned num, expr * const * args, expr_ref & result) {
SASSERT(num == 2); SASSERT(num == 2);
unsigned ebits = m_util.get_ebits(f->get_range());
unsigned sbits = m_util.get_sbits(f->get_range());
expr * x = args[0], * y = args[1]; expr * x = args[0], * y = args[1];
@ -1227,8 +1225,6 @@ void fpa2bv_converter::mk_min(func_decl * f, unsigned num, expr * const * args,
void fpa2bv_converter::mk_max(func_decl * f, unsigned num, expr * const * args, expr_ref & result) { void fpa2bv_converter::mk_max(func_decl * f, unsigned num, expr * const * args, expr_ref & result) {
SASSERT(num == 2); SASSERT(num == 2);
unsigned ebits = m_util.get_ebits(f->get_range());
unsigned sbits = m_util.get_sbits(f->get_range());
expr * x = args[0], *y = args[1]; expr * x = args[0], *y = args[1];
@ -3081,8 +3077,6 @@ void fpa2bv_converter::mk_to_ieee_bv(func_decl * f, unsigned num, expr * const *
mk_is_nan(x, x_is_nan); mk_is_nan(x, x_is_nan);
sort * fp_srt = m.get_sort(x); sort * fp_srt = m.get_sort(x);
unsigned ebits = m_util.get_ebits(fp_srt);
unsigned sbits = m_util.get_sbits(fp_srt);
expr_ref unspec(m); expr_ref unspec(m);
mk_to_ieee_bv_unspecified(f, num, args, unspec); mk_to_ieee_bv_unspecified(f, num, args, unspec);

4
src/ast/rewriter/maximize_ac_sharing.cpp
View file

@ -151,11 +151,7 @@ void maximize_ac_sharing::restore_entries(unsigned old_lim) {
} }
void maximize_ac_sharing::reset() { void maximize_ac_sharing::reset() {
restore_entries(0);
m_entries.reset();
m_cache.reset(); m_cache.reset();
m_region.reset();
m_scopes.reset();
} }
void maximize_bv_sharing::init_core() { void maximize_bv_sharing::init_core() {

7
src/cmd_context/cmd_context.cpp
View file

@ -870,6 +870,12 @@ void cmd_context::insert_rec_fun(func_decl* f, expr_ref_vector const& binding, s
lhs = m().mk_app(f, binding.size(), binding.c_ptr()); lhs = m().mk_app(f, binding.size(), binding.c_ptr());
eq = m().mk_eq(lhs, e); eq = m().mk_eq(lhs, e);
if (!ids.empty()) { if (!ids.empty()) {
if (is_var(e)) {
ptr_vector<sort> domain;
for (expr* b : binding) domain.push_back(m().get_sort(b));
insert_macro(f->get_name(), domain.size(), domain.c_ptr(), e);
return;
}
if (!is_app(e)) { if (!is_app(e)) {
throw cmd_exception("Z3 only supports recursive definitions that are proper terms (not binders or variables)"); throw cmd_exception("Z3 only supports recursive definitions that are proper terms (not binders or variables)");
} }
@ -1763,6 +1769,7 @@ void cmd_context::validate_model() {
continue; continue;
} }
try { try {
for_each_expr(contains_underspecified, a);
for_each_expr(contains_underspecified, r); for_each_expr(contains_underspecified, r);
} }
catch (contains_underspecified_op_proc::found) { catch (contains_underspecified_op_proc::found) {

29
src/interp/iz3mgr.cpp
View file

@ -33,9 +33,11 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <ostream> #include <ostream>
#include <sstream>
#include "ast/expr_abstract.h" #include "ast/expr_abstract.h"
#include "util/params.h" #include "util/params.h"
#include "ast/used_vars.h"
using namespace stl_ext; using namespace stl_ext;
@ -938,3 +940,30 @@ void iz3mgr::get_bound_substitutes(stl_ext::hash_map<ast,bool> &memo, const ast
} }
#endif #endif
unsigned iz3mgr::num_free_variables(const ast &e){
used_vars uv;
uv(to_expr(e.raw()));
return uv.get_num_vars();
}
iz3mgr::ast iz3mgr::close_universally (ast e){
used_vars uv;
uv(to_expr(e.raw()));
std::vector<ast> bvs;
stl_ext::hash_map<ast,ast> subst_memo;
for (unsigned i = 0; i < uv.get_max_found_var_idx_plus_1(); i++){
if (uv.get(i)) {
std::ostringstream os;
os << "%%" << i;
ast c = make_var(os.str(),uv.get(i));
ast v = cook(m().mk_var(i,uv.get(i)));
subst_memo[v] = c;
bvs.push_back(c);
}
}
e = subst(subst_memo,e);
for (unsigned i = 0; i < bvs.size(); i++)
e = apply_quant(Forall,bvs[i],e);
return e;
}

6
src/interp/iz3mgr.h
View file

@ -661,6 +661,12 @@ class iz3mgr {
ast apply_quant(opr quantifier, ast var, ast e); ast apply_quant(opr quantifier, ast var, ast e);
// Universally quantify all the free variables in a formula.
// Makes up names for the quntifiers.
ast close_universally (ast e);
unsigned num_free_variables(const ast &e);
/** For debugging */ /** For debugging */
void show(ast); void show(ast);

4
src/interp/iz3proof_itp.cpp
View file

@ -2968,9 +2968,9 @@ class iz3proof_itp_impl : public iz3proof_itp {
ast interpolate(const node &pf){ ast interpolate(const node &pf){
// proof of false must be a formula, with quantified symbols // proof of false must be a formula, with quantified symbols
#ifndef BOGUS_QUANTS #ifndef BOGUS_QUANTS
return add_quants(z3_simplify(pf)); return close_universally(add_quants(z3_simplify(pf)));
#else #else
return z3_simplify(pf); return close_universally(z3_simplify(pf));
#endif #endif
} }

5
src/interp/iz3translate.cpp
View file

@ -234,6 +234,11 @@ public:
} }
} }
// if(!range_is_empty(rng)){
// if (num_free_variables(con) > 0)
// rng = range_empty();
// }
if(res == INT_MAX){ if(res == INT_MAX){
if(range_is_empty(rng)) if(range_is_empty(rng))
res = -1; res = -1;

17
src/muz/ddnf/ddnf.cpp
View file

@ -192,10 +192,15 @@ namespace datalog {
for (unsigned i = 0; i < new_tbvs.size(); ++i) { for (unsigned i = 0; i < new_tbvs.size(); ++i) {
tbv const& nt = *new_tbvs[i]; tbv const& nt = *new_tbvs[i];
IF_VERBOSE(10, m_tbv.display(verbose_stream() << "insert: ", nt); verbose_stream() << "\n";); IF_VERBOSE(10, m_tbv.display(verbose_stream() << "insert: ", nt); verbose_stream() << "\n";);
if (contains(nt)) continue; ddnf_node* n;
ddnf_node* n = alloc(ddnf_node, *this, m_tbv, nt, m_noderefs.size()); if (contains(nt)) {
n = find(nt);
}
else {
n = alloc(ddnf_node, *this, m_tbv, nt, m_noderefs.size());
m_noderefs.push_back(n); m_noderefs.push_back(n);
m_nodes.insert(n); m_nodes.insert(n);
}
insert(*m_root, n, new_tbvs); insert(*m_root, n, new_tbvs);
} }
return find(t); return find(t);
@ -275,13 +280,17 @@ namespace datalog {
void insert(ddnf_node& root, ddnf_node* new_n, ptr_vector<tbv const>& new_intersections) { void insert(ddnf_node& root, ddnf_node* new_n, ptr_vector<tbv const>& new_intersections) {
tbv const& new_tbv = new_n->get_tbv(); tbv const& new_tbv = new_n->get_tbv();
IF_VERBOSE(10, m_tbv.display(verbose_stream() << "root: ", root.get_tbv());
m_tbv.display(verbose_stream() << " new node ", new_tbv); verbose_stream() << "\n";);
SASSERT(m_tbv.contains(root.get_tbv(), new_tbv)); SASSERT(m_tbv.contains(root.get_tbv(), new_tbv));
if (&root == new_n) return; if (m_eq(&root, new_n)) return;
++m_stats.m_num_inserts; ++m_stats.m_num_inserts;
bool inserted = false; bool inserted = false;
for (unsigned i = 0; i < root.num_children(); ++i) { for (unsigned i = 0; i < root.num_children(); ++i) {
ddnf_node& child = *(root[i]); ddnf_node& child = *(root[i]);
++m_stats.m_num_comparisons; ++m_stats.m_num_comparisons;
IF_VERBOSE(10, m_tbv.display(verbose_stream() << "child ", child.get_tbv());
verbose_stream() << " contains: " << m_tbv.contains(child.get_tbv(), new_tbv) << "\n";);
if (m_tbv.contains(child.get_tbv(), new_tbv)) { if (m_tbv.contains(child.get_tbv(), new_tbv)) {
inserted = true; inserted = true;
insert(child, new_n, new_intersections); insert(child, new_n, new_intersections);
@ -299,11 +308,13 @@ namespace datalog {
// checking for subset // checking for subset
if (m_tbv.contains(new_tbv, child.get_tbv())) { if (m_tbv.contains(new_tbv, child.get_tbv())) {
subset_children.push_back(&child); subset_children.push_back(&child);
IF_VERBOSE(10, m_tbv.display(verbose_stream() << "contains child", child.get_tbv()); verbose_stream() << "\n";);
++m_stats.m_num_comparisons; ++m_stats.m_num_comparisons;
} }
else if (m_tbv.intersect(child.get_tbv(), new_tbv, *intr)) { else if (m_tbv.intersect(child.get_tbv(), new_tbv, *intr)) {
// this means there is a non-full intersection // this means there is a non-full intersection
new_intersections.push_back(intr); new_intersections.push_back(intr);
IF_VERBOSE(10, m_tbv.display(verbose_stream() << "intersect child ", child.get_tbv()); verbose_stream() << "\n";);
intr = m_tbv.allocate(); intr = m_tbv.allocate();
m_stats.m_num_comparisons += 2; m_stats.m_num_comparisons += 2;
} }

4
src/muz/rel/karr_relation.cpp
View file

@ -111,8 +111,8 @@ namespace datalog {
void filter_interpreted(app* cond) { void filter_interpreted(app* cond) {
rational one(1), mone(-1); rational one(1), mone(-1);
expr* e1, *e2, *en; expr* e1 = 0, *e2 = 0, *en = 0;
var* v, *w; var* v = 0, *w = 0;
rational n1, n2; rational n1, n2;
expr_ref_vector conjs(m); expr_ref_vector conjs(m);
flatten_and(cond, conjs); flatten_and(cond, conjs);

2
src/parsers/smt2/smt2scanner.cpp
View file

@ -124,7 +124,7 @@ namespace smt2 {
next(); next();
bool is_float = false; bool is_float = false;
while (true) { while (!m_at_eof) {
char c = curr(); char c = curr();
if ('0' <= c && c <= '9') { if ('0' <= c && c <= '9') {
m_number = rational(10)*m_number + rational(c - '0'); m_number = rational(10)*m_number + rational(c - '0');

7
src/smt/asserted_formulas.cpp
View file

@ -170,7 +170,7 @@ void asserted_formulas::get_assertions(ptr_vector<expr> & result) const {
void asserted_formulas::push_scope() { void asserted_formulas::push_scope() {
SASSERT(inconsistent() || m_qhead == m_formulas.size() || m.canceled()); SASSERT(inconsistent() || m_qhead == m_formulas.size() || m.canceled());
TRACE("asserted_formulas_scopes", tout << "push:\n"; display(tout);); TRACE("asserted_formulas_scopes", tout << "before push: " << m_scopes.size() << "\n";);
m_scoped_substitution.push(); m_scoped_substitution.push();
m_scopes.push_back(scope()); m_scopes.push_back(scope());
scope & s = m_scopes.back(); scope & s = m_scopes.back();
@ -181,10 +181,11 @@ void asserted_formulas::push_scope() {
m_bv_sharing.push_scope(); m_bv_sharing.push_scope();
m_macro_manager.push_scope(); m_macro_manager.push_scope();
commit(); commit();
TRACE("asserted_formulas_scopes", tout << "after push: " << m_scopes.size() << "\n";);
} }
void asserted_formulas::pop_scope(unsigned num_scopes) { void asserted_formulas::pop_scope(unsigned num_scopes) {
TRACE("asserted_formulas_scopes", tout << "before pop " << num_scopes << "\n"; display(tout);); TRACE("asserted_formulas_scopes", tout << "before pop " << num_scopes << " of " << m_scopes.size() << "\n";);
m_bv_sharing.pop_scope(num_scopes); m_bv_sharing.pop_scope(num_scopes);
m_macro_manager.pop_scope(num_scopes); m_macro_manager.pop_scope(num_scopes);
unsigned new_lvl = m_scopes.size() - num_scopes; unsigned new_lvl = m_scopes.size() - num_scopes;
@ -196,7 +197,7 @@ void asserted_formulas::pop_scope(unsigned num_scopes) {
m_qhead = s.m_formulas_lim; m_qhead = s.m_formulas_lim;
m_scopes.shrink(new_lvl); m_scopes.shrink(new_lvl);
flush_cache(); flush_cache();
TRACE("asserted_formulas_scopes", tout << "after pop " << num_scopes << "\n"; display(tout);); TRACE("asserted_formulas_scopes", tout << "after pop " << num_scopes << "\n";);
} }
void asserted_formulas::reset() { void asserted_formulas::reset() {

11
src/smt/smt_context.cpp
View file

@ -487,6 +487,7 @@ namespace smt {
*/ */
void context::add_eq(enode * n1, enode * n2, eq_justification js) { void context::add_eq(enode * n1, enode * n2, eq_justification js) {
unsigned old_trail_size = m_trail_stack.size(); unsigned old_trail_size = m_trail_stack.size();
scoped_suspend_rlimit _suspend_cancel(m_manager.limit());
try { try {
TRACE("add_eq", tout << "assigning: #" << n1->get_owner_id() << " = #" << n2->get_owner_id() << "\n";); TRACE("add_eq", tout << "assigning: #" << n1->get_owner_id() << " = #" << n2->get_owner_id() << "\n";);
@ -541,10 +542,14 @@ namespace smt {
mark_as_relevant(r1); mark_as_relevant(r1);
} }
TRACE("add_eq", tout << "to trail\n";);
push_trail(add_eq_trail(r1, n1, r2->get_num_parents())); push_trail(add_eq_trail(r1, n1, r2->get_num_parents()));
TRACE("add_eq", tout << "qmanager add_eq\n";);
m_qmanager->add_eq_eh(r1, r2); m_qmanager->add_eq_eh(r1, r2);
TRACE("add_eq", tout << "merge theory_vars\n";);
merge_theory_vars(n2, n1, js); merge_theory_vars(n2, n1, js);
// 'Proof' tree // 'Proof' tree
@ -577,6 +582,7 @@ namespace smt {
#endif #endif
TRACE("add_eq", tout << "remove_parents_from_cg_table\n";);
remove_parents_from_cg_table(r1); remove_parents_from_cg_table(r1);
enode * curr = r1; enode * curr = r1;
@ -588,8 +594,10 @@ namespace smt {
SASSERT(r1->get_root() == r2); SASSERT(r1->get_root() == r2);
TRACE("add_eq", tout << "reinsert_parents_into_cg_table\n";);
reinsert_parents_into_cg_table(r1, r2, n1, n2, js); reinsert_parents_into_cg_table(r1, r2, n1, n2, js);
TRACE("add_eq", tout << "propagate_bool_enode_assignment\n";);
if (n2->is_bool()) if (n2->is_bool())
propagate_bool_enode_assignment(r1, r2, n1, n2); propagate_bool_enode_assignment(r1, r2, n1, n2);
@ -604,6 +612,7 @@ namespace smt {
catch (...) { catch (...) {
// Restore trail size since procedure was interrupted in the middle. // Restore trail size since procedure was interrupted in the middle.
// If the add_eq_trail remains on the trail stack, then Z3 may crash when the destructor is invoked. // If the add_eq_trail remains on the trail stack, then Z3 may crash when the destructor is invoked.
TRACE("add_eq", tout << "add_eq interrupted. This is unsafe " << m_manager.limit().get_cancel_flag() << "\n";);
m_trail_stack.shrink(old_trail_size); m_trail_stack.shrink(old_trail_size);
throw; throw;
} }
@ -972,7 +981,7 @@ namespace smt {
enode * parent = *it; enode * parent = *it;
if (parent->is_cgc_enabled()) { if (parent->is_cgc_enabled()) {
TRACE("add_eq_parents", tout << "removing: #" << parent->get_owner_id() << "\n";); TRACE("add_eq_parents", tout << "removing: #" << parent->get_owner_id() << "\n";);
CTRACE("add_eq", !parent->is_cgr(), CTRACE("add_eq", !parent->is_cgr() || !m_cg_table.contains_ptr(parent),
tout << "old num_parents: " << r2_num_parents << ", num_parents: " << r2->m_parents.size() << ", parent: #" << tout << "old num_parents: " << r2_num_parents << ", num_parents: " << r2->m_parents.size() << ", parent: #" <<
parent->get_owner_id() << ", parents: \n"; parent->get_owner_id() << ", parents: \n";
for (unsigned i = 0; i < r2->m_parents.size(); i++) { for (unsigned i = 0; i < r2->m_parents.size(); i++) {

2
src/smt/smt_implied_equalities.cpp
View file

@ -284,7 +284,7 @@ namespace smt {
} }
lbool reduce_cond(model_ref& model, expr* e) { lbool reduce_cond(model_ref& model, expr* e) {
expr* e1, *e2; expr* e1 = 0, *e2 = 0;
if (m.is_eq(e, e1, e2) && m_array_util.is_as_array(e1) && m_array_util.is_as_array(e2)) { if (m.is_eq(e, e1, e2) && m_array_util.is_as_array(e1) && m_array_util.is_as_array(e2)) {
if (e1 == e2) { if (e1 == e2) {
return l_true; return l_true;

18
src/smt/smt_model_generator.cpp
View file

@ -54,7 +54,7 @@ namespace smt {
ptr_vector<theory>::const_iterator it = m_context->begin_theories(); ptr_vector<theory>::const_iterator it = m_context->begin_theories();
ptr_vector<theory>::const_iterator end = m_context->end_theories(); ptr_vector<theory>::const_iterator end = m_context->end_theories();
for (; it != end; ++it) { for (; it != end; ++it) {
TRACE("model_generator_bug", tout << "init_model for theory: " << (*it)->get_name() << "\n";); TRACE("model", tout << "init_model for theory: " << (*it)->get_name() << "\n";);
(*it)->init_model(*this); (*it)->init_model(*this);
} }
} }
@ -91,7 +91,7 @@ namespace smt {
sort * s = m_manager.get_sort(r->get_owner()); sort * s = m_manager.get_sort(r->get_owner());
model_value_proc * proc = 0; model_value_proc * proc = 0;
if (m_manager.is_bool(s)) { if (m_manager.is_bool(s)) {
CTRACE("func_interp_bug", m_context->get_assignment(r) == l_undef, CTRACE("model", m_context->get_assignment(r) == l_undef,
tout << mk_pp(r->get_owner(), m_manager) << "\n";); tout << mk_pp(r->get_owner(), m_manager) << "\n";);
SASSERT(m_context->get_assignment(r) != l_undef); SASSERT(m_context->get_assignment(r) != l_undef);
if (m_context->get_assignment(r) == l_true) if (m_context->get_assignment(r) == l_true)
@ -108,7 +108,7 @@ namespace smt {
SASSERT(proc); SASSERT(proc);
} }
else { else {
TRACE("model_bug", tout << "creating fresh value for #" << r->get_owner_id() << "\n";); TRACE("model", tout << "creating fresh value for #" << r->get_owner_id() << "\n";);
proc = alloc(fresh_value_proc, mk_extra_fresh_value(m_manager.get_sort(r->get_owner()))); proc = alloc(fresh_value_proc, mk_extra_fresh_value(m_manager.get_sort(r->get_owner())));
} }
} }
@ -130,7 +130,7 @@ namespace smt {
if (!m_manager.is_model_value(n)) { if (!m_manager.is_model_value(n)) {
sort * s = m_manager.get_sort(r->get_owner()); sort * s = m_manager.get_sort(r->get_owner());
n = m_model->get_fresh_value(s); n = m_model->get_fresh_value(s);
CTRACE("model_generator_bug", n == 0, CTRACE("model", n == 0,
tout << mk_pp(r->get_owner(), m_manager) << "\nsort:\n" << mk_pp(s, m_manager) << "\n"; tout << mk_pp(r->get_owner(), m_manager) << "\nsort:\n" << mk_pp(s, m_manager) << "\n";
tout << "is_finite: " << m_model->is_finite(s) << "\n";); tout << "is_finite: " << m_model->is_finite(s) << "\n";);
} }
@ -407,9 +407,11 @@ namespace smt {
*/ */
bool model_generator::include_func_interp(func_decl * f) const { bool model_generator::include_func_interp(func_decl * f) const {
family_id fid = f->get_family_id(); family_id fid = f->get_family_id();
TRACE("model", tout << f->get_name() << " " << fid << "\n";);
if (fid == null_family_id) return !m_hidden_ufs.contains(f); if (fid == null_family_id) return !m_hidden_ufs.contains(f);
if (fid == m_manager.get_basic_family_id()) return false; if (fid == m_manager.get_basic_family_id()) return false;
theory * th = m_context->get_theory(fid); theory * th = m_context->get_theory(fid);
TRACE("model", tout << th << "\n";);
if (!th) return true; if (!th) return true;
return th->include_func_interp(f); return th->include_func_interp(f);
} }
@ -444,7 +446,7 @@ namespace smt {
SASSERT(m_model->has_interpretation(f)); SASSERT(m_model->has_interpretation(f));
SASSERT(m_model->get_func_interp(f) == fi); SASSERT(m_model->get_func_interp(f) == fi);
// The entry must be new because n->get_cg() == n // The entry must be new because n->get_cg() == n
TRACE("func_interp_bug", TRACE("model",
tout << "insert new entry for:\n" << mk_ismt2_pp(n->get_owner(), m_manager) << "\nargs: "; tout << "insert new entry for:\n" << mk_ismt2_pp(n->get_owner(), m_manager) << "\nargs: ";
for (unsigned i = 0; i < num_args; i++) { for (unsigned i = 0; i < num_args; i++) {
tout << "#" << n->get_arg(i)->get_owner_id() << " "; tout << "#" << n->get_arg(i)->get_owner_id() << " ";
@ -508,20 +510,20 @@ namespace smt {
void model_generator::register_macros() { void model_generator::register_macros() {
unsigned num = m_context->get_num_macros(); unsigned num = m_context->get_num_macros();
TRACE("register_macros", tout << "num. macros: " << num << "\n";); TRACE("model", tout << "num. macros: " << num << "\n";);
expr_ref v(m_manager); expr_ref v(m_manager);
for (unsigned i = 0; i < num; i++) { for (unsigned i = 0; i < num; i++) {
func_decl * f = m_context->get_macro_interpretation(i, v); func_decl * f = m_context->get_macro_interpretation(i, v);
func_interp * fi = alloc(func_interp, m_manager, f->get_arity()); func_interp * fi = alloc(func_interp, m_manager, f->get_arity());
fi->set_else(v); fi->set_else(v);
TRACE("register_macros", tout << f->get_name() << "\n" << mk_pp(v, m_manager) << "\n";); TRACE("model", tout << f->get_name() << "\n" << mk_pp(v, m_manager) << "\n";);
m_model->register_decl(f, fi); m_model->register_decl(f, fi);
} }
} }
proto_model * model_generator::mk_model() { proto_model * model_generator::mk_model() {
SASSERT(!m_model); SASSERT(!m_model);
TRACE("func_interp_bug", m_context->display(tout);); TRACE("model", m_context->display(tout););
init_model(); init_model();
register_existing_model_values(); register_existing_model_values();
mk_bool_model(); mk_bool_model();

1
src/smt/smt_setup.cpp
View file

@ -216,6 +216,7 @@ namespace smt {
void setup::setup_QF_DT() { void setup::setup_QF_DT() {
setup_QF_UF(); setup_QF_UF();
setup_datatypes();
} }
void setup::setup_QF_BVRE() { void setup::setup_QF_BVRE() {

2
src/smt/theory_arith_nl.h
View file

@ -780,7 +780,7 @@ namespace smt {
of a non linear monomial that is not satisfied by the current assignment. of a non linear monomial that is not satisfied by the current assignment.
if v >= l, then create the case split v >= l+1 if v >= l, then create the case split v >= l+1
else v <= u, then create the case split v <= u-1 else v <= u, then create the case split v <= u-1
else do nothing and return false. else create the bound v = 0 and case split on it.
*/ */
template<typename Ext> template<typename Ext>
bool theory_arith<Ext>::branch_nl_int_var(theory_var v) { bool theory_arith<Ext>::branch_nl_int_var(theory_var v) {

6
src/smt/theory_lra.cpp
View file

@ -689,7 +689,7 @@ namespace smt {
SASSERT(!ctx().b_internalized(atom)); SASSERT(!ctx().b_internalized(atom));
bool_var bv = ctx().mk_bool_var(atom); bool_var bv = ctx().mk_bool_var(atom);
ctx().set_var_theory(bv, get_id()); ctx().set_var_theory(bv, get_id());
expr* n1, *n2; expr* n1 = 0, *n2 = 0;
rational r; rational r;
lra_lp::bound_kind k; lra_lp::bound_kind k;
theory_var v = null_theory_var; theory_var v = null_theory_var;
@ -721,7 +721,7 @@ namespace smt {
SASSERT(!ctx().b_internalized(atom)); SASSERT(!ctx().b_internalized(atom));
bool_var bv = ctx().mk_bool_var(atom); bool_var bv = ctx().mk_bool_var(atom);
ctx().set_var_theory(bv, get_id()); ctx().set_var_theory(bv, get_id());
expr* n1, *n2; expr* n1 = 0, *n2 = 0;
rational r; rational r;
lra_lp::bound_kind k; lra_lp::bound_kind k;
theory_var v = null_theory_var; theory_var v = null_theory_var;
@ -862,7 +862,7 @@ namespace smt {
void relevant_eh(app* n) { void relevant_eh(app* n) {
TRACE("arith", tout << mk_pp(n, m) << "\n";); TRACE("arith", tout << mk_pp(n, m) << "\n";);
expr* n1, *n2; expr* n1 = 0, *n2 = 0;
if (a.is_mod(n, n1, n2)) if (a.is_mod(n, n1, n2))
mk_idiv_mod_axioms(n1, n2); mk_idiv_mod_axioms(n1, n2);
else if (a.is_rem(n, n1, n2)) else if (a.is_rem(n, n1, n2))

307
src/tactic/bv/bv_bounds_tactic.cpp
View file

@ -18,6 +18,7 @@ Author:
#include "tactic/bv/bv_bounds_tactic.h" #include "tactic/bv/bv_bounds_tactic.h"
#include "tactic/core/ctx_simplify_tactic.h" #include "tactic/core/ctx_simplify_tactic.h"
#include "tactic/core/dom_simplify_tactic.h"
#include "ast/bv_decl_plugin.h" #include "ast/bv_decl_plugin.h"
#include "ast/ast_pp.h" #include "ast/ast_pp.h"
#include <climits> #include <climits>
@ -29,7 +30,7 @@ static uint64 uMaxInt(unsigned sz) {
namespace { namespace {
struct interval { struct interval {
// l < h: [l, h] // l < h: [l, h]
// l > h: [0, h] U [l, UMAX_INT] // l > h: [0, h] U [l, UMAX_INT]
uint64 l, h; uint64 l, h;
@ -70,11 +71,13 @@ struct interval {
if (is_wrapped()) { if (is_wrapped()) {
// l >= b.l >= b.h >= h // l >= b.l >= b.h >= h
return b.is_wrapped() && h <= b.h && l >= b.l; return b.is_wrapped() && h <= b.h && l >= b.l;
} else if (b.is_wrapped()) { }
else if (b.is_wrapped()) {
// b.l > b.h >= h >= l // b.l > b.h >= h >= l
// h >= l >= b.l > b.h // h >= l >= b.l > b.h
return h <= b.h || l >= b.l; return h <= b.h || l >= b.l;
} else { }
else {
// //
return l >= b.l && h <= b.h; return l >= b.l && h <= b.h;
} }
@ -103,7 +106,8 @@ struct interval {
} else { } else {
return b.intersect(*this, result); return b.intersect(*this, result);
} }
} else if (b.is_wrapped()) { }
else if (b.is_wrapped()) {
// ... b.h ... l ... h ... b.l .. // ... b.h ... l ... h ... b.l ..
if (h < b.l && l > b.h) { if (h < b.l && l > b.h) {
return false; return false;
@ -146,24 +150,24 @@ struct interval {
} }
return true; return true;
} }
}; };
#ifdef _TRACE #ifdef _TRACE
std::ostream& operator<<(std::ostream& o, const interval& I) { std::ostream& operator<<(std::ostream& o, const interval& I) {
o << "[" << I.l << ", " << I.h << "]"; o << "[" << I.l << ", " << I.h << "]";
return o; return o;
} }
#endif #endif
struct undo_bound { struct undo_bound {
expr* e; expr* e;
interval b; interval b;
bool fresh; bool fresh;
undo_bound(expr* e, const interval& b, bool fresh) : e(e), b(b), fresh(fresh) {} undo_bound(expr* e, const interval& b, bool fresh) : e(e), b(b), fresh(fresh) {}
}; };
class bv_bounds_simplifier : public ctx_simplify_tactic::simplifier { class bv_bounds_simplifier : public ctx_simplify_tactic::simplifier {
typedef obj_map<expr, interval> map; typedef obj_map<expr, interval> map;
typedef obj_map<expr, bool> expr_set; typedef obj_map<expr, bool> expr_set;
typedef obj_map<expr, unsigned> expr_cnt; typedef obj_map<expr, unsigned> expr_cnt;
@ -188,7 +192,7 @@ class bv_bounds_simplifier : public ctx_simplify_tactic::simplifier {
bool is_bound(expr *e, expr*& v, interval& b) const { bool is_bound(expr *e, expr*& v, interval& b) const {
uint64 n; uint64 n;
expr *lhs, *rhs; expr *lhs = 0, *rhs = 0;
unsigned sz; unsigned sz;
if (m_bv.is_bv_ule(e, lhs, rhs)) { if (m_bv.is_bv_ule(e, lhs, rhs)) {
@ -204,7 +208,8 @@ class bv_bounds_simplifier : public ctx_simplify_tactic::simplifier {
v = lhs; v = lhs;
return true; return true;
} }
} else if (m_bv.is_bv_sle(e, lhs, rhs)) { }
else if (m_bv.is_bv_sle(e, lhs, rhs)) {
if (is_number(lhs, n, sz)) { // C sle x <=> x sge C if (is_number(lhs, n, sz)) { // C sle x <=> x sge C
if (m_bv.is_numeral(rhs)) if (m_bv.is_numeral(rhs))
return false; return false;
@ -293,7 +298,7 @@ class bv_bounds_simplifier : public ctx_simplify_tactic::simplifier {
} }
#endif #endif
public: public:
bv_bounds_simplifier(ast_manager& m, params_ref const& p) : m(m), m_params(p), m_bv(m) { bv_bounds_simplifier(ast_manager& m, params_ref const& p) : m(m), m_params(p), m_bv(m) {
updt_params(p); updt_params(p);
} }
@ -526,10 +531,284 @@ public:
virtual unsigned scope_level() const { virtual unsigned scope_level() const {
return m_scopes.size(); return m_scopes.size();
} }
}; };
class dom_bv_bounds_simplifier : public dom_simplifier {
typedef obj_map<expr, interval> map;
typedef obj_map<expr, bool> expr_set;
typedef obj_map<expr, unsigned> expr_cnt;
ast_manager& m;
params_ref m_params;
bool m_propagate_eq;
bv_util m_bv;
vector<undo_bound> m_scopes;
map m_bound;
svector<expr_set*> m_expr_vars;
svector<expr_cnt*> m_bound_exprs;
bool is_number(expr *e, uint64& n, unsigned& sz) const {
rational r;
if (m_bv.is_numeral(e, r, sz) && sz <= 64) {
n = r.get_uint64();
return true;
}
return false;
}
bool is_bound(expr *e, expr*& v, interval& b) const {
uint64 n;
expr *lhs = 0, *rhs = 0;
unsigned sz = 0;
if (m_bv.is_bv_ule(e, lhs, rhs)) {
if (is_number(lhs, n, sz)) { // C ule x <=> x uge C
if (m_bv.is_numeral(rhs))
return false;
b = interval(n, uMaxInt(sz), sz, true);
v = rhs;
return true;
}
if (is_number(rhs, n, sz)) { // x ule C
b = interval(0, n, sz, true);
v = lhs;
return true;
}
}
else if (m_bv.is_bv_sle(e, lhs, rhs)) {
if (is_number(lhs, n, sz)) { // C sle x <=> x sge C
if (m_bv.is_numeral(rhs))
return false;
b = interval(n, (1ull << (sz-1)) - 1, sz, true);
v = rhs;
return true;
}
if (is_number(rhs, n, sz)) { // x sle C
b = interval(1ull << (sz-1), n, sz, true);
v = lhs;
return true;
}
} else if (m.is_eq(e, lhs, rhs)) {
if (is_number(lhs, n, sz)) {
if (m_bv.is_numeral(rhs))
return false;
b = interval(n, n, sz, true);
v = rhs;
return true;
}
if (is_number(rhs, n, sz)) {
b = interval(n, n, sz, true);
v = lhs;
return true;
}
}
return false;
}
public:
dom_bv_bounds_simplifier(ast_manager& m, params_ref const& p) : m(m), m_params(p), m_bv(m) {
updt_params(p);
}
virtual void updt_params(params_ref const & p) {
m_propagate_eq = p.get_bool("propagate_eq", false);
}
static void get_param_descrs(param_descrs& r) {
r.insert("propagate-eq", CPK_BOOL, "(default: false) propagate equalities from inequalities");
}
virtual ~dom_bv_bounds_simplifier() {
for (unsigned i = 0, e = m_expr_vars.size(); i < e; ++i) {
dealloc(m_expr_vars[i]);
}
for (unsigned i = 0, e = m_bound_exprs.size(); i < e; ++i) {
dealloc(m_bound_exprs[i]);
}
}
virtual bool assert_expr(expr * t, bool sign) {
while (m.is_not(t, t)) {
sign = !sign;
}
interval b;
expr* t1;
if (is_bound(t, t1, b)) {
SASSERT(!m_bv.is_numeral(t1));
if (sign)
VERIFY(b.negate(b));
TRACE("bv", tout << (sign?"(not ":"") << mk_pp(t, m) << (sign ? ")" : "") << ": " << mk_pp(t1, m) << " in " << b << "\n";);
map::obj_map_entry* e = m_bound.find_core(t1);
if (e) {
interval& old = e->get_data().m_value;
interval intr;
if (!old.intersect(b, intr))
return false;
if (old == intr)
return true;
m_scopes.insert(undo_bound(t1, old, false));
old = intr;
} else {
m_bound.insert(t1, b);
m_scopes.insert(undo_bound(t1, interval(), true));
}
}
return true;
}
virtual void operator()(expr_ref& r) {
expr* t1, * t = r;
interval b;
if (m_bound.find(t, b) && b.is_singleton()) {
r = m_bv.mk_numeral(b.l, m_bv.get_bv_size(t));
return;
}
if (!m.is_bool(t))
return;
bool sign = false;
while (m.is_not(t, t)) {
sign = !sign;
}
if (!is_bound(t, t1, b))
return;
if (sign && b.tight) {
sign = false;
if (!b.negate(b)) {
r = m.mk_false();
return;
}
}
interval ctx, intr;
bool was_updated = true;
if (b.is_full() && b.tight) {
r = m.mk_true();
} else if (m_bound.find(t1, ctx)) {
if (ctx.implies(b)) {
r = m.mk_true();
}
else if (!b.intersect(ctx, intr)) {
r = m.mk_false();
}
else if (m_propagate_eq && intr.is_singleton()) {
r = m.mk_eq(t1, m_bv.mk_numeral(rational(intr.l, rational::ui64()),
m.get_sort(t1)));
}
}
else {
was_updated = false;
}
CTRACE("bv", was_updated, tout << mk_pp(t, m) << " " << b << " (ctx: " << ctx << ") (intr: " << intr << "): " << r << "\n";);
if (sign && was_updated)
r = m.mk_not(r);
}
// check if t contains v
ptr_vector<expr> todo;
bool contains(expr* t, expr* v) {
ast_fast_mark1 mark;
todo.push_back(t);
while (!todo.empty()) {
t = todo.back();
todo.pop_back();
if (mark.is_marked(t)) {
continue;
}
if (t == v) {
todo.reset();
return true;
}
mark.mark(t);
if (!is_app(t)) {
continue;
}
app* a = to_app(t);
todo.append(a->get_num_args(), a->get_args());
}
return false;
}
bool contains_bound(expr* t) {
ast_fast_mark1 mark1;
ast_fast_mark2 mark2;
todo.push_back(t);
while (!todo.empty()) {
t = todo.back();
todo.pop_back();
if (mark1.is_marked(t)) {
continue;
}
mark1.mark(t);
if (!is_app(t)) {
continue;
}
interval b;
expr* e;
if (is_bound(t, e, b)) {
if (mark2.is_marked(e)) {
todo.reset();
return true;
}
mark2.mark(e);
if (m_bound.contains(e)) {
todo.reset();
return true;
}
}
app* a = to_app(t);
todo.append(a->get_num_args(), a->get_args());
}
return false;
}
virtual void pop(unsigned num_scopes) {
TRACE("bv", tout << "pop: " << num_scopes << "\n";);
if (m_scopes.empty())
return;
unsigned target = m_scopes.size() - num_scopes;
if (target == 0) {
m_bound.reset();
m_scopes.reset();
return;
}
for (unsigned i = m_scopes.size()-1; i >= target; --i) {
undo_bound& undo = m_scopes[i];
SASSERT(m_bound.contains(undo.e));
if (undo.fresh) {
m_bound.erase(undo.e);
} else {
m_bound.insert(undo.e, undo.b);
}
}
m_scopes.shrink(target);
}
virtual dom_simplifier * translate(ast_manager & m) {
return alloc(dom_bv_bounds_simplifier, m, m_params);
}
};
} }
tactic * mk_bv_bounds_tactic(ast_manager & m, params_ref const & p) { tactic * mk_bv_bounds_tactic(ast_manager & m, params_ref const & p) {
return clean(alloc(ctx_simplify_tactic, m, alloc(bv_bounds_simplifier, m, p), p)); return clean(alloc(ctx_simplify_tactic, m, alloc(bv_bounds_simplifier, m, p), p));
} }
tactic * mk_dom_bv_bounds_tactic(ast_manager & m, params_ref const & p) {
return clean(alloc(dom_simplify_tactic, m, alloc(dom_bv_bounds_simplifier, m, p), p));
}

2
src/tactic/core/CMakeLists.txt
View file

@ -7,6 +7,7 @@ z3_add_component(core_tactics
ctx_simplify_tactic.cpp ctx_simplify_tactic.cpp
der_tactic.cpp der_tactic.cpp
distribute_forall_tactic.cpp distribute_forall_tactic.cpp
dom_simplify_tactic.cpp
elim_term_ite_tactic.cpp elim_term_ite_tactic.cpp
elim_uncnstr_tactic.cpp elim_uncnstr_tactic.cpp
injectivity_tactic.cpp injectivity_tactic.cpp
@ -32,6 +33,7 @@ z3_add_component(core_tactics
ctx_simplify_tactic.h ctx_simplify_tactic.h
der_tactic.h der_tactic.h
distribute_forall_tactic.h distribute_forall_tactic.h
dom_simplify_tactic.h
elim_term_ite_tactic.h elim_term_ite_tactic.h
elim_uncnstr_tactic.h elim_uncnstr_tactic.h
injectivity_tactic.h injectivity_tactic.h

218
src/tactic/core/dom_simplify_tactic.cpp
View file

@ -83,30 +83,45 @@ expr* expr_dominators::intersect(expr* x, expr * y) {
return x; return x;
} }
void expr_dominators::compute_dominators() { bool expr_dominators::compute_dominators() {
expr * e = m_root; expr * e = m_root;
SASSERT(m_doms.empty()); SASSERT(m_doms.empty());
m_doms.insert(e, e); m_doms.insert(e, e);
bool change = true; bool change = true;
unsigned iterations = 1;
while (change) { while (change) {
change = false; change = false;
SASSERT(m_post2expr.back() == e); TRACE("simplify",
for (unsigned i = 0; i < m_post2expr.size() - 1; ++i) { for (auto & kv : m_doms) {
tout << expr_ref(kv.m_key, m) << " |-> " << expr_ref(kv.m_value, m) << "\n";
});
SASSERT(m_post2expr.empty() || m_post2expr.back() == e);
for (unsigned i = 0; i + 1 < m_post2expr.size(); ++i) {
expr * child = m_post2expr[i]; expr * child = m_post2expr[i];
ptr_vector<expr> const& p = m_parents[child]; ptr_vector<expr> const& p = m_parents[child];
SASSERT(!p.empty()); expr * new_idom = 0, *idom2 = 0;
expr * new_idom = p[0], * idom2 = 0;
for (unsigned j = 1; j < p.size(); ++j) { for (expr * pred : p) {
if (m_doms.find(p[j], idom2)) { if (m_doms.contains(pred)) {
new_idom = intersect(new_idom, idom2); new_idom = !new_idom ? pred : intersect(new_idom, pred);
} }
} }
if (!m_doms.find(child, idom2) || idom2 != new_idom) { if (!new_idom) {
m_doms.insert(child, p[0]);
change = true;
}
else if (!m_doms.find(child, idom2) || idom2 != new_idom) {
m_doms.insert(child, new_idom); m_doms.insert(child, new_idom);
change = true; change = true;
} }
} }
iterations *= 2;
if (change && iterations > m_post2expr.size()) {
return false;
} }
}
return true;
} }
void expr_dominators::extract_tree() { void expr_dominators::extract_tree() {
@ -115,17 +130,19 @@ void expr_dominators::extract_tree() {
} }
} }
void expr_dominators::compile(expr * e) { bool expr_dominators::compile(expr * e) {
reset(); reset();
m_root = e; m_root = e;
compute_post_order(); compute_post_order();
compute_dominators(); if (!compute_dominators()) return false;
extract_tree(); extract_tree();
TRACE("simplify", display(tout););
return true;
} }
void expr_dominators::compile(unsigned sz, expr * const* es) { bool expr_dominators::compile(unsigned sz, expr * const* es) {
expr_ref e(m.mk_and(sz, es), m); expr_ref e(m.mk_and(sz, es), m);
compile(e); return compile(e);
} }
void expr_dominators::reset() { void expr_dominators::reset() {
@ -137,11 +154,31 @@ void expr_dominators::reset() {
m_root.reset(); m_root.reset();
} }
std::ostream& expr_dominators::display(std::ostream& out) {
return display(out, 0, m_root);
}
std::ostream& expr_dominators::display(std::ostream& out, unsigned indent, expr* r) {
for (unsigned i = 0; i < indent; ++i) out << " ";
out << expr_ref(r, m);
if (m_tree.contains(r)) {
for (expr* child : m_tree[r]) {
if (child != r)
display(out, indent + 1, child);
}
}
out << "\n";
return out;
}
// ----------------------- // -----------------------
// dom_simplify_tactic // dom_simplify_tactic
dom_simplify_tactic::~dom_simplify_tactic() {
dealloc(m_simplifier);
}
tactic * dom_simplify_tactic::translate(ast_manager & m) { tactic * dom_simplify_tactic::translate(ast_manager & m) {
return alloc(dom_simplify_tactic, m, m_simplifier->translate(m), m_params); return alloc(dom_simplify_tactic, m, m_simplifier->translate(m), m_params);
} }
@ -164,31 +201,40 @@ void dom_simplify_tactic::operator()(
void dom_simplify_tactic::cleanup() { void dom_simplify_tactic::cleanup() {
m_trail.reset(); m_trail.reset();
m_args.reset(); m_args.reset();
m_args2.reset();
m_result.reset(); m_result.reset();
m_dominators.reset(); m_dominators.reset();
} }
expr_ref dom_simplify_tactic::simplify_ite(app * ite) { expr_ref dom_simplify_tactic::simplify_ite(app * ite) {
expr_ref r(m); expr_ref r(m);
expr * c = 0, * t = 0, * e = 0; expr * c = 0, *t = 0, *e = 0;
VERIFY(m.is_ite(ite, c, t, e)); VERIFY(m.is_ite(ite, c, t, e));
unsigned old_lvl = scope_level(); unsigned old_lvl = scope_level();
expr_ref new_c = simplify(c); expr_ref new_c = simplify_arg(c);
if (m.is_true(new_c)) { if (m.is_true(new_c)) {
r = simplify(t); r = simplify_arg(t);
} }
else if (m.is_false(new_c) || !assert_expr(new_c, false)) { else if (m.is_false(new_c) || !assert_expr(new_c, false)) {
r = simplify(e); r = simplify_arg(e);
} }
else { else {
expr_ref new_t = simplify(t); for (expr * child : tree(ite)) {
if (is_subexpr(child, t) && !is_subexpr(child, e)) {
simplify_rec(child);
}
}
pop(scope_level() - old_lvl); pop(scope_level() - old_lvl);
expr_ref new_t = simplify_arg(t);
if (!assert_expr(new_c, true)) { if (!assert_expr(new_c, true)) {
return new_t; return new_t;
} }
expr_ref new_e = simplify(e); for (expr * child : tree(ite)) {
if (is_subexpr(child, e) && !is_subexpr(child, t)) {
simplify_rec(child);
}
}
pop(scope_level() - old_lvl); pop(scope_level() - old_lvl);
expr_ref new_e = simplify_arg(e);
if (c == new_c && t == new_t && e == new_e) { if (c == new_c && t == new_t && e == new_e) {
r = ite; r = ite;
} }
@ -197,15 +243,28 @@ expr_ref dom_simplify_tactic::simplify_ite(app * ite) {
} }
else { else {
TRACE("tactic", tout << new_c << "\n" << new_t << "\n" << new_e << "\n";); TRACE("tactic", tout << new_c << "\n" << new_t << "\n" << new_e << "\n";);
r = m.mk_ite(new_c, new_t, new_c); r = m.mk_ite(new_c, new_t, new_e);
} }
} }
return r; return r;
} }
expr_ref dom_simplify_tactic::simplify(expr * e0) { expr_ref dom_simplify_tactic::simplify_arg(expr * e) {
expr_ref r(m);
r = get_cached(e);
(*m_simplifier)(r);
TRACE("simplify", tout << "depth: " << m_depth << " " << mk_pp(e, m) << " -> " << r << "\n";);
return r;
}
/**
\brief simplify e recursively.
*/
expr_ref dom_simplify_tactic::simplify_rec(expr * e0) {
expr_ref r(m); expr_ref r(m);
expr* e = 0; expr* e = 0;
TRACE("simplify", tout << "depth: " << m_depth << " " << mk_pp(e0, m) << "\n";);
if (!m_result.find(e0, e)) { if (!m_result.find(e0, e)) {
e = e0; e = e0;
} }
@ -224,17 +283,13 @@ expr_ref dom_simplify_tactic::simplify(expr * e0) {
r = simplify_or(to_app(e)); r = simplify_or(to_app(e));
} }
else { else {
expr_dominators::tree_t const& t = m_dominators.get_tree(); for (expr * child : tree(e)) {
if (t.contains(e)) { simplify_rec(child);
ptr_vector<expr> const& children = t[e];
for (expr * child : children) {
simplify(child);
}
} }
if (is_app(e)) { if (is_app(e)) {
m_args.reset(); m_args.reset();
for (expr* arg : *to_app(e)) { for (expr* arg : *to_app(e)) {
m_args.push_back(get_cached(arg)); // TBD is cache really applied to all sub-terms? m_args.push_back(simplify_arg(arg));
} }
r = m.mk_app(to_app(e)->get_decl(), m_args.size(), m_args.c_ptr()); r = m.mk_app(to_app(e)->get_decl(), m_args.size(), m_args.c_ptr());
} }
@ -246,45 +301,64 @@ expr_ref dom_simplify_tactic::simplify(expr * e0) {
cache(e0, r); cache(e0, r);
TRACE("simplify", tout << "depth: " << m_depth << " " << mk_pp(e0, m) << " -> " << r << "\n";); TRACE("simplify", tout << "depth: " << m_depth << " " << mk_pp(e0, m) << " -> " << r << "\n";);
--m_depth; --m_depth;
m_subexpr_cache.reset();
return r; return r;
} }
expr_ref dom_simplify_tactic::simplify_and_or(bool is_and, app * e) { expr_ref dom_simplify_tactic::simplify_and_or(bool is_and, app * e) {
expr_ref r(m); expr_ref r(m);
unsigned old_lvl = scope_level(); unsigned old_lvl = scope_level();
m_args.reset();
auto is_subexpr_arg = [&](expr * child, expr * except) {
if (!is_subexpr(child, except))
return false;
for (expr * arg : *e) { for (expr * arg : *e) {
r = simplify(arg); if (arg != except && is_subexpr(child, arg))
if (!assert_expr(r, !is_and)) { return false;
r = is_and ? m.mk_false() : m.mk_true();
} }
m_args.push_back(r); return true;
};
expr_ref_vector args(m);
if (m_forward) {
for (expr * arg : *e) {
#define _SIMP_ARG(arg) \
for (expr * child : tree(arg)) { \
if (is_subexpr_arg(child, arg)) { \
simplify_rec(child); \
} \
} \
r = simplify_arg(arg); \
args.push_back(r); \
if (!assert_expr(r, !is_and)) { \
r = is_and ? m.mk_false() : m.mk_true(); \
return r; \
}
_SIMP_ARG(arg);
}
}
else {
for (unsigned i = e->get_num_args(); i > 0; ) {
--i;
expr* arg = e->get_arg(i);
_SIMP_ARG(arg);
}
args.reverse();
} }
pop(scope_level() - old_lvl); pop(scope_level() - old_lvl);
m_args.reverse(); r = is_and ? mk_and(args) : mk_or(args);
m_args2.reset();
for (expr * arg : m_args) {
r = simplify(arg);
if (!assert_expr(r, !is_and)) {
r = is_and ? m.mk_false() : m.mk_true();
}
m_args2.push_back(r);
}
pop(scope_level() - old_lvl);
m_args2.reverse();
r = is_and ? mk_and(m_args2) : mk_or(m_args2);
return r; return r;
} }
void dom_simplify_tactic::init(goal& g) { bool dom_simplify_tactic::init(goal& g) {
expr_ref_vector args(m); expr_ref_vector args(m);
unsigned sz = g.size(); unsigned sz = g.size();
for (unsigned i = 0; i < sz; ++i) args.push_back(g.form(i)); for (unsigned i = 0; i < sz; ++i) args.push_back(g.form(i));
expr_ref fml = mk_and(args); expr_ref fml = mk_and(args);
m_result.reset(); m_result.reset();
m_trail.reset(); m_trail.reset();
m_dominators.compile(fml); return m_dominators.compile(fml);
} }
void dom_simplify_tactic::simplify_goal(goal& g) { void dom_simplify_tactic::simplify_goal(goal& g) {
@ -296,13 +370,15 @@ void dom_simplify_tactic::simplify_goal(goal& g) {
change = false; change = false;
// go forwards // go forwards
init(g); m_forward = true;
if (!init(g)) return;
unsigned sz = g.size(); unsigned sz = g.size();
for (unsigned i = 0; !g.inconsistent() && i < sz; ++i) { for (unsigned i = 0; !g.inconsistent() && i < sz; ++i) {
expr_ref r = simplify(g.form(i)); expr_ref r = simplify_rec(g.form(i));
if (i < sz - 1 && !m.is_true(r) && !m.is_false(r) && !g.dep(i) && !g.proofs_enabled() && !assert_expr(r, false)) { if (i < sz - 1 && !m.is_true(r) && !m.is_false(r) && !g.dep(i) && !g.proofs_enabled() && !assert_expr(r, false)) {
r = m.mk_false(); r = m.mk_false();
} }
CTRACE("simplify", r != g.form(i), tout << r << " " << mk_pp(g.form(i), m) << "\n";);
change |= r != g.form(i); change |= r != g.form(i);
proof* new_pr = 0; proof* new_pr = 0;
if (g.proofs_enabled()) { if (g.proofs_enabled()) {
@ -313,15 +389,17 @@ void dom_simplify_tactic::simplify_goal(goal& g) {
pop(scope_level()); pop(scope_level());
// go backwards // go backwards
init(g); m_forward = false;
if (!init(g)) return;
sz = g.size(); sz = g.size();
for (unsigned i = sz; !g.inconsistent() && i > 0; ) { for (unsigned i = sz; !g.inconsistent() && i > 0; ) {
--i; --i;
expr_ref r = simplify(g.form(i)); expr_ref r = simplify_rec(g.form(i));
if (i > 0 && !m.is_true(r) && !m.is_false(r) && !g.dep(i) && !g.proofs_enabled() && !assert_expr(r, false)) { if (i > 0 && !m.is_true(r) && !m.is_false(r) && !g.dep(i) && !g.proofs_enabled() && !assert_expr(r, false)) {
r = m.mk_false(); r = m.mk_false();
} }
change |= r != g.form(i); change |= r != g.form(i);
CTRACE("simplify", r != g.form(i), tout << r << " " << mk_pp(g.form(i), m) << "\n";);
proof* new_pr = 0; proof* new_pr = 0;
if (g.proofs_enabled()) { if (g.proofs_enabled()) {
new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite_star(g.form(i), r, 0, 0)); new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite_star(g.form(i), r, 0, 0));
@ -333,11 +411,41 @@ void dom_simplify_tactic::simplify_goal(goal& g) {
SASSERT(scope_level() == 0); SASSERT(scope_level() == 0);
} }
/**
\brief determine if a is dominated by b.
Walk the immediate dominators of a upwards until hitting b or a term that is deeper than b.
Save intermediary results in a cache to avoid recomputations.
*/
bool dom_simplify_tactic::is_subexpr(expr * a, expr * b) {
if (a == b)
return true;
bool r;
if (m_subexpr_cache.find(a, b, r))
return r;
if (get_depth(a) >= get_depth(b)) {
return false;
}
SASSERT(a != idom(a) && get_depth(idom(a)) > get_depth(a));
r = is_subexpr(idom(a), b);
m_subexpr_cache.insert(a, b, r);
return r;
}
ptr_vector<expr> const & dom_simplify_tactic::tree(expr * e) {
if (auto p = m_dominators.get_tree().find_core(e))
return p->get_data().get_value();
return m_empty;
}
// ---------------------- // ----------------------
// expr_substitution_simplifier // expr_substitution_simplifier
bool expr_substitution_simplifier::assert_expr(expr * t, bool sign) { bool expr_substitution_simplifier::assert_expr(expr * t, bool sign) {
m_scoped_substitution.push();
expr* tt; expr* tt;
if (!sign) { if (!sign) {
update_substitution(t, 0); update_substitution(t, 0);
@ -389,6 +497,8 @@ void expr_substitution_simplifier::update_substitution(expr* n, proof* pr) {
if (is_ground(n) && (m.is_eq(n, lhs, rhs) || m.is_iff(n, lhs, rhs))) { if (is_ground(n) && (m.is_eq(n, lhs, rhs) || m.is_iff(n, lhs, rhs))) {
compute_depth(lhs); compute_depth(lhs);
compute_depth(rhs); compute_depth(rhs);
m_trail.push_back(lhs);
m_trail.push_back(rhs);
if (is_gt(lhs, rhs)) { if (is_gt(lhs, rhs)) {
TRACE("propagate_values", tout << "insert " << mk_pp(lhs, m) << " -> " << mk_pp(rhs, m) << "\n";); TRACE("propagate_values", tout << "insert " << mk_pp(lhs, m) << " -> " << mk_pp(rhs, m) << "\n";);
m_scoped_substitution.insert(lhs, rhs, pr); m_scoped_substitution.insert(lhs, rhs, pr);
@ -440,3 +550,7 @@ void expr_substitution_simplifier::compute_depth(expr* e) {
m_expr2depth.insert(e, d + 1); m_expr2depth.insert(e, d + 1);
} }
} }
tactic * mk_dom_simplify_tactic(ast_manager & m, params_ref const & p) {
return clean(alloc(dom_simplify_tactic, m, alloc(expr_substitution_simplifier, m), p));
}

70
src/tactic/core/dom_simplify_tactic.h
View file

@ -23,6 +23,8 @@ Notes:
#include "ast/ast.h" #include "ast/ast.h"
#include "ast/expr_substitution.h" #include "ast/expr_substitution.h"
#include "tactic/tactic.h" #include "tactic/tactic.h"
#include "tactic/tactical.h"
#include "util/obj_pair_hashtable.h"
class expr_dominators { class expr_dominators {
@ -43,24 +45,28 @@ private:
void compute_post_order(); void compute_post_order();
expr* intersect(expr* x, expr * y); expr* intersect(expr* x, expr * y);
void compute_dominators(); bool compute_dominators();
void extract_tree(); void extract_tree();
std::ostream& display(std::ostream& out, unsigned indent, expr* r);
public: public:
expr_dominators(ast_manager& m): m(m), m_root(m) {} expr_dominators(ast_manager& m): m(m), m_root(m) {}
void compile(expr * e); bool compile(expr * e);
void compile(unsigned sz, expr * const* es); bool compile(unsigned sz, expr * const* es);
tree_t const& get_tree() { return m_tree; } tree_t const& get_tree() { return m_tree; }
void reset(); void reset();
expr* idom(expr *e) const { return m_doms[e]; }
std::ostream& display(std::ostream& out);
}; };
class dom_simplify_tactic : public tactic { class dom_simplifier {
public:
class simplifier {
public: public:
virtual ~simplifier() {} dom_simplifier() {}
virtual ~dom_simplifier() {}
/** /**
\brief assert_expr performs an implicit push \brief assert_expr performs an implicit push
*/ */
@ -76,45 +82,55 @@ public:
*/ */
virtual void pop(unsigned num_scopes) = 0; virtual void pop(unsigned num_scopes) = 0;
virtual simplifier * translate(ast_manager & m); virtual dom_simplifier * translate(ast_manager & m) = 0;
}; };
private:
class dom_simplify_tactic : public tactic {
ast_manager& m; ast_manager& m;
simplifier* m_simplifier; dom_simplifier* m_simplifier;
params_ref m_params; params_ref m_params;
expr_ref_vector m_trail, m_args, m_args2; expr_ref_vector m_trail, m_args;
obj_map<expr, expr*> m_result; obj_map<expr, expr*> m_result;
expr_dominators m_dominators; expr_dominators m_dominators;
unsigned m_scope_level; unsigned m_scope_level;
unsigned m_depth; unsigned m_depth;
unsigned m_max_depth; unsigned m_max_depth;
ptr_vector<expr> m_empty;
obj_pair_map<expr, expr, bool> m_subexpr_cache;
bool m_forward;
expr_ref simplify(expr* t); expr_ref simplify_rec(expr* t);
expr_ref simplify_arg(expr* t);
expr_ref simplify_ite(app * ite); expr_ref simplify_ite(app * ite);
expr_ref simplify_and(app * ite) { return simplify_and_or(true, ite); } expr_ref simplify_and(app * ite) { return simplify_and_or(true, ite); }
expr_ref simplify_or(app * ite) { return simplify_and_or(false, ite); } expr_ref simplify_or(app * ite) { return simplify_and_or(false, ite); }
expr_ref simplify_and_or(bool is_and, app * ite); expr_ref simplify_and_or(bool is_and, app * ite);
void simplify_goal(goal& g); void simplify_goal(goal& g);
expr_ref get_cached(expr* t) { expr* r = 0; if (!m_result.find(r, r)) r = t; return expr_ref(r, m); } bool is_subexpr(expr * a, expr * b);
expr_ref get_cached(expr* t) { expr* r = 0; if (!m_result.find(t, r)) r = t; return expr_ref(r, m); }
void cache(expr *t, expr* r) { m_result.insert(t, r); m_trail.push_back(r); } void cache(expr *t, expr* r) { m_result.insert(t, r); m_trail.push_back(r); }
ptr_vector<expr> const & tree(expr * e);
expr* idom(expr *e) const { return m_dominators.idom(e); }
unsigned scope_level() { return m_scope_level; } unsigned scope_level() { return m_scope_level; }
void pop(unsigned n) { SASSERT(n <= m_scope_level); m_scope_level -= n; m_simplifier->pop(n); } void pop(unsigned n) { SASSERT(n <= m_scope_level); m_scope_level -= n; m_simplifier->pop(n); }
bool assert_expr(expr* f, bool sign) { m_scope_level++; return m_simplifier->assert_expr(f, sign); } bool assert_expr(expr* f, bool sign) { m_scope_level++; return m_simplifier->assert_expr(f, sign); }
void init(goal& g); bool init(goal& g);
public: public:
dom_simplify_tactic(ast_manager & m, simplifier* s, params_ref const & p = params_ref()): dom_simplify_tactic(ast_manager & m, dom_simplifier* s, params_ref const & p = params_ref()):
m(m), m_simplifier(s), m_params(p), m(m), m_simplifier(s), m_params(p),
m_trail(m), m_args(m), m_args2(m), m_trail(m), m_args(m),
m_dominators(m), m_dominators(m),
m_scope_level(0), m_depth(0), m_max_depth(1024) {} m_scope_level(0), m_depth(0), m_max_depth(1024), m_forward(true) {}
virtual ~dom_simplify_tactic() {} virtual ~dom_simplify_tactic();
virtual tactic * translate(ast_manager & m); virtual tactic * translate(ast_manager & m);
virtual void updt_params(params_ref const & p) {} virtual void updt_params(params_ref const & p) {}
@ -130,11 +146,12 @@ public:
virtual void cleanup(); virtual void cleanup();
}; };
class expr_substitution_simplifier : public dom_simplify_tactic::simplifier { class expr_substitution_simplifier : public dom_simplifier {
ast_manager& m; ast_manager& m;
expr_substitution m_subst; expr_substitution m_subst;
scoped_expr_substitution m_scoped_substitution; scoped_expr_substitution m_scoped_substitution;
obj_map<expr, unsigned> m_expr2depth; obj_map<expr, unsigned> m_expr2depth;
expr_ref_vector m_trail;
// move from asserted_formulas to here.. // move from asserted_formulas to here..
void compute_depth(expr* e); void compute_depth(expr* e);
@ -142,7 +159,7 @@ class expr_substitution_simplifier : public dom_simplify_tactic::simplifier {
unsigned depth(expr* e) { return m_expr2depth[e]; } unsigned depth(expr* e) { return m_expr2depth[e]; }
public: public:
expr_substitution_simplifier(ast_manager& m): m(m), m_subst(m), m_scoped_substitution(m_subst) {} expr_substitution_simplifier(ast_manager& m): m(m), m_subst(m), m_scoped_substitution(m_subst), m_trail(m) {}
virtual ~expr_substitution_simplifier() {} virtual ~expr_substitution_simplifier() {}
virtual bool assert_expr(expr * t, bool sign); virtual bool assert_expr(expr * t, bool sign);
@ -152,12 +169,17 @@ public:
virtual void pop(unsigned num_scopes) { m_scoped_substitution.pop(num_scopes); } virtual void pop(unsigned num_scopes) { m_scoped_substitution.pop(num_scopes); }
virtual simplifier * translate(ast_manager & m) { virtual dom_simplifier * translate(ast_manager & m) {
SASSERT(m_subst.empty()); SASSERT(m_subst.empty());
return alloc(expr_substitution_simplifier, m); return alloc(expr_substitution_simplifier, m);
} }
}; };
tactic * mk_dom_simplify_tactic(ast_manager & m, params_ref const & p = params_ref());
/*
ADD_TACTIC("dom-simplify", "apply dominator simplification rules.", "mk_dom_simplify_tactic(m, p)")
*/
#endif #endif

4
src/test/ddnf.cpp
View file

@ -214,6 +214,10 @@ void tst_ddnf1() {
ddnf.insert(*tX1); ddnf.insert(*tX1);
ddnf.insert(*t1X); ddnf.insert(*t1X);
ddnf.display(std::cout); ddnf.display(std::cout);
tbvm.deallocate(tXX);
tbvm.deallocate(t1X);
tbvm.deallocate(tX1);
tbvm.deallocate(t11);
} }

1
src/util/lp/indexed_vector_instances.cpp
View file

@ -33,6 +33,7 @@ template void indexed_vector<unsigned>::resize(unsigned int);
template void indexed_vector<mpq>::set_value(const mpq&, unsigned int); template void indexed_vector<mpq>::set_value(const mpq&, unsigned int);
template void indexed_vector<unsigned>::set_value(const unsigned&, unsigned int); template void indexed_vector<unsigned>::set_value(const unsigned&, unsigned int);
#ifdef Z3DEBUG #ifdef Z3DEBUG
template bool indexed_vector<unsigned>::is_OK() const;
template bool indexed_vector<double>::is_OK() const; template bool indexed_vector<double>::is_OK() const;
template bool indexed_vector<mpq>::is_OK() const; template bool indexed_vector<mpq>::is_OK() const;
template bool indexed_vector<lp::numeric_pair<mpq> >::is_OK() const; template bool indexed_vector<lp::numeric_pair<mpq> >::is_OK() const;

2
src/util/lp/lar_solver.h
View file

@ -417,6 +417,8 @@ public:
for (unsigned i : m_rows_with_changed_bounds.m_index) { for (unsigned i : m_rows_with_changed_bounds.m_index) {
calculate_implied_bounds_for_row(i, bp); calculate_implied_bounds_for_row(i, bp);
if (settings().get_cancel_flag())
return;
} }
m_rows_with_changed_bounds.clear(); m_rows_with_changed_bounds.clear();
if (!use_tableau()) { if (!use_tableau()) {

13
src/util/lp/lp_primal_core_solver_tableau.h
View file

@ -188,9 +188,18 @@ unsigned lp_primal_core_solver<T, X>::solve_with_tableau() {
&& &&
this->total_iterations() <= this->m_settings.max_total_number_of_iterations this->total_iterations() <= this->m_settings.max_total_number_of_iterations
&& &&
!(this->current_x_is_feasible() && this->m_look_for_feasible_solution_only)); !(this->current_x_is_feasible() && this->m_look_for_feasible_solution_only)
&&
this->m_settings.get_cancel_flag() == false);
SASSERT(this->get_status() == FLOATING_POINT_ERROR if (this->m_settings.get_cancel_flag()) {
this->set_status(CANCELLED);
}
SASSERT(
this->get_status() == FLOATING_POINT_ERROR
||
this->get_status() == CANCELLED
|| ||
this->current_x_is_feasible() == false this->current_x_is_feasible() == false
|| ||

3
src/util/lp/lp_settings.h
View file

@ -61,7 +61,8 @@ enum lp_status {
TIME_EXHAUSTED, TIME_EXHAUSTED,
ITERATIONS_EXHAUSTED, ITERATIONS_EXHAUSTED,
EMPTY, EMPTY,
UNSTABLE UNSTABLE,
CANCELLED
}; };
// when the ratio of the vector lenth to domain size to is greater than the return value we switch to solve_By_for_T_indexed_only // when the ratio of the vector lenth to domain size to is greater than the return value we switch to solve_By_for_T_indexed_only

5
src/util/rlimit.cpp
View file

@ -21,6 +21,7 @@ Revision History:
reslimit::reslimit(): reslimit::reslimit():
m_cancel(0), m_cancel(0),
m_suspend(false),
m_count(0), m_count(0),
m_limit(0) { m_limit(0) {
} }
@ -31,12 +32,12 @@ uint64 reslimit::count() const {
bool reslimit::inc() { bool reslimit::inc() {
++m_count; ++m_count;
return m_cancel == 0 && (m_limit == 0 || m_count <= m_limit); return (m_cancel == 0 && (m_limit == 0 || m_count <= m_limit)) || m_suspend;
} }
bool reslimit::inc(unsigned offset) { bool reslimit::inc(unsigned offset) {
m_count += offset; m_count += offset;
return m_cancel == 0 && (m_limit == 0 || m_count <= m_limit); return (m_cancel == 0 && (m_limit == 0 || m_count <= m_limit)) || m_suspend;
} }
void reslimit::push(unsigned delta_limit) { void reslimit::push(unsigned delta_limit) {

15
src/util/rlimit.h
View file

@ -23,12 +23,14 @@ Revision History:
class reslimit { class reslimit {
volatile unsigned m_cancel; volatile unsigned m_cancel;
bool m_suspend;
uint64 m_count; uint64 m_count;
uint64 m_limit; uint64 m_limit;
svector<uint64> m_limits; svector<uint64> m_limits;
ptr_vector<reslimit> m_children; ptr_vector<reslimit> m_children;
void set_cancel(unsigned f); void set_cancel(unsigned f);
friend class scoped_suspend_rlimit;
public: public:
reslimit(); reslimit();
@ -42,7 +44,7 @@ public:
uint64 count() const; uint64 count() const;
bool get_cancel_flag() const { return m_cancel > 0; } bool get_cancel_flag() const { return m_cancel > 0 && !m_suspend; }
char const* get_cancel_msg() const; char const* get_cancel_msg() const;
void cancel(); void cancel();
void reset_cancel(); void reset_cancel();
@ -61,6 +63,17 @@ public:
}; };
class scoped_suspend_rlimit {
reslimit & m_limit;
public:
scoped_suspend_rlimit(reslimit& r): m_limit(r) {
r.m_suspend = true;
}
~scoped_suspend_rlimit() {
m_limit.m_suspend = false;
}
};
struct scoped_limits { struct scoped_limits {
reslimit& m_limit; reslimit& m_limit;
unsigned m_sz; unsigned m_sz;