getting the z3 solver results back as :class:`cas.mapper.mapper`
instances.
"""
from amoco.logger import Log
logger = Log(__name__)
logger.debug("loading module")
from .expressions import *
from amoco.cas.mapper import mapper
try:
import z3
except ImportError:
logger.verbose("z3 package not found => solve() method is not implemented")
class solver(object):
def __init__(self, eqns=None, tactics=None, timeout=None):
raise NotImplementedError
has_solver = False
else:
logger.verbose("z3 package imported")
class solver(object):
"""
Wrapper of z3.Solver which allows to convert boolean expressions
to their z3 bitvector-based forms and ultimately convert back a z3
*model* into an amoco :class:`mapper` instance.
from amoco.config import conf
from amoco.logger import Log
logger = Log(__name__)
logger.debug("loading module")
import re
try:
from pygments.token import Token
from pygments.style import Style
from pygments.lexer import RegexLexer
from pygments.formatters import *
except ImportError:
logger.verbose("pygments package not found, no renderer defined")
has_pygments = False
# metaclass definition, with a syntax compatible with python2 and python3
class TokenType(type):
def __getattr__(cls, key):
return key
Token_base = TokenType("Token_base", (), {})
class Token(Token_base):
pass
class NullFormatter(object):
def __init__(self, **options):
self.options = options
def read_data(self,vaddr,size):
return self.mmap.read(vaddr,size)
def read_instruction(self,vaddr,**kargs):
if self.cpu is None:
logger.error('no cpu imported')
raise ValueError
maxlen = self.cpu.disassemble.maxlen
try:
istr = self.mmap.read(vaddr,maxlen)
except MemoryError,e:
logger.verbose("vaddr %s is not mapped"%vaddr)
raise MemoryError(e)
else:
if len(istr)<=0 or not isinstance(istr[0],str):
logger.verbose("failed to read instruction at %s"%vaddr)
return None
i = self.cpu.disassemble(istr[0],**kargs)
if i is None:
logger.warning("disassemble failed at vaddr %s"%vaddr)
return None
else:
i.address = vaddr
return i
# optional codehelper method allows platform-specific analysis of
# either a (raw) list of instruction, a block/func object (see amoco.code)
# the default helper is a no-op:
def codehelper(self,seq=None,block=None,func=None):
if seq is not None: return seq
if block is not None: return block
def read_data(self, vaddr, size):
return self.mmap.read(vaddr, size)
def read_instruction(self, vaddr, **kargs):
if self.cpu is None:
logger.error('no cpu imported')
raise ValueError
maxlen = self.cpu.disassemble.maxlen
try:
istr = self.mmap.read(vaddr, maxlen)
except MemoryError, e:
logger.verbose("vaddr %s is not mapped" % vaddr)
raise MemoryError(e)
else:
if len(istr) <= 0 or not isinstance(istr[0], str):
logger.verbose("failed to read instruction at %s" % vaddr)
return None
i = self.cpu.disassemble(istr[0], **kargs)
if i is None:
logger.warning("disassemble failed at vaddr %s" % vaddr)
return None
else:
i.address = vaddr
return i
# optional codehelper method allows platform-specific analysis of
# either a (raw) list of instruction, a block/func object (see amoco.code)
# the default helper is a no-op:
def codehelper(self, seq=None, block=None, func=None):
if seq is not None: return seq
if block is not None: return block
