The output Varnode becomes \e free but is not immediately deleted. \param op is the given PcodeOp

\brief Resolve a native constant into an Address If there is a special resolver for the AddrSpace, this is invoked, otherwise basic wordsize conversi

The Action is specified by name. A grouplist must already exist for this name. If the Action doesn't already exist, it will be derived from the \e un

The lock on the data-type of input parameters is set as specified. A \b true value indicates that future analysis will not change the number of input

A prototype model is set, and any parameters added to \b this during analysis will be backed internally. \param m is the prototype model to set \param

\param i is the index of the outgoing edge \param lab is the new edge label

< Clear temporary hold on dead code removal

< Get the \e slot associated with \b this trial

< Return next block to be executed in flow

A particular group is either added or removed from the grouplist defining a particular \e root Action. The \e root Action is then (re)derived from th

As manipulations are made, Cover information gets out of date. A \e dirty flag is used to indicate a particular HighVariable Cover is out-of-date. Th

\brief Clear all bits above given bit Zero extend \b val starting at \b bit \param val is the value to be zero extended \param bit is the index of th

\brief Allocate data objects for a new set of Varnodes \param size is the number of objects to allocate \return a pointer to the array of available V

\return \b true if a transform was applied

Attach the child as an immediate sub-scope of \b this. Take responsibility of the child's memory: the child will be freed when this is freed. \param c

< Clear a range of split points

If \b this pointer has a size of \b sizeOfAltPointer, a smaller (\b sizeOfPointer) pointer data-type is created and assigned to \b this as a subcompon

< Find the owning Scope of a given memory range

< Beginning iterator of child scopes

Sort data-types for the main TypeFactory container. The sort needs to be based on the data-type structure so that an example data-type, constructed o

This handles the common case, of trying to find a join address given a high location and a low location. This may not return an address in the \e join

The given PcodeOp is removed from all internal lists and added to a final \e deadandgone list. The memory is not reclaimed until the whole container i

The indicated Datatype object is removed from this container. Indirect references (via TypeArray TypeStruct etc.) are not affected \param ct is the da

\brief Determine if two boolean Varnodes hold related values The values may be the \e same, or opposite of each other (\e complementary). Otherwise t

Given a list of memory locations, the \e pieces, either find a pre-existing JoinRecord or create a JoinRecord that represents the logical joining of t

Given an address space, like \e stack, that is known to have a base register pointing to it, try to locate the unique Varnode that holds the input val

\brief Find an immediate subfield of \b this data-type Given a byte range within \b this data-type, determine the field it is contained in and pass b

< Return \b true if return value is locked and on the stack

Get the underlying behavior object for this pcode operation. From this object you can determine how the object evaluates inputs to get the output \re

< Set the number of content characters

< Get bits of switch variable consumed by \b this table

Return the size of addresses for the processor's official default space. This space is usually the main RAM databus. \return the size of an address in

< Get the right-most integer contained in the range

Drill down into nested data-types until we get to a data-type that exactly matches the given offset and size, and return this data-type. Any \e union

If \b this RangeList contains the specific address (spaceid,offset), return it \return the containing Range or NULL

< Get maximum offset of the guarded range

< Return \b true if \b this node is a leaf of the tree structure

Both the pcode translation process and the simplification process need access to a pool of temporary registers that can be used for moving data around

\brief Is \b this a prototype for a class method, taking a \e this pointer.

The block is pushed onto the stack of the given priority. \param bl is the block being added to the queue \param depth is the priority to associate wi

< Return \b true if this op is dead

< Return \b true if this starts an instruction

If \b this varnode is produced by an operation with a boolean output, or if it is formally marked with a boolean data-type, return \b true. The parame

< Mark that \b this storage is \e killed-by-call

< Get the outgoing edge index for the given FlowBlock

< Does \b this storage location persist beyond the end of the function?

\brief Return \b true if the fall-thru branch is taken when the boolean input is true

< Return the symbol associated with \b this function

< Return \b true if input parameter recovery analysis is active

< Return \b true if \b this is active

If this method returns \b true, the logical form of this space is truncated from its actual size Pointers may refer to this original size put the most

< Set the model entry for this trial

Add the new BlockBasic to \b this \param fd is the function underlying the basic block \return the new BlockBasic

Create a special \e annotation Varnode that holds a pointer reference to a specific PcodeOp. This is used specifically to let a CPUI_INDIRECT op refe

< Mark PcodeOps paths from the given start

Some spaces are "virtual", like the stack spaces, where addresses are really relative to a base pointer stored in a register, like the stackpointer.

The given PcodeOp is inserted as the \e last op in the basic block except: - MULTIEQUALS in a basic block all occur first - INDIRECTs occur immediatel

Print textual information about this Varnode including a base identifier along with enough size and attribute information to uniquely identify the Var

The Varnode is selected from the \e current function. It is specified as a storage location with info about its defining p-code in parantheses. - `%E

The edge must already exist \param begin is the incoming FlowBlock of the edge \param end is the outgoing FlowBlock

All the properties of the original pointer are preserved, except the size is changed. \param ptr is the original pointer \param newSize is the size of

\brief Get the Scope (and base name) associated with a qualified Symbol name The name is parsed using a \b delimiter that is passed in. The name can

< Reset start of range

< Clear the \e implied mark on this Varnode

< Get the general \e extrapop setting for \b this prototype

This is the main entry point for marking a branch from one block to another as unstructured. \param i is the index of the outgoing edge to mark

< Clear the forcing attribute

< Get the BRANCHIND PcodeOp

The lock of the data-type of the return value is set as specified. A \b true value indicates that future analysis will not change the presence of or t

< Return \b true if this produces/consumes ptrs