SYMBOL INDEX (738 symbols across 44 files)

FILE: fuzzing/enhanced_fdp.py
  class EnhancedFuzzedDataProvider (line 23) | class EnhancedFuzzedDataProvider(FuzzedDataProvider):
    method _consume_random_count (line 28) | def _consume_random_count(self) -> int:
    method ConsumeRandomBytes (line 34) | def ConsumeRandomBytes(self) -> bytes:
    method ConsumeRemainingBytes (line 41) | def ConsumeRemainingBytes(self) -> bytes:
    method ConsumeRandomString (line 47) | def ConsumeRandomString(self) -> str:
    method ConsumeRemainingString (line 54) | def ConsumeRemainingString(self) -> str:
    method PickValueInEnum (line 60) | def PickValueInEnum(self, enum):

FILE: fuzzing/irsb_fuzzer.py
  function nostdout (line 35) | def nostdout():
  class SupportedOptLevels (line 64) | class SupportedOptLevels(IntEnum):
  function consume_random_arch (line 75) | def consume_random_arch(fdp: atheris.FuzzedDataProvider) -> pyvex.arches...
  function TestOneInput (line 79) | def TestOneInput(data: bytes):
  function main (line 109) | def main():

FILE: make_ffi.py
  function find_good_scan (line 14) | def find_good_scan(questionable):
  function doit (line 69) | def doit(vex_path):
  function get_guest_offsets (line 133) | def get_guest_offsets(vex_path):

FILE: pyvex/arches.py
  class PyvexArch (line 7) | class PyvexArch:
    method __init__ (line 12) | def __init__(self, name: str, bits: int, memory_endness: str, instruct...
    method __repr__ (line 53) | def __repr__(self):
    method vex_name_small (line 57) | def vex_name_small(self):
    method translate_register_name (line 60) | def translate_register_name(self, offset, size=None):  # pylint: disab...
    method get_register_offset (line 69) | def get_register_offset(self, name: str) -> int:

FILE: pyvex/block.py
  class IRSB (line 32) | class IRSB(VEXObject):
    method __init__ (line 76) | def __init__(
    method empty_block (line 169) | def empty_block(arch, addr, statements=None, nxt=None, tyenv=None, jum...
    method tyenv (line 175) | def tyenv(self) -> "IRTypeEnv":
    method tyenv (line 181) | def tyenv(self, v):
    method has_statements (line 185) | def has_statements(self) -> bool:
    method exit_statements (line 189) | def exit_statements(self) -> tuple[tuple[int, int, IRStmt], ...]:
    method copy (line 210) | def copy(self) -> "IRSB":
    method extend (line 213) | def extend(self, extendwith) -> None:
    method invalidate_direct_next (line 289) | def invalidate_direct_next(self) -> None:
    method pp (line 292) | def pp(self) -> None:
    method __repr__ (line 298) | def __repr__(self):
    method __str__ (line 301) | def __str__(self):
    method __eq__ (line 304) | def __eq__(self, other):
    method __hash__ (line 314) | def __hash__(self):
    method typecheck (line 317) | def typecheck(self) -> bool:
    method from_c (line 359) | def from_c(c_irsb, mem_addr, arch) -> "IRSB":
    method from_py (line 365) | def from_py(tyenv, stmts, next_expr, jumpkind, mem_addr, arch) -> "IRSB":
    method stmts_used (line 381) | def stmts_used(self) -> int:
    method offsIP (line 387) | def offsIP(self) -> int:
    method direct_next (line 391) | def direct_next(self):
    method expressions (line 397) | def expressions(self):
    method instructions (line 406) | def instructions(self):
    method instruction_addresses (line 418) | def instruction_addresses(self) -> tuple[int, ...]:
    method size (line 432) | def size(self):
    method operations (line 441) | def operations(self):
    method all_constants (line 452) | def all_constants(self):
    method constants (line 460) | def constants(self):
    method constant_jump_targets (line 467) | def constant_jump_targets(self):
    method constant_jump_targets_and_jumpkinds (line 484) | def constant_jump_targets_and_jumpkinds(self):
    method _pp_str (line 504) | def _pp_str(self) -> str:
    method _is_defaultexit_direct_jump (line 534) | def _is_defaultexit_direct_jump(self):
    method _from_c (line 548) | def _from_c(self, lift_r, skip_stmts=False):
    method _set_attributes (line 598) | def _set_attributes(
    method _from_py (line 623) | def _from_py(self, irsb):
  class IRTypeEnv (line 638) | class IRTypeEnv(VEXObject):
    method __init__ (line 649) | def __init__(self, arch, types=None):
    method __str__ (line 654) | def __str__(self):
    method lookup (line 657) | def lookup(self, tmp: int) -> str:
    method sizeof (line 666) | def sizeof(self, tmp):
    method add (line 669) | def add(self, ty):
    method types_used (line 677) | def types_used(self):
    method _from_c (line 681) | def _from_c(arch, c_tyenv):
    method _to_c (line 685) | def _to_c(tyenv):
    method typecheck (line 691) | def typecheck(self):

FILE: pyvex/const.py
  class IRConst (line 11) | class IRConst(VEXObject, ABC):
    method pp (line 20) | def pp(self):
    method value (line 24) | def value(self) -> int:
    method _from_c (line 28) | def _from_c(c_const):
    method _to_c (line 42) | def _to_c(cls, const):
    method __eq__ (line 52) | def __eq__(self, other):
    method __hash__ (line 57) | def __hash__(self):
  class U1 (line 61) | class U1(IRConst):
    method __init__ (line 70) | def __init__(self, value):
    method __str__ (line 73) | def __str__(self):
    method _from_c (line 77) | def _from_c(c_const):
  class U8 (line 81) | class U8(IRConst):
    method __init__ (line 90) | def __init__(self, value):
    method __str__ (line 93) | def __str__(self):
    method _from_c (line 97) | def _from_c(c_const):
  class U16 (line 104) | class U16(IRConst):
    method __init__ (line 113) | def __init__(self, value):
    method __str__ (line 116) | def __str__(self):
    method _from_c (line 120) | def _from_c(c_const):
  class U32 (line 132) | class U32(IRConst):
    method __init__ (line 141) | def __init__(self, value: int):
    method __str__ (line 144) | def __str__(self):
    method _from_c (line 148) | def _from_c(c_const):
  class U64 (line 160) | class U64(IRConst):
    method __init__ (line 169) | def __init__(self, value):
    method __str__ (line 172) | def __str__(self):
    method _from_c (line 176) | def _from_c(c_const):
  function vex_int_class (line 191) | def vex_int_class(size):
  class F32 (line 213) | class F32(IRConst):
    method __init__ (line 222) | def __init__(self, value):
    method __str__ (line 225) | def __str__(self):
    method _from_c (line 229) | def _from_c(c_const):
  class F32i (line 233) | class F32i(IRConst):
    method __init__ (line 242) | def __init__(self, value):
    method __str__ (line 245) | def __str__(self):
    method _from_c (line 249) | def _from_c(c_const):
  class F64 (line 253) | class F64(IRConst):
    method __init__ (line 262) | def __init__(self, value):
    method __str__ (line 265) | def __str__(self):
    method _from_c (line 269) | def _from_c(c_const):
  class F64i (line 273) | class F64i(IRConst):
    method __init__ (line 282) | def __init__(self, value):
    method __str__ (line 285) | def __str__(self):
    method _from_c (line 289) | def _from_c(c_const):
  class V128 (line 293) | class V128(IRConst):
    method __init__ (line 302) | def __init__(self, value):
    method __str__ (line 305) | def __str__(self):
    method _from_c (line 311) | def _from_c(c_const):
  class V256 (line 320) | class V256(IRConst):
    method __init__ (line 329) | def __init__(self, value):
    method __str__ (line 332) | def __str__(self):
    method _from_c (line 337) | def _from_c(c_const):
  function is_int_ty (line 356) | def is_int_ty(ty):
  function is_int_tag (line 361) | def is_int_tag(tag):
  function get_tag_size (line 366) | def get_tag_size(tag):
  function get_type_size (line 377) | def get_type_size(ty):
  function get_type_spec_size (line 391) | def get_type_spec_size(ty):
  function ty_to_const_class (line 407) | def ty_to_const_class(ty):
  function tag_to_const_class (line 418) | def tag_to_const_class(tag):

FILE: pyvex/const_val.py
  class ConstVal (line 1) | class ConstVal:
    method __init__ (line 16) | def __init__(self, tmp: int, value: int, stmt_idx: int):
    method __repr__ (line 21) | def __repr__(self):
    method from_c (line 25) | def from_c(cls, r):

FILE: pyvex/data_ref.py
  function data_ref_type_str (line 1) | def data_ref_type_str(dref_enum):
  class DataRef (line 17) | class DataRef:
    method __init__ (line 30) | def __init__(self, data_addr, data_size, data_type, stmt_idx, ins_addr):
    method data_type_str (line 38) | def data_type_str(self):
    method __repr__ (line 44) | def __repr__(self):
    method from_c (line 54) | def from_c(cls, r):

FILE: pyvex/enums.py
  class VEXObject (line 7) | class VEXObject:
    method __eq__ (line 14) | def __eq__(self, other):
    method __hash__ (line 23) | def __hash__(self):
  class IRCallee (line 31) | class IRCallee(VEXObject):
    method __init__ (line 38) | def __init__(self, regparms, name, mcx_mask):
    method __str__ (line 44) | def __str__(self):
    method _from_c (line 48) | def _from_c(c_callee):
    method _to_c (line 57) | def _to_c(callee):  # pylint: disable=unused-argument
  class IRRegArray (line 68) | class IRRegArray(VEXObject):
    method __init__ (line 80) | def __init__(self, base, elemTy, nElems):
    method __str__ (line 86) | def __str__(self):
    method _from_c (line 90) | def _from_c(c_arr):
    method _to_c (line 94) | def _to_c(arr):
  function get_enum_from_int (line 104) | def get_enum_from_int(i):
  function get_int_from_enum (line 108) | def get_int_from_enum(e):
  function _add_enum (line 115) | def _add_enum(s, i=None):  # TODO get rid of this
  function vex_endness_from_string (line 136) | def vex_endness_from_string(endness_str):
  function default_vex_archinfo (line 140) | def default_vex_archinfo() -> dict[str, Any]:

FILE: pyvex/errors.py
  class PyVEXError (line 1) | class PyVEXError(Exception):
  class SkipStatementsError (line 5) | class SkipStatementsError(PyVEXError):
  class LiftingException (line 14) | class LiftingException(Exception):
  class NeedStatementsNotification (line 18) | class NeedStatementsNotification(LiftingException):

FILE: pyvex/expr.py
  class IRExpr (line 18) | class IRExpr(VEXObject):
    method pp (line 28) | def pp(self):
    method __str__ (line 31) | def __str__(self):
    method _pp_str (line 34) | def _pp_str(self) -> str:
    method child_expressions (line 38) | def child_expressions(self) -> list[IRExpr]:
    method constants (line 51) | def constants(self):
    method result_size (line 64) | def result_size(self, tyenv: IRTypeEnv):
    method result_type (line 67) | def result_type(self, tyenv: IRTypeEnv):
    method replace_expression (line 70) | def replace_expression(self, replacements):
    method _from_c (line 103) | def _from_c(c_expr) -> IRExpr | None:
    method _to_c (line 115) | def _to_c(expr):
    method typecheck (line 121) | def typecheck(self, tyenv):
  class Binder (line 125) | class Binder(IRExpr):
    method __init__ (line 134) | def __init__(self, binder):
    method _pp_str (line 137) | def _pp_str(self):
    method _from_c (line 141) | def _from_c(c_expr):
    method _to_c (line 145) | def _to_c(expr):
    method result_type (line 148) | def result_type(self, tyenv):
  class VECRET (line 152) | class VECRET(IRExpr):
    method _pp_str (line 157) | def _pp_str(self):
    method _from_c (line 161) | def _from_c(c_expr):
    method _to_c (line 165) | def _to_c(expr):
    method result_type (line 168) | def result_type(self, tyenv):
  class GSPTR (line 172) | class GSPTR(IRExpr):
    method _pp_str (line 177) | def _pp_str(self):
    method _from_c (line 181) | def _from_c(c_expr):
    method _to_c (line 185) | def _to_c(expr):
    method result_type (line 188) | def result_type(self, tyenv):
  class GetI (line 192) | class GetI(IRExpr):
    method __init__ (line 201) | def __init__(self, descr, ix, bias):
    method description (line 207) | def description(self):
    method index (line 211) | def index(self):
    method _pp_str (line 214) | def _pp_str(self):
    method _from_c (line 218) | def _from_c(c_expr):
    method _to_c (line 225) | def _to_c(expr):
    method result_type (line 228) | def result_type(self, tyenv):
  class RdTmp (line 232) | class RdTmp(IRExpr):
    method __init__ (line 241) | def __init__(self, tmp):
    method _pp_str (line 244) | def _pp_str(self):
    method tmp (line 248) | def tmp(self):
    method _from_c (line 252) | def _from_c(c_expr):
    method _to_c (line 257) | def _to_c(expr):
    method get_instance (line 261) | def get_instance(tmp):
    method replace_expression (line 267) | def replace_expression(self, replacements):
    method result_type (line 271) | def result_type(self, tyenv):
    method __hash__ (line 274) | def __hash__(self):
  class Get (line 281) | class Get(IRExpr):
    method __init__ (line 290) | def __init__(self, offset: int, ty: str, ty_int: int | None = None):
    method ty (line 298) | def ty(self):
    method type (line 302) | def type(self):
    method _pp_str (line 305) | def _pp_str(self):
    method pp_str_with_name (line 308) | def pp_str_with_name(self, reg_name: str):
    method _from_c (line 314) | def _from_c(c_expr):
    method _to_c (line 318) | def _to_c(expr):
    method result_type (line 321) | def result_type(self, tyenv):
    method __hash__ (line 324) | def __hash__(self):
  class Qop (line 328) | class Qop(IRExpr):
    method __init__ (line 337) | def __init__(self, op, args):
    method _pp_str (line 341) | def _pp_str(self):
    method child_expressions (line 345) | def child_expressions(self):
    method _from_c (line 351) | def _from_c(c_expr):
    method _to_c (line 366) | def _to_c(expr):
    method result_type (line 369) | def result_type(self, tyenv):
    method typecheck (line 372) | def typecheck(self, tyenv):  # TODO change all this to use PyvexTypeEr...
  class Triop (line 397) | class Triop(IRExpr):
    method __init__ (line 406) | def __init__(self, op, args):
    method _pp_str (line 410) | def _pp_str(self):
    method child_expressions (line 414) | def child_expressions(self):
    method _from_c (line 420) | def _from_c(c_expr):
    method _to_c (line 430) | def _to_c(expr):
    method result_type (line 433) | def result_type(self, tyenv):
    method typecheck (line 436) | def typecheck(self, tyenv):
  class Binop (line 457) | class Binop(IRExpr):
    method __init__ (line 466) | def __init__(self, op, args, op_int=None):
    method _pp_str (line 471) | def _pp_str(self):
    method op (line 475) | def op(self):
    method child_expressions (line 481) | def child_expressions(self):
    method _from_c (line 487) | def _from_c(c_expr):
    method _to_c (line 495) | def _to_c(expr):
    method result_type (line 498) | def result_type(self, tyenv):
    method typecheck (line 501) | def typecheck(self, tyenv):
  class Unop (line 519) | class Unop(IRExpr):
    method __init__ (line 528) | def __init__(self, op: str, args: list[IRExpr]):
    method _pp_str (line 532) | def _pp_str(self):
    method child_expressions (line 536) | def child_expressions(self):
    method _from_c (line 542) | def _from_c(c_expr):
    method _to_c (line 546) | def _to_c(expr):
    method result_type (line 549) | def result_type(self, tyenv):
    method typecheck (line 552) | def typecheck(self, tyenv):
  class Load (line 565) | class Load(IRExpr):
    method __init__ (line 574) | def __init__(self, end, ty, addr):
    method endness (line 580) | def endness(self):
    method type (line 584) | def type(self):
    method _pp_str (line 587) | def _pp_str(self):
    method _from_c (line 591) | def _from_c(c_expr):
    method _to_c (line 599) | def _to_c(expr):
    method result_type (line 602) | def result_type(self, tyenv):
    method typecheck (line 605) | def typecheck(self, tyenv):
  class Const (line 615) | class Const(IRExpr):
    method __init__ (line 624) | def __init__(self, con: IRConst):
    method _pp_str (line 627) | def _pp_str(self):
    method con (line 631) | def con(self) -> IRConst:
    method _from_c (line 635) | def _from_c(c_expr):
    method _to_c (line 640) | def _to_c(expr):
    method get_instance (line 644) | def get_instance(con):
    method result_type (line 649) | def result_type(self, tyenv):
  class ITE (line 661) | class ITE(IRExpr):
    method __init__ (line 670) | def __init__(self, cond, iffalse, iftrue):
    method _pp_str (line 675) | def _pp_str(self):
    method _from_c (line 679) | def _from_c(c_expr):
    method _to_c (line 687) | def _to_c(expr):
    method result_type (line 690) | def result_type(self, tyenv):
    method typecheck (line 693) | def typecheck(self, tyenv):
  class CCall (line 712) | class CCall(IRExpr):
    method __init__ (line 721) | def __init__(self, retty, cee, args):
    method ret_type (line 727) | def ret_type(self):
    method callee (line 731) | def callee(self):
    method _pp_str (line 734) | def _pp_str(self):
    method child_expressions (line 738) | def child_expressions(self):
    method _from_c (line 744) | def _from_c(c_expr):
    method _to_c (line 757) | def _to_c(expr):
    method result_type (line 762) | def result_type(self, tyenv):
  function get_op_retty (line 766) | def get_op_retty(op):
  function _request_op_type_from_cache (line 773) | def _request_op_type_from_cache(op):
  function _request_op_type_from_libvex (line 777) | def _request_op_type_from_libvex(op):
  class PyvexOpMatchException (line 799) | class PyvexOpMatchException(Exception):
  class PyvexTypeErrorException (line 803) | class PyvexTypeErrorException(Exception):
  function int_type_for_size (line 807) | def int_type_for_size(size):
  function unop_signature (line 822) | def unop_signature(op):
  function binop_signature (line 831) | def binop_signature(op):
  function shift_signature (line 840) | def shift_signature(op):
  function cmp_signature (line 851) | def cmp_signature(op):
  function mull_signature (line 863) | def mull_signature(op):
  function half_signature (line 873) | def half_signature(op):
  function cast_signature (line 886) | def cast_signature(op):
  function _request_polymorphic_op_type (line 906) | def _request_polymorphic_op_type(op):
  function op_arg_types (line 921) | def op_arg_types(op):
  function tag_to_expr_class (line 947) | def tag_to_expr_class(tag):
  function enum_to_expr_class (line 962) | def enum_to_expr_class(tag_enum):

FILE: pyvex/lifting/gym/aarch64_spotter.py
  class Aarch64Instruction (line 9) | class Aarch64Instruction(Instruction):  # pylint: disable=abstract-method
  class Instruction_SYSL (line 15) | class Instruction_SYSL(Aarch64Instruction):
    method compute_result (line 19) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_MSR (line 23) | class Instruction_MSR(Aarch64Instruction):
    method compute_result (line 27) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_MRS (line 31) | class Instruction_MRS(Aarch64Instruction):
    method compute_result (line 35) | def compute_result(self):  # pylint: disable=arguments-differ
  class AARCH64Spotter (line 39) | class AARCH64Spotter(GymratLifter):

FILE: pyvex/lifting/gym/arm_spotter.py
  class ARMInstruction (line 13) | class ARMInstruction(Instruction):  # pylint: disable=abstract-method
    method match_instruction (line 20) | def match_instruction(self, data, bitstrm):
    method get_N (line 27) | def get_N(self):
    method get_C (line 34) | def get_C(self):
    method get_V (line 41) | def get_V(self):
    method get_Z (line 48) | def get_Z(self):
    method evaluate_condition (line 55) | def evaluate_condition(self):
    method _load_le_instr (line 101) | def _load_le_instr(self, bitstream: bitstring.ConstBitStream, numbits:...
  class Instruction_MRC (line 116) | class Instruction_MRC(ARMInstruction):
    method compute_result (line 126) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_MCR (line 133) | class Instruction_MCR(ARMInstruction):
    method compute_result (line 143) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_MSR (line 150) | class Instruction_MSR(ARMInstruction):
    method compute_result (line 156) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_MRS (line 164) | class Instruction_MRS(ARMInstruction):
    method compute_result (line 168) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_STM (line 176) | class Instruction_STM(ARMInstruction):
    method match_instruction (line 180) | def match_instruction(self, data, bitstrm):
    method compute_result (line 186) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_LDM (line 194) | class Instruction_LDM(ARMInstruction):
    method match_instruction (line 198) | def match_instruction(self, data, bitstrm):
    method compute_result (line 204) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_STC (line 238) | class Instruction_STC(ARMInstruction):
    method compute_result (line 242) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_STC_THUMB (line 247) | class Instruction_STC_THUMB(ARMInstruction):
    method compute_result (line 251) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_LDC (line 256) | class Instruction_LDC(ARMInstruction):
    method compute_result (line 260) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_LDC_THUMB (line 267) | class Instruction_LDC_THUMB(ARMInstruction):
    method compute_result (line 271) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_CDP (line 278) | class Instruction_CDP(Instruction):
    method compute_result (line 286) | def compute_result(self):  # pylint: disable=arguments-differ
  class ThumbInstruction (line 297) | class ThumbInstruction(Instruction):  # pylint: disable=abstract-method
    method mark_instruction_start (line 298) | def mark_instruction_start(self):
  class Instruction_tCPSID (line 302) | class Instruction_tCPSID(ThumbInstruction):
    method compute_result (line 306) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_tMSR (line 311) | class Instruction_tMSR(ThumbInstruction):
    method compute_result (line 315) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_tMRS (line 341) | class Instruction_tMRS(ThumbInstruction):
    method compute_result (line 345) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_tDMB (line 375) | class Instruction_tDMB(ThumbInstruction):
    method compute_result (line 379) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_WFI (line 384) | class Instruction_WFI(ThumbInstruction):
    method compute_result (line 389) | def compute_result(self):  # pylint: disable=arguments-differ
  class ARMSpotter (line 393) | class ARMSpotter(GymratLifter):
    method __init__ (line 415) | def __init__(self, arch: Arch, addr: int):
    method _lift (line 419) | def _lift(self):

FILE: pyvex/lifting/gym/x86_spotter.py
  class Instruction_SWAPGS (line 10) | class Instruction_SWAPGS(Instruction):
    method compute_result (line 14) | def compute_result(self, *args):
  class Instruction_SYSRET (line 18) | class Instruction_SYSRET(Instruction):
    method compute_result (line 22) | def compute_result(self, *args):
  class Instruction_IRETQ (line 27) | class Instruction_IRETQ(Instruction):
    method compute_result (line 31) | def compute_result(self, *args):
  class Instruction_RDMSR (line 36) | class Instruction_RDMSR(Instruction):
    method compute_result (line 40) | def compute_result(self, *args):
  class Instruction_XGETBV (line 53) | class Instruction_XGETBV(Instruction):
    method compute_result (line 57) | def compute_result(self, *args):
  class Instruction_AAM (line 70) | class Instruction_AAM(Instruction):
    method compute_result (line 75) | def compute_result(self):  # pylint: disable=arguments-differ
  class Instruction_AAD (line 90) | class Instruction_AAD(Instruction):
    method compute_result (line 95) | def compute_result(self):  # pylint: disable=arguments-differ
  class AMD64Spotter (line 111) | class AMD64Spotter(GymratLifter):
  class X86Spotter (line 123) | class X86Spotter(GymratLifter):

FILE: pyvex/lifting/libvex.py
  class VexRegisterUpdates (line 35) | class VexRegisterUpdates:
  class LibVEXLifter (line 44) | class LibVEXLifter(Lifter):
    method get_vex_log (line 50) | def get_vex_log():
    method _lift (line 53) | def _lift(self):

FILE: pyvex/lifting/lift_function.py
  function lift (line 22) | def lift(
  function register (line 291) | def register(lifter, arch_name):

FILE: pyvex/lifting/lifter.py
  class Lifter (line 7) | class Lifter:
    method __init__ (line 49) | def __init__(self, arch: Arch, addr: int):
    method lift (line 53) | def lift(
    method _lift (line 113) | def _lift(self):

FILE: pyvex/lifting/post_processor.py
  class Postprocessor (line 6) | class Postprocessor:
    method __init__ (line 7) | def __init__(self, irsb):
    method postprocess (line 10) | def postprocess(self):

FILE: pyvex/lifting/util/instr_helper.py
  class Instruction (line 13) | class Instruction(metaclass=abc.ABCMeta):
    method __init__ (line 73) | def __init__(self, bitstrm, arch, addr):
    method bin_format (line 88) | def bin_format(self) -> str:
    method name (line 97) | def name(self) -> str:
    method __call__ (line 104) | def __call__(self, irsb_c, past_instructions, future_instructions):
    method mark_instruction_start (line 107) | def mark_instruction_start(self):
    method fetch_operands (line 110) | def fetch_operands(self):  # pylint: disable=no-self-use
    method lift (line 117) | def lift(self, irsb_c: IRSBCustomizer, past_instructions, future_instr...
    method commit_result (line 138) | def commit_result(self, res):
    method compute_result (line 149) | def compute_result(self, *args):  # pylint: disable=unused-argument,no...
    method compute_flags (line 163) | def compute_flags(self, *args):
    method match_instruction (line 170) | def match_instruction(self, data, bitstrm):  # pylint: disable=unused-...
    method parse (line 181) | def parse(self, bitstrm):
    method bytewidth (line 215) | def bytewidth(self):
    method disassemble (line 220) | def disassemble(self):
    method load (line 231) | def load(self, addr, ty):
    method constant (line 242) | def constant(self, val, ty):
    method _lookup_register (line 256) | def _lookup_register(arch, reg):
    method get (line 266) | def get(self, reg, ty):
    method put (line 282) | def put(self, val, reg):
    method put_conditional (line 294) | def put_conditional(self, cond, valiftrue, valiffalse, reg):
    method store (line 311) | def store(self, val, addr):
    method jump (line 321) | def jump(self, condition, to_addr, jumpkind=JumpKind.Boring, ip_offset...
    method ite (line 365) | def ite(self, cond, t, f):
    method ccall (line 368) | def ccall(self, ret_type, func_name, args):
    method dirty (line 394) | def dirty(self, ret_type, func_name, args) -> VexValue:
    method _load_le_instr (line 421) | def _load_le_instr(self, bitstream: bitstring.ConstBitStream, numbits:...

FILE: pyvex/lifting/util/lifter_helper.py
  function is_empty (line 18) | def is_empty(bitstrm):
  class ParseError (line 26) | class ParseError(Exception):
  class GymratLifter (line 30) | class GymratLifter(Lifter):
    method __init__ (line 51) | def __init__(self, arch, addr):
    method create_bitstrm (line 58) | def create_bitstrm(self):
    method _decode_next_instruction (line 61) | def _decode_next_instruction(self, addr):
    method decode (line 82) | def decode(self):
    method _lift (line 106) | def _lift(self):
    method pp_disas (line 140) | def pp_disas(self):
    method error (line 148) | def error(self):
    method disassemble (line 151) | def disassemble(self):

FILE: pyvex/lifting/util/syntax_wrapper.py
  function checkparams (line 10) | def checkparams(rhstype=None):
  function vvifyresults (line 31) | def vvifyresults(f):
  class VexValue (line 41) | class VexValue:
    method __init__ (line 42) | def __init__(self, irsb_c: "IRSBCustomizer", rdt: "Union[RdTmp, Const]...
    method value (line 50) | def value(self):
    method signed (line 57) | def signed(self):
    method widen_unsigned (line 61) | def widen_unsigned(self, ty):
    method cast_to (line 65) | def cast_to(self, ty, signed=False, high=False):
    method widen_signed (line 69) | def widen_signed(self, ty):
    method narrow_high (line 73) | def narrow_high(self, ty):
    method narrow_low (line 77) | def narrow_low(self, ty):
    method __getitem__ (line 81) | def __getitem__(self, idx):
    method __setitem__ (line 94) | def __setitem__(self, idx, bval):
    method set_bit (line 100) | def set_bit(self, idx, bval):
    method set_bits (line 105) | def set_bits(self, idxsandvals):
    method ite (line 110) | def ite(self, iftrue, iffalse):
    method sar (line 116) | def sar(self, right):
    method __add__ (line 127) | def __add__(self, right):
    method __radd__ (line 131) | def __radd__(self, left):
    method __sub__ (line 136) | def __sub__(self, right):
    method __rsub__ (line 140) | def __rsub__(self, left):
    method __div__ (line 145) | def __div__(self, right):
    method __rdiv__ (line 152) | def __rdiv__(self, left):
    method __floordiv__ (line 156) | def __floordiv__(self, right):  # Note: nonprimitive
    method __rfloordiv__ (line 160) | def __rfloordiv__(self, left):
    method __truediv__ (line 164) | def __truediv__(self, right):  # Note: nonprimitive
    method __rtruediv__ (line 168) | def __rtruediv__(self, left):
    method __and__ (line 173) | def __and__(self, right):
    method __rand__ (line 177) | def __rand__(self, left):
    method __eq__ (line 182) | def __eq__(self, right):
    method __ne__ (line 187) | def __ne__(self, other):
    method __invert__ (line 192) | def __invert__(self):
    method __le__ (line 197) | def __le__(self, right):
    method __gt__ (line 205) | def __gt__(self, other):
    method __ge__ (line 213) | def __ge__(self, right):
    method __lshift__ (line 221) | def __lshift__(self, right):  # TODO put better type inference in irsb...
    method __lt__ (line 229) | def __lt__(self, right):
    method __mod__ (line 237) | def __mod__(self, right):  # Note: nonprimitive
    method __rmod__ (line 241) | def __rmod__(self, left):
    method __mul__ (line 246) | def __mul__(self, right):
    method __rmul__ (line 253) | def __rmul__(self, left):
    method __neg__ (line 258) | def __neg__(self):  # Note: nonprimitive
    method __or__ (line 266) | def __or__(self, right):
    method __ror__ (line 269) | def __ror__(self, left):
    method __pos__ (line 274) | def __pos__(self):
    method __rshift__ (line 279) | def __rshift__(self, right):
    method __rlshift__ (line 286) | def __rlshift__(self, left):
    method __rrshift__ (line 290) | def __rrshift__(self, left):
    method __xor__ (line 295) | def __xor__(self, right):
    method __rxor__ (line 298) | def __rxor__(self, left):
    method Constant (line 302) | def Constant(cls, irsb_c, val, ty):

FILE: pyvex/lifting/util/vex_helper.py
  class JumpKind (line 10) | class JumpKind:
  class TypeMeta (line 22) | class TypeMeta(type):
    method __getattr__ (line 25) | def __getattr__(self, name):
  class Type (line 34) | class Type(metaclass=TypeMeta):
  function get_op_format_from_const_ty (line 48) | def get_op_format_from_const_ty(ty):
  function make_format_op_generator (line 52) | def make_format_op_generator(fmt_string):
  function mkbinop (line 67) | def mkbinop(fstring):
  function mkunop (line 71) | def mkunop(fstring):
  function mkcmpop (line 75) | def mkcmpop(fstring_fragment, signedness=""):
  class IRSBCustomizer (line 85) | class IRSBCustomizer:
    method __init__ (line 118) | def __init__(self, irsb):
    method get_type (line 122) | def get_type(self, rdt):
    method _append_stmt (line 126) | def _append_stmt(self, stmt):
    method imark (line 129) | def imark(self, int_addr, int_length, int_delta=0):
    method get_reg (line 132) | def get_reg(self, regname):  # TODO move this into the lifter
    method put (line 135) | def put(self, expr_val, tuple_reg):
    method store (line 138) | def store(self, addr, expr):
    method noop (line 141) | def noop(self):
    method add_exit (line 144) | def add_exit(self, guard, dst, jk, ip):
    method goto (line 157) | def goto(self, addr):
    method ret (line 161) | def ret(self, addr):
    method call (line 165) | def call(self, addr):
    method _add_tmp (line 169) | def _add_tmp(self, t):
    method _rdtmp (line 172) | def _rdtmp(self, tmp):
    method _settmp (line 175) | def _settmp(self, expr):
    method rdreg (line 181) | def rdreg(self, reg, ty):
    method load (line 184) | def load(self, addr, ty):
    method op_ccall (line 187) | def op_ccall(self, retty, funcstr, args):
    method dirty (line 190) | def dirty(self, retty, funcstr, args):
    method ite (line 198) | def ite(self, condrdt, iftruerdt, iffalserdt):
    method mkconst (line 201) | def mkconst(self, val, ty):
    method op_generic (line 206) | def op_generic(self, Operation, op_generator):
    method op_binary (line 220) | def op_binary(self, op_format_str):
    method op_unary (line 223) | def op_unary(self, op_format_str):
    method cast_to (line 226) | def cast_to(self, rdt, tydest, signed=False, high=False):
    method op_to_one_bit (line 237) | def op_to_one_bit(self, rdt):
    method op_narrow_int (line 244) | def op_narrow_int(self, rdt, tydest, high_half=False):
    method op_widen_int (line 250) | def op_widen_int(self, rdt, tydest, signed=False):
    method op_widen_int_signed (line 256) | def op_widen_int_signed(self, rdt, tydest):
    method op_widen_int_unsigned (line 259) | def op_widen_int_unsigned(self, rdt, tydest):
    method get_msb (line 262) | def get_msb(self, tmp, ty):
    method get_bit (line 266) | def get_bit(self, rdt, idx):
    method op_extract_lsb (line 271) | def op_extract_lsb(self, rdt):
    method set_bit (line 275) | def set_bit(self, rdt, idx, bval):
    method set_bits (line 283) | def set_bits(self, rdt, idxsandvals):
    method get_rdt_width (line 300) | def get_rdt_width(self, rdt):

FILE: pyvex/lifting/zerodivision.py
  class ZeroDivisionPostProcessor (line 8) | class ZeroDivisionPostProcessor(Postprocessor):
    method postprocess (line 43) | def postprocess(self):

FILE: pyvex/native.py
  function _parse_ffi_str (line 17) | def _parse_ffi_str():
  function _find_c_lib (line 41) | def _find_c_lib():

FILE: pyvex/stmt.py
  class IRStmt (line 20) | class IRStmt(VEXObject):
    method pp (line 30) | def pp(self):
    method child_expressions (line 34) | def child_expressions(self) -> Iterator[IRExpr]:
    method expressions (line 45) | def expressions(self):
    method constants (line 49) | def constants(self):
    method _from_c (line 53) | def _from_c(c_stmt):
    method typecheck (line 63) | def typecheck(self, tyenv: IRTypeEnv) -> bool:  # pylint: disable=unus...
    method replace_expression (line 66) | def replace_expression(self, replacements):
    method __str__ (line 93) | def __str__(self):
    method pp_str (line 96) | def pp_str(self, reg_name=None, arch=None, tyenv=None) -> str:
  class NoOp (line 100) | class NoOp(IRStmt):
    method pp_str (line 109) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 113) | def _from_c(c_stmt):
  class IMark (line 117) | class IMark(IRStmt):
    method __init__ (line 128) | def __init__(self, addr: int, length: int, delta: int):
    method pp_str (line 133) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 137) | def _from_c(c_stmt):
  class AbiHint (line 141) | class AbiHint(IRStmt):
    method __init__ (line 150) | def __init__(self, base, length, nia):
    method pp_str (line 155) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 159) | def _from_c(c_stmt):
  class Put (line 165) | class Put(IRStmt):
    method __init__ (line 174) | def __init__(self, data: IRExpr, offset: int):
    method pp_str (line 179) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 189) | def _from_c(c_stmt):
    method typecheck (line 192) | def typecheck(self, tyenv):
  class PutI (line 196) | class PutI(IRStmt):
    method __init__ (line 205) | def __init__(self, descr, ix, data, bias):
    method pp_str (line 211) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 215) | def _from_c(c_stmt):
    method typecheck (line 223) | def typecheck(self, tyenv):
  class WrTmp (line 233) | class WrTmp(IRStmt):
    method __init__ (line 243) | def __init__(self, tmp, data: IRExpr):
    method pp_str (line 247) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 259) | def _from_c(c_stmt):
    method typecheck (line 262) | def typecheck(self, tyenv):
  class Store (line 272) | class Store(IRStmt):
    method __init__ (line 281) | def __init__(self, addr: IRExpr, data: IRExpr, end: str):
    method endness (line 287) | def endness(self):
    method pp_str (line 290) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 294) | def _from_c(c_stmt):
    method typecheck (line 301) | def typecheck(self, tyenv):
  class CAS (line 317) | class CAS(IRStmt):
    method __init__ (line 326) | def __init__(self, addr, dataLo, dataHi, expdLo, expdHi, oldLo, oldHi,...
    method endness (line 337) | def endness(self):
    method pp_str (line 340) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 346) | def _from_c(c_stmt):
    method typecheck (line 358) | def typecheck(self, tyenv):
  class LLSC (line 402) | class LLSC(IRStmt):
    method __init__ (line 412) | def __init__(self, addr: IRExpr, storedata: IRExpr, result: int, end: ...
    method endness (line 419) | def endness(self):
    method pp_str (line 422) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 429) | def _from_c(c_stmt):
    method typecheck (line 437) | def typecheck(self, tyenv):
  class MBE (line 461) | class MBE(IRStmt):
    method __init__ (line 466) | def __init__(self, event):
    method pp_str (line 469) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 473) | def _from_c(c_stmt):
  class Dirty (line 477) | class Dirty(IRStmt):
    method __init__ (line 482) | def __init__(self, cee, guard, args, tmp, mFx, mAddr, mSize, nFxState):
    method pp_str (line 492) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method child_expressions (line 498) | def child_expressions(self):
    method _from_c (line 506) | def _from_c(c_stmt):
  class Exit (line 527) | class Exit(IRStmt):
    method __init__ (line 536) | def __init__(self, guard: IRExpr, dst: IRConst, jk: str, offsIP: int):
    method jumpkind (line 543) | def jumpkind(self):
    method pp_str (line 546) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method child_expressions (line 556) | def child_expressions(self):
    method _from_c (line 560) | def _from_c(c_stmt):
    method typecheck (line 568) | def typecheck(self, tyenv):
  class LoadG (line 581) | class LoadG(IRStmt):
    method __init__ (line 590) | def __init__(self, end: str, cvt: str, dst: int, addr: IRExpr, alt: IR...
    method endness (line 606) | def endness(self):
    method pp_str (line 609) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 620) | def _from_c(c_stmt):
    method typecheck (line 630) | def typecheck(self, tyenv):
  class StoreG (line 659) | class StoreG(IRStmt):
    method __init__ (line 668) | def __init__(self, end, addr, data, guard):
    method endness (line 675) | def endness(self):
    method pp_str (line 678) | def pp_str(self, reg_name=None, arch=None, tyenv=None):
    method _from_c (line 682) | def _from_c(c_stmt):
    method typecheck (line 690) | def typecheck(self, tyenv):
  function tag_to_stmt_class (line 729) | def tag_to_stmt_class(tag):
  function enum_to_stmt_class (line 736) | def enum_to_stmt_class(tag_enum):

FILE: pyvex/types.py
  class Register (line 6) | class Register(Protocol):
  class Arch (line 14) | class Arch(Protocol):
    method translate_register_name (line 28) | def translate_register_name(self, offset: int, size: int | None = None...
    method get_register_offset (line 30) | def get_register_offset(self, name: str) -> int: ...
  class LibvexArch (line 34) | class LibvexArch(Protocol):

FILE: pyvex/utils.py
  function stable_hash (line 14) | def stable_hash(t: tuple) -> int:
  function _dump_tuple (line 20) | def _dump_tuple(t: tuple) -> bytes:
  function _dump_str (line 33) | def _dump_str(t: str) -> bytes:
  function _dump_int (line 37) | def _dump_int(t: int) -> bytes:
  function _dump_type (line 54) | def _dump_type(t: type) -> bytes:

FILE: pyvex_c/analysis.c
  function remove_noops (line 16) | void remove_noops(
  function get_exits_and_inst_addrs (line 38) | void get_exits_and_inst_addrs(
  function get_default_exit_target (line 72) | void get_default_exit_target(
  function Addr (line 184) | Addr get_value_from_const_expr(
  type HashHW (line 209) | typedef
  function HashHW (line 219) | static HashHW* newHHW()
  function freeHHW (line 230) | static void freeHHW(HashHW* h)
  function Bool (line 241) | static Bool lookupHHW(HashHW* h, /*OUT*/HWord* val, HWord key)
  function addToHHW (line 258) | static void addToHHW(HashHW* h, HWord key, HWord val)
  function removeFromHHW (line 302) | static void removeFromHHW(HashHW* h, HWord key)
  function UInt (line 317) | static UInt mk_key_GetPut ( Int offset, IRType ty )
  function record_data_reference (line 326) | void record_data_reference(
  function Addr (line 345) | Addr get_const_and_record(
  function record_tmp_value (line 371) | void record_tmp_value(
  type TmpValue (line 387) | typedef struct {
  type Region (line 393) | typedef struct {
  function find_region (line 404) | static int find_region(ULong start)
  function Bool (line 426) | Bool register_readonly_region(ULong start, ULong size, unsigned char* co...
  function deregister_all_readonly_regions (line 470) | void deregister_all_readonly_regions()
  function Bool (line 476) | Bool load_value(ULong addr, int size, int endness, void *value) {
  type InitialReg (line 534) | typedef struct _InitialReg {
  function Bool (line 543) | Bool register_initial_register_value(UInt offset, UInt size, ULong value)
  function Bool (line 564) | Bool reset_initial_register_values()
  function execute_irsb (line 571) | void execute_irsb(
  function get_is_noop_block (line 930) | void get_is_noop_block(

FILE: pyvex_c/e4c_lite.h
  type e4c_exception_type (line 33) | struct e4c_exception_type{
  type e4c_exception (line 48) | struct e4c_exception{
  type e4c_stage (line 72) | enum e4c_stage{e4c_beginning, e4c_trying, e4c_catching, e4c_finalizing, ...
  type e4c_context (line 73) | struct e4c_context{jmp_buf jump[E4C_MAX_FRAMES]; struct e4c_exception er...
  type e4c_exception_type (line 76) | struct e4c_exception_type
  type e4c_exception_type (line 76) | struct e4c_exception_type
  type e4c_exception_type (line 77) | struct e4c_exception_type

FILE: pyvex_c/logging.c
  function pyvex_debug (line 11) | void pyvex_debug(const char *fmt, ...)
  function pyvex_info (line 24) | void pyvex_info(const char *fmt, ...)
  function pyvex_error (line 37) | void pyvex_error(const char *fmt, ...)

FILE: pyvex_c/postprocess.c
  function arm_post_processor_determine_calls (line 27) | void arm_post_processor_determine_calls(
  function mips32_post_processor_fix_unconditional_exit (line 270) | void mips32_post_processor_fix_unconditional_exit(
  function irsb_insert (line 318) | void irsb_insert(IRSB *irsb, IRStmt* stmt, Int i) {
  function zero_division_side_exits (line 328) | void zero_division_side_exits(IRSB *irsb) {

FILE: pyvex_c/pyvex.c
  function failure_exit (line 58) | __declspec(noreturn)
  function log_bytes (line 66) | static void log_bytes(const HChar* bytes, SizeT nbytes) {
  function clear_log (line 82) | void clear_log() {
  function Bool (line 91) | static Bool chase_into_ok(void *closureV, Addr addr64) {
  function UInt (line 95) | static UInt needs_self_check(void *callback_opaque, VexRegisterUpdates* ...
  function vex_init (line 108) | int vex_init() {
  function vex_prepare_vai (line 225) | static void vex_prepare_vai(VexArch arch, VexArchInfo *vai) {
  function vex_prepare_vbi (line 289) | static void vex_prepare_vbi(VexArch arch, VexAbiInfo *vbi) {
  function VEXLiftResult (line 313) | VEXLiftResult *vex_lift(

FILE: pyvex_c/pyvex.h
  type ExitInfo (line 22) | typedef struct _ExitInfo {
  type DataRefTypes (line 28) | typedef enum {
  type DataRef (line 35) | typedef struct _DataRef {
  type ConstVal (line 43) | typedef struct _ConstVal {
  type VEXLiftResult (line 53) | typedef struct _VEXLiftResult {

FILE: tests/test_arm_postprocess.py
  function test_arm_postprocess_call (line 7) | def test_arm_postprocess_call():
  function test_arm_postprocess_ret (line 333) | def test_arm_postprocess_ret():

FILE: tests/test_gym.py
  class Tests (line 7) | class Tests(unittest.TestCase):
    method test_x86_aam (line 8) | def test_x86_aam(self):
    method test_x86_aad (line 13) | def test_x86_aad(self):
    method test_x86_xgetbv (line 18) | def test_x86_xgetbv(self):
    method test_x86_rdmsr (line 23) | def test_x86_rdmsr(self):

FILE: tests/test_irsb_property_caching.py
  class TestCacheInvalidationOnExtend (line 7) | class TestCacheInvalidationOnExtend(unittest.TestCase):
    method test_cache_invalidation_on_extend (line 8) | def test_cache_invalidation_on_extend(self):

FILE: tests/test_lift.py
  class TestLift (line 11) | class TestLift(unittest.TestCase):
    method test_partial_lift (line 12) | def test_partial_lift(self):
    method test_skipstmts_toomanyexits (line 34) | def test_skipstmts_toomanyexits(self):
    method test_max_bytes (line 69) | def test_max_bytes(self):

FILE: tests/test_mips32_postprocess.py
  function test_mips32_unconditional_jumps (line 4) | def test_mips32_unconditional_jumps():

FILE: tests/test_pyvex.py
  class TestPyvex (line 17) | class TestPyvex(unittest.TestCase):
    method test_memory (line 21) | def test_memory(self):
    method test_ircallee (line 63) | def test_ircallee(self):
    method test_irsb_empty (line 73) | def test_irsb_empty(self):
    method test_irsb_arm (line 77) | def test_irsb_arm(self):
    method test_irsb_popret (line 81) | def test_irsb_popret(self):
    method test_two_irsb (line 97) | def test_two_irsb(self):
    method test_irsb_deepCopy (line 106) | def test_irsb_deepCopy(self):
    method test_irsb_addStmt (line 114) | def test_irsb_addStmt(self):
    method test_irsb_tyenv (line 128) | def test_irsb_tyenv(self):
    method test_irstmt_pp (line 146) | def test_irstmt_pp(self):
    method test_irstmt_flat (line 153) | def test_irstmt_flat(self):
    method test_irstmt_imark (line 156) | def test_irstmt_imark(self):
    method test_irstmt_abihint (line 172) | def test_irstmt_abihint(self):
    method test_irstmt_put (line 183) | def test_irstmt_put(self):
    method test_irexpr_puti (line 194) | def test_irexpr_puti(self):
    method test_irstmt_wrtmp (line 206) | def test_irstmt_wrtmp(self):
    method test_irstmt_store (line 215) | def test_irstmt_store(self):
    method test_irstmt_cas (line 226) | def test_irstmt_cas(self):
    method test_irstmt_loadg (line 257) | def test_irstmt_loadg(self):
    method test_irstmt_storeg (line 284) | def test_irstmt_storeg(self):
    method test_irstmt_llsc (line 300) | def test_irstmt_llsc(self):
    method test_irstmt_mbe (line 312) | def test_irstmt_mbe(self):
    method test_irstmt_dirty (line 318) | def test_irstmt_dirty(self):
    method test_irstmt_exit (line 330) | def test_irstmt_exit(self):
    method test_irregarray (line 347) | def test_irregarray(self):
    method helper_const_subtype (line 358) | def helper_const_subtype(self, subtype, tag, value):
    method test_irconst (line 377) | def test_irconst(self):
    method test_irexpr_binder (line 394) | def test_irexpr_binder(self):
    method test_irexpr_geti (line 401) | def test_irexpr_geti(self):
    method test_irexpr_rdtmp (line 411) | def test_irexpr_rdtmp(self):
    method test_irexpr_get (line 419) | def test_irexpr_get(self):
    method test_irexpr_qop (line 425) | def test_irexpr_qop(self):
    method test_irexpr_triop (line 440) | def test_irexpr_triop(self):
    method test_irexpr_binop (line 454) | def test_irexpr_binop(self):
    method test_irexpr_unop (line 467) | def test_irexpr_unop(self):
    method test_irexpr_load (line 477) | def test_irexpr_load(self):
    method test_irexpr_const (line 487) | def test_irexpr_const(self):
    method test_irexpr_ite (line 497) | def test_irexpr_ite(self):
    method test_irexpr_ccall (line 506) | def test_irexpr_ccall(self):

FILE: tests/test_s390x_exrl.py
  function test_s390x_exrl (line 4) | def test_s390x_exrl():

FILE: tests/test_s390x_lochi.py
  function test_s390x_lochi (line 4) | def test_s390x_lochi():

FILE: tests/test_s390x_vl.py
  function test_s390x_vl (line 5) | def test_s390x_vl():

FILE: tests/test_spotter.py
  class Instruction_IMAGINARY (line 11) | class Instruction_IMAGINARY(Instruction):
    method compute_result (line 15) | def compute_result(self):
  class ImaginarySpotter (line 21) | class ImaginarySpotter(GymratLifter):
  function test_basic (line 38) | def test_basic():
  function test_embedded (line 43) | def test_embedded():
  class Instruction_MSR (line 61) | class Instruction_MSR(Instruction):
    method compute_result (line 65) | def compute_result(self):
  class Instruction_CPSIEI (line 71) | class Instruction_CPSIEI(Instruction):
    method compute_result (line 75) | def compute_result(self):
  class Instruction_CPSIEF (line 81) | class Instruction_CPSIEF(Instruction):
    method compute_result (line 85) | def compute_result(self):
  class CortexSpotter (line 91) | class CortexSpotter(GymratLifter):
  function test_tmrs (line 98) | def test_tmrs():
  function test_tmsr (line 108) | def test_tmsr():

FILE: tests/test_ud2.py
  function test_ud2 (line 4) | def test_ud2():