Functions — github.com/HexRaysSA/goomba

CodeHub MCPcopy Create free account

hub / github.com/HexRaysSA/goomba / functions

Functions214 in github.com/HexRaysSA/goomba

⨍ Functions 214◇ Types & classes 40

↓ 13 callersMethodminsn_value

-------------------------------------------------------------------------

mcode_emu.hpp:260

↓ 11 callersMethodlookup

-------------------------------------------------------------------------

heuristics.hpp:83

↓ 9 callersMethoddstr

-------------------------------------------------------------------------- The following functions are only place holders.

nonlin_expr.hpp:987

↓ 9 callersMethodsigned_val

-------------------------------------------------------------------------

mcode_emu.hpp:37

↓ 8 callersMethodfind

-------------------------------------------------------------------------

equiv_class.hpp:198

↓ 7 callersFunctioncurtime

------------------------------------------------------------------------- In fact this function is not really needed. The user can simply turn on the

↓ 7 callersMethoddstr

-------------------------------------------------------------------------

linear_exprs.cpp:13

↓ 7 callersFunctionmake_bin

minsn_template.hpp:132

↓ 6 callersFunctionresize_mop

------------------------------------------------------------------------- resize_mop generates a minsn that resizes the source operand (truncates or e

linear_exprs.hpp:27

↓ 4 callersFunctionadd_candidate

--------------------------------------------------------------------------

optimizer.cpp:143

↓ 4 callersMethodminsn_to_expr

--------------------------------------------------------------------------

smt_convert.cpp:53

↓ 4 callersFunctionscore_complexity

------------------------------------------------------------------------- estimates the "complexity" of a given instruction

heuristics.cpp:137

↓ 3 callersMethodto_minsn

-------------------------------------------------------------------------

linear_exprs.cpp:111

↓ 2 callersMethoddump

-------------------------------------------------------------------------- dump the elements in a set of mop_t

nonlin_expr.hpp:939

↓ 2 callersFunctionget_input_mops

heuristics.hpp:153

↓ 2 callersMethodintval64_to_expr

-------------------------------------------------------------------------

smt_convert.hpp:84

↓ 2 callersFunctionmake_un

minsn_template.hpp:125

↓ 2 callersFunctionprobably_equivalent

------------------------------------------------------------------------- runs a battery of random test cases against both expressions to see if they

heuristics.cpp:103

↓ 2 callersFunctionset_cmt

--------------------------------------------------------------------------

optimizer.cpp:22

↓ 2 callersMethodsynthesize

minsn_template.hpp:100

↓ 1 callersFunctionalways_on

-------------------------------------------------------------------------- returns true if the environment variables indicate the plugin should always

↓ 1 callersMethodbv_resize_to_len

-------------------------------------------------------------------------

smt_convert.hpp:70

↓ 1 callersFunctionbv_sz_on_disk

-------------------------------------------------------------------------

↓ 1 callersFunctionbvset_sz_on_disk

-------------------------------------------------------------------------

↓ 1 callersFunctioncheck_and_substitute

--------------------------------------------------------------------------

optimizer.cpp:29

↓ 1 callersFunctioncompare_mops

------------------------------------------------------------

↓ 1 callersFunctioncompute_fingerprint_from_outputs

------------------------------------------------------------------------- output behavior is summarized as a list of uint64's, each corresponding to a

equiv_class.hpp:30

↓ 1 callersMethodcompute_fingerprint_from_serialization

-------------------------------------------------------------------------

equiv_class.hpp:111

↓ 1 callersFunctioncreate_minsns_file

-------------------------------------------------------------------------

↓ 1 callersFunctioncreate_oracle_file

-------------------------------------------------------------------------

↓ 1 callersFunctioncreate_var_mapping

-------------------------------------------------------------------------

equiv_class.cpp:57

↓ 1 callersMethoddstr

-------------------------------------------------------------------------

lin_conj_exprs.hpp:27

↓ 1 callersMethodevaluate

-------------------------------------------------------------------------

linear_exprs.cpp:71

↓ 1 callersFunctionfind_and_print_overlapped_operands

-------------------------------------------------------------------------- To satisfy our curiosity: find and print overlapping operands

↓ 1 callersMethodfind_candidates

-------------------------------------------------------------------------

equiv_class.cpp:64

↓ 1 callersFunctiongen_rand_byte

-------------------------------------------------------------------------

heuristics.cpp:36

↓ 1 callersFunctiongen_rand_mcode_val

-------------------------------------------------------------------------

heuristics.cpp:21

↓ 1 callersFunctiongen_testcase

-------------------------------------------------------------------------

equiv_class.hpp:45

↓ 1 callersFunctionget_binop

-------------------------------------------------------------------------

msynth_parser.hpp:32

↓ 1 callersMethodget_mop_value

heuristics.hpp:120

↓ 1 callersMethodhigh

-------------------------------------------------------------------------

mcode_emu.hpp:64

↓ 1 callersMethodinit_oracle

--------------------------------------------------------------------------

↓ 1 callersFunctionis_linear

-------------------------------------------------------------------------

↓ 1 callersFunctionis_mba

------------------------------------------------------------------------- guesses whether or not the instruction is MBA

heuristics.cpp:52

↓ 1 callersMethodlow

-------------------------------------------------------------------------

mcode_emu.hpp:57

↓ 1 callersFunctionmake_concrete_minsn

------------------------------------------------------------------------- replaces all references to abstract mop_l's with variables from new_vars

equiv_class.cpp:16

↓ 1 callersMethodmop_to_expr

--------------------------------------------------------------------------

smt_convert.cpp:20

↓ 1 callersFunctionmops_overlap

------------------------------------------------------------ 0-no overlap, 1-op1 includes op2, -1-op2 includes op1, 2-partial overlap

↓ 1 callersMethodnew_minsn

-------------------------------------------------------------------------- Six overloaded functions for creating new minsn from mop or sub-minsn. Four

nonlin_expr.hpp:583

↓ 1 callersMethodoptimize_insn

--------------------------------------------------------------------------

optimizer.cpp:151

↓ 1 callersMethodoptimize_insn_recurse

--------------------------------------------------------------------------

optimizer.cpp:114

↓ 1 callersMethodparse_next_expr

msynth_parser.cpp:15

↓ 1 callersMethodprint

--------------------------------------------------------------------------

nonlin_expr.hpp:191

↓ 1 callersFunctionrand64

-------------------------------------------------------------------------

heuristics.cpp:13

↓ 1 callersMethodread_from_file

-------------------------------------------------------------------------

equiv_class.hpp:184

↓ 1 callersMethodsar

-------------------------------------------------------------------------

mcode_emu.hpp:184

↓ 1 callersMethodsdiv

-------------------------------------------------------------------------

mcode_emu.hpp:121

↓ 1 callersMethodsext

-------------------------------------------------------------------------

mcode_emu.hpp:43

↓ 1 callersFunctionskip_proofs

-------------------------------------------------------------------------- check whether or not we should skip the proving step of optimization

optimizer.cpp:16

↓ 1 callersMethodsmod

-------------------------------------------------------------------------

mcode_emu.hpp:151

↓ 1 callersFunctionsubstitute

--------------------------------------------------------------------------

optimizer.hpp:19

↓ 1 callersMethodsuccess

nonlin_expr.hpp:284

↓ 1 callersMethodto_mop

--------------------------------------------------------------------------

nonlin_expr.hpp:170

↓ 1 callersFunctiontrunc

------------------------------------------------------------------------- truncate v to w bytes

mcode_emu.hpp:15

↓ 1 callersFunctionwrite_bv_to_disk

-------------------------------------------------------------------------

↓ 1 callersFunctionwrite_bvset_to_disk

-------------------------------------------------------------------------

↓ 1 callersMethodzext

-------------------------------------------------------------------------

mcode_emu.hpp:50

--------------------------------------------------------------------------

Methodadd_abstract_minsn

------------------------------------------------------------------------- computes the fingerprint of the abstract minsn and adds it to the index

equiv_class.hpp:129

Methodapply_assignment

------------------------------------------------------------------------- each boolean assignment is represented as a uint32, where the nth bit repres

lin_conj_exprs.hpp:67

Methodapply_rm_par

-------------------------------------------------------------------------- Apply rm_par on all sub-expressions of ins. The result is somehow like a le

nonlin_expr.hpp:683

Methodassn_to_minsn

------------------------------------------------------------------------- converts an assignment to the corresponding conjunction. e.g. 0b1101 => x0 &

lin_conj_exprs.hpp:187

Methodbool_to_bv

-------------------------------------------------------------------------

smt_convert.hpp:46

Methodbuild_new_varname

smt_convert.hpp:18

Methodbuild_normal_mba

--------------------------------------------------------------------------

nonlin_expr.hpp:855

Methodbuild_op_set

-------------------------------------------------------------------------- Recursively collect all variables in the sub-instructions of an operand op,

nonlin_expr.hpp:783

Methodbuild_product

--------------------------------------------------------------------------

nonlin_expr.hpp:805

Methodbv2mcode_val

------------------------------------------------------------------------- build a mcode_val from a byte qvector

heuristics.hpp:44

Methodbv_sext_to_len

-------------------------------------------------------------------------

smt_convert.hpp:61

Methodbv_zext_to_len

-------------------------------------------------------------------------

smt_convert.hpp:52

Methodbw_expr_tbl_t

bitwise_expr_lookup_tbl.cpp:14

Functioncallback

-------------------------------------------------------------------------- This callback handles various hexrays events.

Methodcan_eliminate_variable

------------------------------------------------------------------------- returns true if the variable can be eliminated safely i.e. all terms contain

lin_conj_exprs.hpp:263

Methodcheck_size_equal

-------------------------------------------------------------------------

mcode_emu.hpp:28

Methodcompute_coeffs

------------------------------------------------------------------------- the i'th index in output_vals contains the output value corresponding to the

lin_conj_exprs.hpp:85

Methodcompute_fingerprint

------------------------------------------------------------------------- mapping = nullptr means the instruction is abstract (all terminal mops have

equiv_class.hpp:96

Methodcreate_new_z3_var

--------------------------------------------------------------------------

smt_convert.cpp:13

Methoddefault_mops_t

minsn_template.hpp:28

--------------------------------------------------------------------------

nonlin_expr.hpp:90

-------------------------------------------------------------------------

simp_lin_conj_exprs.hpp:75

minsn_template.hpp:50

-------------------------------------------------------------------------- dump a normal mba expression as terms

nonlin_expr.hpp:221

Methodeliminate_variable

------------------------------------------------------------------------- removes the variable from the expression make sure to check can_eliminate_va

lin_conj_exprs.hpp:276

Methodeliminate_variables

------------------------------------------------------------------------- eliminates all variables that are not needed in the expression

lin_conj_exprs.hpp:129

Methodeq_mba_product

-------------------------------------------------------------------------- Check whether two mba products are equivalent. It is used for getting the l

nonlin_expr.hpp:837

Methodequiv_class_finder_lazy_t

------------------------------------------------------------------------- lint -sem(equiv_class_finder_lazy_t::equiv_class_finder_lazy_t, custodial(1)

equiv_class.hpp:223

Methodequiv_class_finder_t

-------------------------------------------------------------------------

equiv_class.hpp:86

Methodeval_trace_to_bit_trace

------------------------------------------------------------------------- returns a bitfield where the i'th bit indicates whether the i'th evaluation

simp_lin_conj_exprs.hpp:41

--------------------------------------------------------------------------

nonlin_expr.hpp:995

-------------------------------------------------------------------------

lin_conj_exprs.hpp:119

next →1–100 of 214, ranked by callers