pyvex 3.0__tar.gz

home/yans/.virtualenvs/t1/lib/python2.7/site-packages/pyvex/IRConst/__init__.py

@@ -0,0 +1,154 @@
+from .. import VEXObject
+
+# IRConst heirarchy
+class IRConst(VEXObject):
+    type = None
+
+    def __init__(self, c_expr):
+        VEXObject.__init__(self)
+        self.tag = ints_to_enums[c_expr.tag]
+
+    def pp(self):
+        print self.__str__()
+
+    @property
+    def size(self):
+        return type_sizes[self.type]
+
+    @staticmethod
+    def _translate(c_expr):
+        if c_expr[0] == ffi.NULL:
+            return None
+
+        tag = c_expr.tag
+
+        try:
+            return tag_to_class[tag](c_expr)
+        except KeyError:
+            raise PyVEXError('Unknown/unsupported IRExprTag %s\n' % ints_to_enums[tag])
+
+class U1(IRConst):
+    type = 'Ity_I1'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.U1
+
+    def __str__(self):
+        return "%d" % self.value
+
+class U8(IRConst):
+    type = 'Ity_I8'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.U8
+
+    def __str__(self):
+        return "0x%02x" % self.value
+
+class U16(IRConst):
+    type = 'Ity_I16'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.U16
+
+    def __str__(self):
+        return "0x%04x" % self.value
+
+class U32(IRConst):
+    type = 'Ity_I32'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.U32
+
+    def __str__(self):
+        return "0x%08x" % self.value
+
+class U64(IRConst):
+    type = 'Ity_I64'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.U64
+
+    def __str__(self):
+        return "0x%016x" % self.value
+
+class F32(IRConst):
+    type = 'Ity_F32'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.F32
+
+    def __str__(self):
+        return "%f" % self.value
+
+class F32i(IRConst):
+    type = 'Ity_F32'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.F32i
+
+    def __str__(self):
+        return "%f" % self.value
+
+class F64(IRConst):
+    type = 'Ity_F64'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.F64
+
+    def __str__(self):
+        return "%f" % self.value
+
+class F64i(IRConst):
+    type = 'Ity_F64'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.F64i
+
+    def __str__(self):
+        return "%f" % self.value
+
+class V128(IRConst):
+    type = 'Ity_V128'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.V128
+
+    def __str__(self):
+        return "%x" % self.value
+
+class V256(IRConst):
+    type = 'Ity_V256'
+
+    def __init__(self, c_expr):
+        IRConst.__init__(self, c_expr)
+        self.value = c_expr.Ico.V256
+
+    def __str__(self):
+        return "%x" % self.value
+
+from .. import ints_to_enums, enums_to_ints, PyVEXError, ffi, type_sizes
+
+tag_to_class = {
+    enums_to_ints['Ico_U1']: U1,
+    enums_to_ints['Ico_U8']: U8,
+    enums_to_ints['Ico_U16']: U16,
+    enums_to_ints['Ico_U32']: U32,
+    enums_to_ints['Ico_U64']: U64,
+    enums_to_ints['Ico_F32']: F32,
+    enums_to_ints['Ico_F32i']: F32i,
+    enums_to_ints['Ico_F64']: F64,
+    enums_to_ints['Ico_F64i']: F64i,
+    enums_to_ints['Ico_V128']: V128,
+    enums_to_ints['Ico_V256']: V256,
+}

home/yans/.virtualenvs/t1/lib/python2.7/site-packages/pyvex/IRExpr/__init__.py

@@ -0,0 +1,281 @@
+from .. import VEXObject
+
+# IRExpr heirarchy
+class IRExpr(VEXObject):
+    def __init__(self, c_expr, irsb):
+        VEXObject.__init__(self)
+        self.tag = ints_to_enums[c_expr.tag]
+        #self.c_expr = c_expr
+        self.arch = irsb.arch
+
+        if isinstance(self, (VECRET, Binder, BBPTR)):
+            self.result_type = 'Ity_INVALID'
+        else:
+            self.result_type = ints_to_enums[pvc.typeOfIRExpr(irsb.c_irsb.tyenv, c_expr)]
+        self.result_size = type_sizes[self.result_type]
+
+    def pp(self):
+        print self.__str__()
+
+    @property
+    def child_expressions(self):
+        '''
+        A list of all of the expressions that this expression ends up evaluating.
+        '''
+        expressions = [ ]
+        for _,v in self.__dict__.iteritems():
+            if isinstance(v, IRExpr):
+                expressions.append(v)
+                expressions.extend(v.child_expressions)
+        return expressions
+
+    @property
+    def constants(self):
+        '''
+        A list of all of the constants that this expression ends up using.
+        '''
+        constants = [ ]
+        for _,v in self.__dict__.iteritems():
+            if isinstance(v, IRExpr):
+                constants.extend(v.constants)
+            elif isinstance(v, IRConst):
+                constants.append(v)
+        return constants
+
+    @staticmethod
+    def _translate(c_expr, irsb):
+        if c_expr[0] == ffi.NULL:
+            return None
+
+        tag = c_expr.tag
+
+        try:
+            expr_class = tag_to_class[tag]
+        except KeyError:
+            raise PyVEXError('Unknown/unsupported IRExprTag %s\n' % ints_to_enums[tag])
+        return expr_class(c_expr, irsb)
+
+class Binder(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.binder = c_expr.iex.Binder.binder
+
+    def __str__(self):
+        return "Binder"
+
+class VECRET(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+
+    def __str__(self):
+        return "VECRET"
+
+class BBPTR(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.result_type = 'Ity_INVALID'
+        self.result_size = 0
+
+    def __str__(self):
+        return "BBPTR"
+
+class GetI(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.descr = IRRegArray(c_expr.Iex.GetI.descr)
+        self.ix = IRExpr._translate(c_expr.Iex.GetI.ix, irsb)
+        self.bias = c_expr.Iex.GetI.bias
+
+    @property
+    def description(self):
+        return self.descr
+
+    @property
+    def index(self):
+        return self.ix
+
+    def __str__(self):
+        return "GetI(%s)[%s,%s]" % (self.descr, self.ix, self.bias)
+
+class RdTmp(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.tmp = c_expr.Iex.RdTmp.tmp
+
+    def __str__(self):
+        return "t%d" % self.tmp
+
+class Get(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.offset = c_expr.Iex.Get.offset
+        self.ty = ints_to_enums[c_expr.Iex.Get.ty]
+
+    @property
+    def type(self):
+        return self.ty
+
+    def __str__(self):
+        return "GET:%s(%s)" % (self.ty[4:], self.arch.translate_register_name(self.offset))
+
+class Qop(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.op = ints_to_enums[c_expr.Iex.Qop.details.op]
+        self.args = (
+            IRExpr._translate(c_expr.Iex.Qop.details.arg1, irsb),
+            IRExpr._translate(c_expr.Iex.Qop.details.arg2, irsb),
+            IRExpr._translate(c_expr.Iex.Qop.details.arg3, irsb),
+            IRExpr._translate(c_expr.Iex.Qop.details.arg4, irsb),
+        )
+
+    def __str__(self):
+        return "%s(%s)" % (self.op[4:], ','.join(str(a) for a in self.args))
+
+    @property
+    def child_expressions(self):
+        expressions = sum((a.child_expressions for a in self.args), [ ])
+        expressions.extend(self.args)
+        return expressions
+
+class Triop(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.op = ints_to_enums[c_expr.Iex.Triop.details.op]
+        self.args = (
+            IRExpr._translate(c_expr.Iex.Triop.details.arg1, irsb),
+            IRExpr._translate(c_expr.Iex.Triop.details.arg2, irsb),
+            IRExpr._translate(c_expr.Iex.Triop.details.arg3, irsb),
+        )
+
+    def __str__(self):
+        return "%s(%s)" % (self.op[4:], ','.join(str(a) for a in self.args))
+
+    @property
+    def child_expressions(self):
+        expressions = sum((a.child_expressions for a in self.args), [ ])
+        expressions.extend(self.args)
+        return expressions
+
+class Binop(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.op = ints_to_enums[c_expr.Iex.Binop.op]
+        self.args = (
+            IRExpr._translate(c_expr.Iex.Binop.arg1, irsb),
+            IRExpr._translate(c_expr.Iex.Binop.arg2, irsb),
+        )
+
+    def __str__(self):
+        return "%s(%s)" % (self.op[4:], ','.join(str(a) for a in self.args))
+
+    @property
+    def child_expressions(self):
+        expressions = sum((a.child_expressions for a in self.args), [ ])
+        expressions.extend(self.args)
+        return expressions
+
+class Unop(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.op = ints_to_enums[c_expr.Iex.Unop.op]
+        self.args = (
+            IRExpr._translate(c_expr.Iex.Unop.arg, irsb),
+        )
+
+    def __str__(self):
+        return "%s(%s)" % (self.op[4:], ','.join(str(a) for a in self.args))
+
+    @property
+    def child_expressions(self):
+        expressions = sum((a.child_expressions for a in self.args), [ ])
+        expressions.extend(self.args)
+        return expressions
+
+class Load(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.end = ints_to_enums[c_expr.Iex.Load.end]
+        self.ty = ints_to_enums[c_expr.Iex.Load.ty]
+        self.addr = IRExpr._translate(c_expr.Iex.Load.addr, irsb)
+
+    @property
+    def endness(self):
+        return self.end
+
+    @property
+    def type(self):
+        return self.ty
+
+    def __str__(self):
+        return "LD%s:%s(%s)" % (self.end[-2:].lower(), self.ty[4:], self.addr)
+
+class Const(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.con = IRConst._translate(c_expr.Iex.Const.con)
+
+    def __str__(self):
+        return str(self.con)
+
+class ITE(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.cond = IRExpr._translate(c_expr.Iex.ITE.cond, irsb)
+        self.iffalse = IRExpr._translate(c_expr.Iex.ITE.iffalse, irsb)
+        self.iftrue = IRExpr._translate(c_expr.Iex.ITE.iftrue, irsb)
+
+    def __str__(self):
+        return "ITE(%s,%s,%s)" % (self.cond, self.iftrue, self.iffalse)
+
+class CCall(IRExpr):
+    def __init__(self, c_expr, irsb):
+        IRExpr.__init__(self, c_expr, irsb)
+        self.retty = ints_to_enums[c_expr.Iex.CCall.retty]
+        self.cee = IRCallee(c_expr.Iex.CCall.cee)
+
+        self.args = [ ]
+        for i in range(20):
+            a = c_expr.Iex.CCall.args[i]
+            if a == ffi.NULL:
+                break
+
+            self.args.append(IRExpr._translate(a, irsb))
+        self.args = tuple(self.args)
+
+    @property
+    def ret_type(self):
+        return self.retty
+
+    @property
+    def callee(self):
+        return self.cee
+
+    def __str__(self):
+        return "%s(%s):%s" % (self.cee, ','.join(str(a) for a in self.args), self.retty)
+
+    @property
+    def child_expressions(self):
+        expressions = sum((a.child_expressions for a in self.args), [ ])
+        expressions.extend(self.args)
+        return expressions
+
+from ..IRConst import IRConst
+from .. import IRCallee, IRRegArray, enums_to_ints, ints_to_enums, PyVEXError, ffi, pvc, type_sizes
+
+tag_to_class = {
+    enums_to_ints['Iex_Binder']: Binder,
+    enums_to_ints['Iex_Get']: Get,
+    enums_to_ints['Iex_GetI']: GetI,
+    enums_to_ints['Iex_RdTmp']: RdTmp,
+    enums_to_ints['Iex_Qop']: Qop,
+    enums_to_ints['Iex_Triop']: Triop,
+    enums_to_ints['Iex_Binop']: Binop,
+    enums_to_ints['Iex_Unop']: Unop,
+    enums_to_ints['Iex_Load']: Load,
+    enums_to_ints['Iex_Const']: Const,
+    enums_to_ints['Iex_ITE']: ITE,
+    enums_to_ints['Iex_CCall']: CCall,
+    enums_to_ints['Iex_BBPTR']: BBPTR,
+    enums_to_ints['Iex_VECRET']: VECRET,
+}

home/yans/.virtualenvs/t1/lib/python2.7/site-packages/pyvex/IRStmt/__init__.py

@@ -0,0 +1,265 @@
+from .. import VEXObject
+
+# IRStmt heirarchy
+class IRStmt(VEXObject):
+	def __init__(self, c_stmt, irsb):
+		VEXObject.__init__(self)
+		self.arch = irsb.arch
+		#self.c_stmt = c_stmt
+		self.tag = ints_to_enums[c_stmt.tag]
+
+	def pp(self):
+		print self.__str__()
+
+	@property
+	def expressions(self):
+		expressions = [ ]
+		for _,v in self.__dict__.iteritems():
+			if isinstance(v, IRExpr):
+				expressions.append(v)
+				expressions.extend(v.child_expressions)
+		return expressions
+
+	@property
+	def constants(self):
+		return sum((e.constants for e in self.expressions), [ ])
+
+	@staticmethod
+	def _translate(c_stmt, irsb):
+		if c_stmt[0] == ffi.NULL:
+			return None
+
+		tag = c_stmt.tag
+		try:
+			stmt_class = _tag_to_class[tag]
+		except KeyError:
+			raise PyVEXError('Unknown/unsupported IRStmtTag %s\n' % ints_to_enums[tag])
+		return stmt_class(c_stmt, irsb)
+
+class NoOp(IRStmt):
+	def __init__(self, c_stmt, irsb): #pylint:disable=unused-argument
+		IRStmt.__init__(self, c_stmt, irsb)
+
+	def __str__(self):
+		return "IR-NoOp"
+
+class IMark(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+		self.addr = c_stmt.Ist.IMark.addr
+		self.len = c_stmt.Ist.IMark.len
+		self.delta = c_stmt.Ist.IMark.delta
+
+	def __str__(self):
+		return "------ IMark(0x%x, %d, %d) ------" % (self.addr, self.len, self.delta)
+
+class AbiHint(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+		self.base = IRExpr._translate(c_stmt.Ist.AbiHint.base, irsb)
+		self.len = c_stmt.Ist.AbiHint.len
+		self.nia = IRExpr._translate(c_stmt.Ist.AbiHint.nia, irsb)
+
+	def __str__(self):
+		return "====== AbiHint(0x%s, %d, %s) ======" % (self.base, self.len, self.nia)
+
+class Put(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+		self.data = IRExpr._translate(c_stmt.Ist.Put.data, irsb)
+		self.offset = c_stmt.Ist.Put.offset
+
+	def __str__(self):
+		return "PUT(%s) = %s" % (self.arch.translate_register_name(self.offset), self.data)
+
+class PutI(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+		self.descr = IRRegArray(c_stmt.Ist.PutI.details.descr)
+		self.ix = IRExpr._translate(c_stmt.Ist.PutI.details.ix, irsb)
+		self.data = IRExpr._translate(c_stmt.Ist.PutI.details.data, irsb)
+		self.bias = c_stmt.Ist.PutI.details.bias
+
+	def __str__(self):
+		return "PutI(%s)[%s,%d] = %s" % (self.descr, self.ix, self.bias, self.data)
+
+class WrTmp(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+
+		self.data = IRExpr._translate(c_stmt.Ist.WrTmp.data, irsb)
+		self.tmp = c_stmt.Ist.WrTmp.tmp
+
+	def __str__(self):
+		return "t%d = %s" % (self.tmp, self.data)
+
+class Store(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+
+		self.addr = IRExpr._translate(c_stmt.Ist.Store.addr, irsb)
+		self.data = IRExpr._translate(c_stmt.Ist.Store.data, irsb)
+		self.end = ints_to_enums[c_stmt.Ist.Store.end]
+
+	@property
+	def endness(self):
+		return self.end
+
+	def __str__(self):
+		return "ST%s(%s) = %s" % (self.endness[-2:].lower(), self.addr, self.data)
+
+class CAS(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+
+		self.addr = IRExpr._translate(c_stmt.Ist.CAS.details.addr, irsb)
+		self.dataLo = IRExpr._translate(c_stmt.Ist.CAS.details.dataLo, irsb)
+		self.dataHi = IRExpr._translate(c_stmt.Ist.CAS.details.dataHi, irsb)
+		self.expdLo = IRExpr._translate(c_stmt.Ist.CAS.details.expdLo, irsb)
+		self.expdHi = IRExpr._translate(c_stmt.Ist.CAS.details.expdHi, irsb)
+		self.oldLo = c_stmt.Ist.CAS.details.oldLo
+		self.oldHi = c_stmt.Ist.CAS.details.oldHi
+		self.end = ints_to_enums[c_stmt.Ist.CAS.details.end]
+
+	@property
+	def endness(self):
+		return self.end
+
+	def __str__(self):
+		return "t(%s,%s) = CAS%s(%s :: (%s,%s)->(%s,%s))" % (self.oldLo, self.oldHi, self.end[-2:].lower(), self.addr, self.expdLo, self.expdHi, self.dataLo, self.dataHi)
+
+class LLSC(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+
+		self.addr = IRExpr._translate(c_stmt.Ist.LLSC.addr, irsb)
+		self.storedata = IRExpr._translate(c_stmt.Ist.LLSC.storedata, irsb)
+		self.result = c_stmt.Ist.LLSC.result
+		self.end = ints_to_enums[c_stmt.Ist.LLSC.end]
+
+	@property
+	def endness(self):
+		return self.end
+
+	def __str__(self):
+		if self.storedata is None:
+			return "result = LD%s-Linked(%s)" % (self.end[-2:].lower(), self.addr)
+		else:
+			return "result = ( ST%s-Cond(%s) = %s )" % (self.end[-2:].lower(), self.addr, self.storedata)
+
+class MBE(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+		self.event = ints_to_enums[c_stmt.Ist.MBE.event]
+
+	def __str__(self):
+		return "MBusEvent-" + self.event
+
+class Dirty(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+		self.cee = IRCallee(c_stmt.Ist.Dirty.details.cee)
+		self.guard = IRExpr._translate(c_stmt.Ist.Dirty.details.guard, irsb)
+		self.tmp = c_stmt.Ist.Dirty.details.tmp
+		self.mFx = ints_to_enums[c_stmt.Ist.Dirty.details.mFx]
+		self.mAddr = IRExpr._translate(c_stmt.Ist.Dirty.details.mAddr, irsb)
+		self.mSize = c_stmt.Ist.Dirty.details.mSize
+		self.nFxState = c_stmt.Ist.Dirty.details.nFxState
+
+		self.args = [ ]
+		for i in range(20):
+			a = c_stmt.Ist.Dirty.details.args[i]
+			if a == ffi.NULL:
+				break
+
+			self.args.append(IRExpr._translate(a, irsb))
+		self.args = tuple(self.args)
+
+	def __str__(self):
+		return "t%s = DIRTY %s %s ::: %s(%s)" % (self.tmp, self.guard, "TODO(effects)", self.cee, ','.join(str(a) for a in self.args))
+
+	@property
+	def child_expressions(self):
+		expressions = sum((a.child_expressions for a in self.args), [ ])
+		expressions.extend(self.args)
+		expressions.append(self.guard)
+		expressions.extend(self.guard.child_expressions)
+		return expressions
+
+class Exit(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+		self.guard = IRExpr._translate(c_stmt.Ist.Exit.guard, irsb)
+		self.dst = IRConst._translate(c_stmt.Ist.Exit.dst)
+		self.offsIP = c_stmt.Ist.Exit.offsIP
+		self.jk = ints_to_enums[c_stmt.Ist.Exit.jk]
+
+	@property
+	def jumpkind(self):
+		return self.jk
+
+	def __str__(self):
+		return "if (%s) { PUT(%d) = %s; %s }" % (self.guard, self.offsIP, hex(self.dst.value), self.jumpkind)
+
+class LoadG(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+
+		self.addr = IRExpr._translate(c_stmt.Ist.LoadG.details.addr, irsb)
+		self.alt = IRExpr._translate(c_stmt.Ist.LoadG.details.alt, irsb)
+		self.guard = IRExpr._translate(c_stmt.Ist.LoadG.details.guard, irsb)
+		self.dst = c_stmt.Ist.LoadG.details.dst
+		self.cvt = ints_to_enums[c_stmt.Ist.LoadG.details.cvt]
+
+		self.end = ints_to_enums[c_stmt.Ist.LoadG.details.end]
+
+		type_in = ffi.new('IRType *')
+		type_out = ffi.new('IRType *')
+		pvc.typeOfIRLoadGOp(c_stmt.Ist.LoadG.details.cvt, type_in, type_out)
+		type_in = ffi.cast('int *', type_in)[0]
+		type_out = ffi.cast('int *', type_out)[0]
+		self.cvt_types = (ints_to_enums[type_in], ints_to_enums[type_out])
+
+	@property
+	def endness(self):
+		return self.end
+
+	def __str__(self):
+		return "t%d = if (%s) %s(LD%s(%s)) else %s" % (self.dst, self.guard, self.cvt, self.end[-2:].lower(), self.addr, self.alt)
+
+class StoreG(IRStmt):
+	def __init__(self, c_stmt, irsb):
+		IRStmt.__init__(self, c_stmt, irsb)
+
+		self.addr = IRExpr._translate(c_stmt.Ist.StoreG.details.addr, irsb)
+		self.data = IRExpr._translate(c_stmt.Ist.StoreG.details.data, irsb)
+		self.guard = IRExpr._translate(c_stmt.Ist.StoreG.details.guard, irsb)
+		self.end = ints_to_enums[c_stmt.Ist.StoreG.details.end]
+
+	@property
+	def endness(self):
+		return self.end
+
+	def __str__(self):
+		return "if (%s) ST%s(%s) = %s" % (self.guard, self.end[-2:].lower(), self.addr, self.data)
+
+from ..IRExpr import IRExpr
+from ..IRConst import IRConst
+from .. import IRRegArray, ints_to_enums, enums_to_ints, IRCallee, ffi, pvc, PyVEXError
+
+_tag_to_class = {
+	enums_to_ints['Ist_NoOp']: NoOp,
+	enums_to_ints['Ist_IMark']: IMark,
+	enums_to_ints['Ist_AbiHint']: AbiHint,
+	enums_to_ints['Ist_Put']: Put,
+	enums_to_ints['Ist_PutI']: PutI,
+	enums_to_ints['Ist_WrTmp']: WrTmp,
+	enums_to_ints['Ist_Store']: Store,
+	enums_to_ints['Ist_LoadG']: LoadG,
+	enums_to_ints['Ist_StoreG']: StoreG,
+	enums_to_ints['Ist_CAS']: CAS,
+	enums_to_ints['Ist_LLSC']: LLSC,
+	enums_to_ints['Ist_Dirty']: Dirty,
+	enums_to_ints['Ist_MBE']: MBE,
+	enums_to_ints['Ist_Exit']: Exit,
+}