\brief The lowest level error generated by the decompiler This is the base error for all exceptions thrown by the decompiler. This underived form is

\brief An annotation for a specific collection of hierarchical data This class parallels the XML concept of an \b element. An ElementId describes a

\brief An annotation for a data element to being transferred to/from a stream This class parallels the XML concept of an \b attribute on an element.

\brief An exception throw during the execution of a command Processing of a specific command has started but has reached an error state

\brief A low-level machine address for labelling bytes and data. All data that can be manipulated within the processor reverse engineering model can

Forward declaration

\brief An exception describing a parsing error in a command line Thrown when attempting to parse a command line. Options are missing or are in the w

\brief An error generated while parsing a command or language This error is generated when parsing character data of some form, as in a user command

\brief An exception thrown by the XML parser This object holds the error message as passed to the SAX interface callback and is thrown as a formal ex

\brief A record for caching a Cover intersection test between two HighVariable objects This is just a pair of HighVariable objects that can be used a

\brief A generic recoverable error This error is the most basic form of recoverable error, meaning there is some problem that the user did not take i

\brief A contiguous range of bytes in some address space

This exception is thrown when emulation evaluation of an operator fails for some reason. This can be thrown for either forward or reverse emulation

\brief Class for holding an edge while the underlying graph is being manipulated The original FlowBlock nodes that define the end-points of the edge

\brief An edge in a data-flow path or graph A minimal node for traversing expressions in the data-flow

\brief Exception for bad instruction data This error is thrown when the system cannot decode data for a particular instruction. This usually means t

\brief A class for uniquely labelling and comparing PcodeOps Different PcodeOps generated by a single machine instruction can only be labelled with a

\brief A control-flow edge between blocks (FlowBlock) The edge is owned by the source block and can have FlowBlock::edge_flags labels applied to it.

\brief A class for manipulating integer value ranges. The idea is to have a representation of common sets of values that a varnode might take on in a

\brief An input or output parameter to a p-code injection payload Within the chunk of p-code being injected, this is a placeholder for Varnodes that

\brief Exception thrown when a prototype can't be modeled properly

Class representing a \e term in an additive expression

\brief A (putative) switch variable Varnode and a constraint imposed by a CBRANCH The record constrains a specific Varnode. If the associated CBRANC

\brief An edge between a Varnode and a PcodeOp A DynamicHash is defined on a sub-graph of the data-flow, and this defines an edge in the sub-graph.

\brief A tracked register (Varnode) and the value it contains This is the object returned when querying for tracked registers, via ContextDatabase::g

\brief Description of the indirect effect a sub-function has on a memory range This object applies only to the specific memory range, which is seen f

\brief Encoding information for a single floating-point format This class supports manipulation of a single floating-point encoding. An encoding can

\brief An exception specific to the command line interface

\brief Exception thrown is there are no legal flows to a switch

\brief A description where and how data was loaded from memory This is a generic table description, giving the starting address of the table, the siz

\brief An iterator over SymbolEntry objects in multiple address spaces Given an EntryMap (a rangemap of SymbolEntry objects in a single address space

\brief A register or memory register that may be used to pass a parameter or return value The parameter recovery utilities (see ParamActive) use this

\brief Exception for encountering unimplemented pcode This error is thrown when a particular machine instruction cannot be translated into pcode. Thi

\brief Exception indicating data was not available This exception is thrown when a request for load image data cannot be met, usually because the req

\brief Exception thrown when a function is added more than once to the database Stores off the address of the function, so a handler can recover from

\brief Exception thrown for a thunk mechanism that looks like a jump-table

\brief Describes a (register) storage location and the ways it might be split into lanes

\brief Basic elements of a parameter: address, data-type, properties

\brief Label for describing extent of address range that has been heritaged

\brief A logical value whose storage is split between two Varnodes This is usually a pair of Varnodes \b lo and \b hi holding the least and most sign

\brief Data-type for a storage location when there is no Symbol (yet) Allow a data-type to be fed into a specific storage location. Currently this o

\brief Large scale transformations applied to the varnode/op graph The base for objects that make changes to the syntax tree of a Funcdata The action

\brief Determine active parameters to sub-functions This is the final stage of the parameter recovery process, when a prototype for a sub-function is

\brief Determine which sub-functions have active output Varnodes This is analogous to ActionActiveParam but for sub-function return values.

\brief Assign initial high-level HighVariable objects to each Varnode

\brief Structure control-flow using standard high-level code constructs.

\brief Propagate conditional constants

\brief Search for and remove various forms of redundant CBRANCH operations This action wraps the analysis performed by ConditionalExecution to simpli

\brief Check for constants, with pointer type, that correspond to global symbols

\brief Search for input Varnodes that have been officially provided constant values. This class injects p-code at the beginning of the function if th

\brief Mark COPY operations between Varnodes representing the object as \e non-printing

\brief Database of root Action objects that can be used to transform a function This is a container for Action objects. It also manages \b root Actio

\brief Dead code removal. Eliminate \e dead p-code ops This is a very fine grained algorithm, it detects usage of individual bits within the Varnode

\brief Find a prototype for each sub-function This loads prototype information, if it exists for each sub-function. If no explicit prototype exists,

\brief Eliminate locally constant indirect calls

\brief Remove conditional branches if the condition is constant

\brief Mark Varnodes built out of \e legal parameters Label a varnode with the \b directwrite attribute if: that varnode can trace at least part of i

\brief Remove blocks that do nothing

\brief Replace COPYs from the same source with a single dominant COPY

\brief Attach \e dynamically mapped symbols to Varnodes in time for data-type propagation

\brief Make final attachments of \e dynamically mapped symbols to Varnodes

\brief Define formal link between stack-pointer values before and after sub-function calls. Change to the stack-pointer across a sub-function is call

\brief Perform final organization of the control-flow structure Label unstructured edges, order switch cases, and order disjoint components of the co

\brief Apply any overridden forced gotos

\brief Prepare for data-flow analysis of function parameters If exact prototypes are known for sub-functions, insert the appropriate Varnodes to matc

\brief Prepare for data-flow analysis of function parameters, when recovery isn't required. If the "protorecovery" action group is not enabled, this

\brief A group of actions (generally) applied in sequence This is a a list of Action objects, which are usually applied in sequence. But the behavior

\brief The list of groups defining a \e root Action Any Rule or \e leaf Action belongs to a \b group. This class is a \b grouplist defined by a colle

\brief Build Static Single Assignment (SSA) representation for function

\brief Locate \e shadow Varnodes and adjust them so they are hidden A \b shadow Varnode is an internal copy of another Varnode that a compiler produc

\brief Infer and propagate data-types. Atomic data-types are ordered from \e most specified to \e least specified. This is extended rescursively to a

\brief Calculate the prototype for the function. If the prototype wasn't originally known, the discovered input Varnodes are analyzed to determine a

\brief Check for constants getting written to the stack from \e internal \e storage registers The constant is internal to the compiler and its storag

\brief Find Varnodes with a vectorized lane scheme and attempt to split the lanes The Architecture lists (vector) registers that may be used to perfo

\brief Get rid of registers with trash values. Register locations called \b likely \b trash are read as a side-effect of some instruction the compile

\brief Create symbols for any discovered global variables in the function.

\brief Find \b explicit Varnodes: Varnodes that have an explicit token representing them in the output In the final output of the syntax tree as sour