mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-10 11:17:07 +00:00
Code Activity
z3/lib/z3_replayer.cpp
Leonardo de Moura e9eab22e5c Z3 sources 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2012-10-02 11:35:25 -07:00

712 lines
23 KiB
C++
Raw Blame History

/*++
Copyright (c) 2011 Microsoft Corporation
Module Name:
z3_replayer.cpp
Abstract:
Interpreter for Z3 logs
Author:
Leonardo de Moura (leonardo) 2011-09-22
Notes:
--*/
#include"vector.h"
#include"map.h"
#include"z3_replayer.h"
#include"stream_buffer.h"
#include"symbol.h"
#include"trace.h"
void register_z3_replayer_cmds(z3_replayer & in);
void throw_invalid_reference() {
throw z3_replayer_exception("invalid argument reference");
}
struct z3_replayer::imp {
z3_replayer & m_owner;
std::istream & m_stream;
char m_curr; // current char;
int m_line; // line
svector<char> m_string;
symbol m_id;
__int64 m_int64;
__uint64 m_uint64;
double m_double;
size_t m_ptr;
size_t_map<void *> m_heap;
svector<z3_replayer_cmd> m_cmds;
enum value_kind { INT64, UINT64, DOUBLE, STRING, SYMBOL, OBJECT, UINT_ARRAY, SYMBOL_ARRAY, OBJECT_ARRAY };
struct value {
value_kind m_kind;
union {
__int64 m_int;
__uint64 m_uint;
double m_double;
char const * m_str;
void * m_obj;
};
value():m_kind(OBJECT), m_int(0) {}
value(void * obj):m_kind(OBJECT), m_obj(obj) {}
value(value_kind k, char const * str):m_kind(k), m_str(str) {}
value(value_kind k, __uint64 u):m_kind(k), m_uint(u) {}
value(value_kind k, __int64 i):m_kind(k), m_int(i) {}
value(value_kind k, double d):m_kind(k), m_double(d) {}
};
svector<value> m_args;
void * m_result;
vector<ptr_vector<void> > m_obj_arrays;
vector<svector<Z3_symbol> > m_sym_arrays;
vector<unsigned_vector> m_unsigned_arrays;
imp(z3_replayer & o, std::istream & in):
m_owner(o),
m_stream(in),
m_curr(0),
m_line(1) {
next();
}
void display_arg(std::ostream & out, value const & v) const {
switch (v.m_kind) {
case INT64:
out << v.m_int;
break;
case UINT64:
out << v.m_uint;
break;
case DOUBLE:
out << v.m_double;
break;
case STRING:
out << v.m_str;
break;
case SYMBOL:
out << symbol::mk_symbol_from_c_ptr(v.m_str);
break;
case OBJECT:
out << v.m_obj;
break;
case UINT_ARRAY:
case OBJECT_ARRAY:
case SYMBOL_ARRAY:
out << "<array>";
break;
default:
out << "<unknown>";
break;
}
}
void display_args(std::ostream & out) const {
for (unsigned i = 0; i < m_args.size(); i++) {
if (i > 0) out << " ";
display_arg(out, m_args[i]);
}
}
char curr() const { return m_curr; }
void new_line() { m_line++; }
void next() { m_curr = m_stream.get(); }
void read_string_core(char delimiter) {
if (curr() != delimiter)
throw z3_replayer_exception("invalid string/symbol");
m_string.reset();
next();
while (true) {
char c = curr();
if (c == EOF) {
throw z3_replayer_exception("unexpected end of file");
}
else if (c == '\n') {
throw z3_replayer_exception("unexpected end of line");
}
else if (c == '\\') {
next();
unsigned val = 0;
unsigned sz = 0;
while (sz < 3) {
c = curr();
if ('0' <= c && c <= '9') {
val *= 10;
val += c - '0';
sz++;
}
else {
throw z3_replayer_exception("invalid scaped character");
}
if (val > 255)
throw z3_replayer_exception("invalid scaped character");
next();
}
TRACE("z3_replayer_escape", tout << "val: " << val << "\n";);
m_string.push_back(static_cast<char>(val));
}
else if (c == delimiter) {
next();
m_string.push_back(0);
return;
}
else {
m_string.push_back(c);
next();
}
}
}
void read_string() {
read_string_core('"');
}
void read_quoted_symbol() {
read_string_core('|');
m_id = m_string.begin();
}
void read_int64() {
if (!(curr() == '-' || ('0' <= curr() && curr() <= '9')))
throw z3_replayer_exception("invalid integer");
bool sign = false;
if (curr() == '-') {
sign = true;
next();
if (!('0' <= curr() && curr() <= '9'))
throw z3_replayer_exception("invalid integer");
}
m_int64 = 0;
while (true) {
char c = curr();
if ('0' <= c && c <= '9') {
m_int64 = 10*m_int64 + (c - '0');
next();
}
else {
break;
}
}
if (sign)
m_int64 = -m_int64;
}
void read_uint64() {
if (!('0' <= curr() && curr() <= '9'))
throw z3_replayer_exception("invalid unsigned");
m_uint64 = 0;
while (true) {
char c = curr();
if ('0' <= c && c <= '9') {
m_uint64 = 10*m_uint64 + (c - '0');
next();
}
else {
break;
}
}
}
bool is_double_char() const {
return curr() == '-' || curr() == '.' || ('0' <= curr() && curr() <= '9') || curr() == 'e' || curr() == 'E';
}
void read_double() {
m_string.reset();
while (is_double_char()) {
m_string.push_back(curr());
next();
}
if (m_string.empty())
throw z3_replayer_exception("invalid double");
m_string.push_back(0);
char * ptr;
m_double = strtod(m_string.begin(), &ptr);
}
void read_ptr() {
if (!(('0' <= curr() && curr() <= '9') || ('A' <= curr() && curr() <= 'F') || ('a' <= curr() && curr() <= 'f')))
throw z3_replayer_exception("invalid ptr");
m_ptr = 0;
while (true) {
char c = curr();
if ('0' <= c && c <= '9') {
m_ptr = m_ptr * 16 + (c - '0');
}
else if ('a' <= c && c <= 'f') {
m_ptr = m_ptr * 16 + 10 + (c - 'a');
}
else if ('A' <= c && c <= 'F') {
m_ptr = m_ptr * 16 + 10 + (c - 'A');
}
else {
return;
}
next();
}
}
void skip_blank() {
while (true) {
char c = curr();
if (c == '\n') {
new_line();
next();
}
else if (c == ' ' || c == '\t') {
next();
}
else {
break;
}
}
}
void push_array(unsigned sz, value_kind k) {
unsigned asz = m_args.size();
if (sz > asz)
throw z3_replayer_exception("invalid array size");
__uint64 aidx;
value_kind nk;
for (unsigned i = asz - sz; i < asz; i++) {
if (m_args[i].m_kind != k)
throw z3_replayer_exception("invalid array: mixed value types");
}
if (k == UINT64) {
aidx = m_unsigned_arrays.size();
nk = UINT_ARRAY;
m_unsigned_arrays.push_back(unsigned_vector());
unsigned_vector & v = m_unsigned_arrays.back();
for (unsigned i = asz - sz; i < asz; i++) {
v.push_back(static_cast<unsigned>(m_args[i].m_uint));
}
}
else if (k == SYMBOL) {
aidx = m_sym_arrays.size();
nk = SYMBOL_ARRAY;
m_sym_arrays.push_back(svector<Z3_symbol>());
svector<Z3_symbol> & v = m_sym_arrays.back();
for (unsigned i = asz - sz; i < asz; i++) {
v.push_back(reinterpret_cast<Z3_symbol>(const_cast<char*>(m_args[i].m_str)));
}
}
else if (k == OBJECT) {
TRACE("z3_replayer_bug",
tout << "args: "; display_args(tout); tout << "\n";
tout << "push_back, sz: " << sz << ", m_obj_arrays.size(): " << m_obj_arrays.size() << "\n";
for (unsigned i = asz - sz; i < asz; i++) {
tout << "pushing: " << m_args[i].m_obj << "\n";
});
aidx = m_obj_arrays.size();
nk = OBJECT_ARRAY;
m_obj_arrays.push_back(ptr_vector<void>());
ptr_vector<void> & v = m_obj_arrays.back();
for (unsigned i = asz - sz; i < asz; i++) {
v.push_back(m_args[i].m_obj);
}
}
else {
throw z3_replayer_exception("unsupported array type");
}
m_args.shrink(asz - sz);
m_args.push_back(value(nk, aidx));
}
#define TICK_FREQUENCY 100000
void parse() {
unsigned long long counter = 0;
unsigned tick = 0;
while (true) {
IF_VERBOSE(1, {
counter++; tick++;
if (tick >= TICK_FREQUENCY) {
std::cout << "[replayer] " << counter << " operations executed" << std::endl;
tick = 0;
}
});
skip_blank();
char c = curr();
if (c == EOF)
return;
switch (c) {
case 'R':
// reset
next();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "R\n";);
reset();
break;
case 'P': {
// push pointer
next(); skip_blank(); read_ptr();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "P " << m_ptr << "\n";);
if (m_ptr == 0) {
m_args.push_back(0);
}
else {
void * obj = 0;
if (!m_heap.find(m_ptr, obj))
throw z3_replayer_exception("invalid pointer");
m_args.push_back(value(obj));
TRACE("z3_replayer_bug", tout << "args after 'P':\n"; display_args(tout); tout << "\n";);
}
break;
}
case 'S': {
// push string
next(); skip_blank(); read_string();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "S " << m_string.begin() << "\n";);
symbol sym(m_string.begin()); // save string
m_args.push_back(value(STRING, sym.bare_str()));
break;
}
case 'N':
// push null symbol
next();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "N\n";);
m_args.push_back(value(SYMBOL, static_cast<char const *>(0)));
break;
case '$': {
// push symbol
next(); skip_blank(); read_quoted_symbol();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "$ " << m_id << "\n";);
m_args.push_back(value(SYMBOL, m_id.bare_str()));
break;
}
case '#': {
// push numeral symbol
next(); skip_blank(); read_uint64();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "# " << m_uint64 << "\n";);
symbol sym(static_cast<unsigned>(m_uint64));
m_args.push_back(value(SYMBOL, static_cast<char const *>(sym.c_ptr())));
break;
}
case 'I':
// push integer;
next(); skip_blank(); read_int64();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "I " << m_int64 << "\n";);
m_args.push_back(value(INT64, m_int64));
break;
case 'U':
// push unsigned;
next(); skip_blank(); read_uint64();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "U " << m_uint64 << "\n";);
m_args.push_back(value(UINT64, m_uint64));
break;
case 'D':
// push double
next(); skip_blank(); read_double();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "D " << m_double << "\n";);
m_args.push_back(value(DOUBLE, m_double));
break;
case 'p':
case 's':
case 'u':
// push array
next(); skip_blank(); read_uint64();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "A " << m_uint64 << "\n";);
if (c == 'p')
push_array(static_cast<unsigned>(m_uint64), OBJECT);
else if (c == 's')
push_array(static_cast<unsigned>(m_uint64), SYMBOL);
else
push_array(static_cast<unsigned>(m_uint64), UINT64);
break;
case 'C': {
// call procedure
next(); skip_blank(); read_uint64();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "C " << m_uint64 << "\n";);
unsigned idx = static_cast<unsigned>(m_uint64);
if (idx >= m_cmds.size())
throw z3_replayer_exception("invalid command");
try {
m_cmds[idx](m_owner);
}
catch (z3_error & ex) {
throw ex;
}
catch (z3_exception & ex) {
std::cout << "[z3 exception]: " << ex.msg() << std::endl;
}
break;
}
case '=':
// save result
// = obj_id
next(); skip_blank(); read_ptr();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "= " << m_ptr << "\n";);
m_heap.insert(m_ptr, m_result);
break;
case '*': {
// save out
// @ obj_id pos
next(); skip_blank(); read_ptr(); skip_blank(); read_uint64();
unsigned pos = static_cast<unsigned>(m_uint64);
TRACE("z3_replayer", tout << "[" << m_line << "] " << "* " << m_ptr << " " << pos << "\n";);
if (pos >= m_args.size() || m_args[pos].m_kind != OBJECT)
throw_invalid_reference();
m_heap.insert(m_ptr, m_args[pos].m_obj);
break;
}
case '@': {
// save array out
// @ obj_id array_pos idx
next(); skip_blank(); read_ptr(); skip_blank(); read_uint64();
unsigned pos = static_cast<unsigned>(m_uint64);
if (pos >= m_args.size() || m_args[pos].m_kind != OBJECT_ARRAY)
throw_invalid_reference();
unsigned aidx = static_cast<unsigned>(m_args[pos].m_uint);
ptr_vector<void> & v = m_obj_arrays[aidx];
skip_blank(); read_uint64();
unsigned idx = static_cast<unsigned>(m_uint64);
TRACE("z3_replayer", tout << "[" << m_line << "] " << "@ " << m_ptr << " " << pos << " " << idx << "\n";);
TRACE("z3_replayer_bug", tout << "v[idx]: " << v[idx] << "\n";);
m_heap.insert(m_ptr, v[idx]);
break;
}
case 'M':
// user message
next(); skip_blank(); read_string();
TRACE("z3_replayer", tout << "[" << m_line << "] " << "M " << m_string.begin() << "\n";);
std::cout << m_string.begin() << "\n"; std::cout.flush();
break;
default:
TRACE("z3_replayer", tout << "unknown command " << c << "\n";);
throw z3_replayer_exception("unknown log command");
break;
}
}
}
int get_int(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != INT64)
throw_invalid_reference();
return static_cast<int>(m_args[pos].m_int);
}
__int64 get_int64(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != INT64)
throw_invalid_reference();
return m_args[pos].m_int;
}
unsigned get_uint(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != UINT64)
throw_invalid_reference();
return static_cast<unsigned>(m_args[pos].m_uint);
}
__uint64 get_uint64(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != UINT64)
throw_invalid_reference();
return m_args[pos].m_uint;
}
double get_double(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != DOUBLE)
throw_invalid_reference();
return m_args[pos].m_double;
}
Z3_string get_str(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != STRING)
throw_invalid_reference();
return m_args[pos].m_str;
}
Z3_symbol get_symbol(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != SYMBOL)
throw_invalid_reference();
return reinterpret_cast<Z3_symbol>(const_cast<char*>(m_args[pos].m_str));
}
void * get_obj(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != OBJECT)
throw_invalid_reference();
return m_args[pos].m_obj;
}
unsigned * get_uint_array(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != UINT_ARRAY)
throw_invalid_reference();
unsigned idx = static_cast<unsigned>(m_args[pos].m_uint);
return m_unsigned_arrays[idx].c_ptr();
}
Z3_symbol * get_symbol_array(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != SYMBOL_ARRAY)
throw_invalid_reference();
unsigned idx = static_cast<unsigned>(m_args[pos].m_uint);
return m_sym_arrays[idx].c_ptr();
}
void ** get_obj_array(unsigned pos) const {
if (pos >= m_args.size() || m_args[pos].m_kind != OBJECT_ARRAY)
throw_invalid_reference();
unsigned idx = static_cast<unsigned>(m_args[pos].m_uint);
ptr_vector<void> const & v = m_obj_arrays[idx];
TRACE("z3_replayer_bug", tout << "pos: " << pos << ", idx: " << idx << " size(): " << v.size() << "\n";
for (unsigned i = 0; i < v.size(); i++) tout << v[i] << " "; tout << "\n";);
return v.c_ptr();
}
int * get_int_addr(unsigned pos) {
if (pos >= m_args.size() || m_args[pos].m_kind != INT64)
throw_invalid_reference();
return reinterpret_cast<int*>(&(m_args[pos].m_int));
}
__int64 * get_int64_addr(unsigned pos) {
if (pos >= m_args.size() || m_args[pos].m_kind != INT64)
throw_invalid_reference();
return &(m_args[pos].m_int);
}
unsigned * get_uint_addr(unsigned pos) {
if (pos >= m_args.size() || m_args[pos].m_kind != UINT64)
throw_invalid_reference();
return reinterpret_cast<unsigned*>(&(m_args[pos].m_uint));
}
__uint64 * get_uint64_addr(unsigned pos) {
if (pos >= m_args.size() || m_args[pos].m_kind != UINT64)
throw_invalid_reference();
return &(m_args[pos].m_uint);
}
Z3_string * get_str_addr(unsigned pos) {
if (pos >= m_args.size() || m_args[pos].m_kind != STRING)
throw_invalid_reference();
return &(m_args[pos].m_str);
}
void ** get_obj_addr(unsigned pos) {
if (pos >= m_args.size() || m_args[pos].m_kind != OBJECT)
throw_invalid_reference();
return &(m_args[pos].m_obj);
}
void store_result(void * obj) {
m_result = obj;
}
void register_cmd(unsigned id, z3_replayer_cmd cmd) {
m_cmds.reserve(id+1, 0);
m_cmds[id] = cmd;
}
void reset() {
m_result = 0;
m_args.reset();
m_obj_arrays.reset();
m_sym_arrays.reset();
m_unsigned_arrays.reset();
}
};
z3_replayer::z3_replayer(std::istream & in) {
m_imp = alloc(imp, *this, in);
register_z3_replayer_cmds(*this);
}
z3_replayer::~z3_replayer() {
dealloc(m_imp);
}
unsigned z3_replayer::get_line() const {
return m_imp->m_line;
}
bool z3_replayer::get_bool(unsigned pos) const {
return get_int(pos) != 0;
}
int z3_replayer::get_int(unsigned pos) const {
return m_imp->get_int(pos);
}
unsigned z3_replayer::get_uint(unsigned pos) const {
return m_imp->get_uint(pos);
}
__int64 z3_replayer::get_int64(unsigned pos) const {
return m_imp->get_int64(pos);
}
__uint64 z3_replayer::get_uint64(unsigned pos) const {
return m_imp->get_uint64(pos);
}
double z3_replayer::get_double(unsigned pos) const {
return m_imp->get_double(pos);
}
Z3_string z3_replayer::get_str(unsigned pos) const {
return m_imp->get_str(pos);
}
Z3_symbol z3_replayer::get_symbol(unsigned pos) const {
return m_imp->get_symbol(pos);
}
void * z3_replayer::get_obj(unsigned pos) const {
return m_imp->get_obj(pos);
}
unsigned * z3_replayer::get_uint_array(unsigned pos) const {
return m_imp->get_uint_array(pos);
}
Z3_symbol * z3_replayer::get_symbol_array(unsigned pos) const {
return m_imp->get_symbol_array(pos);
}
void ** z3_replayer::get_obj_array(unsigned pos) const {
return m_imp->get_obj_array(pos);
}
int * z3_replayer::get_int_addr(unsigned pos) {
return m_imp->get_int_addr(pos);
}
__int64 * z3_replayer::get_int64_addr(unsigned pos) {
return m_imp->get_int64_addr(pos);
}
unsigned * z3_replayer::get_uint_addr(unsigned pos) {
return m_imp->get_uint_addr(pos);
}
__uint64 * z3_replayer::get_uint64_addr(unsigned pos) {
return m_imp->get_uint64_addr(pos);
}
Z3_string * z3_replayer::get_str_addr(unsigned pos) {
return m_imp->get_str_addr(pos);
}
void ** z3_replayer::get_obj_addr(unsigned pos) {
return m_imp->get_obj_addr(pos);
}
void z3_replayer::store_result(void * obj) {
return m_imp->store_result(obj);
}
void z3_replayer::register_cmd(unsigned id, z3_replayer_cmd cmd) {
return m_imp->register_cmd(id, cmd);
}
void z3_replayer::parse() {
return m_imp->parse();
}
View git blame Copy permalink