| ►Nghidra | |
| CAction | Large scale transformations applied to the varnode/op graph |
| CActionActiveParam | Determine active parameters to sub-functions |
| CActionActiveReturn | Determine which sub-functions have active output Varnodes |
| CActionAssignHigh | Assign initial high-level HighVariable objects to each Varnode |
| CActionBlockStructure | Structure control-flow using standard high-level code constructs |
| CActionConditionalConst | Propagate conditional constants |
| CActionConditionalExe | Search for and remove various forms of redundant CBRANCH operations |
| CActionConstantPtr | Check for constants, with pointer type, that correspond to global symbols |
| CActionConstbase | Search for input Varnodes that have been officially provided constant values |
| CActionCopyMarker | Mark COPY operations between Varnodes representing the object as non-printing |
| CActionDatabase | Database of root Action objects that can be used to transform a function |
| CActionDeadCode | Dead code removal. Eliminate dead p-code ops |
| CActionDefaultParams | Find a prototype for each sub-function |
| CActionDeindirect | Eliminate locally constant indirect calls |
| CActionDeterminedBranch | Remove conditional branches if the condition is constant |
| CActionDirectWrite | Mark Varnodes built out of legal parameters |
| CActionDominantCopy | Replace COPYs from the same source with a single dominant COPY |
| CActionDoNothing | Remove blocks that do nothing |
| CActionDynamicMapping | Attach dynamically mapped symbols to Varnodes in time for data-type propagation |
| CActionDynamicSymbols | Make final attachments of dynamically mapped symbols to Varnodes |
| CActionExtraPopSetup | Define formal link between stack-pointer values before and after sub-function calls |
| CActionFinalStructure | Perform final organization of the control-flow structure |
| CActionForceGoto | Apply any overridden forced gotos |
| CActionFuncLink | Prepare for data-flow analysis of function parameters |
| CActionFuncLinkOutOnly | Prepare for data-flow analysis of function parameters, when recovery isn't required |
| CActionGroup | A group of actions (generally) applied in sequence |
| CActionGroupList | The list of groups defining a root Action |
| CActionHeritage | Build Static Single Assignment (SSA) representation for function |
| CActionHideShadow | Locate shadow Varnodes and adjust them so they are hidden |
| CActionInferTypes | Infer and propagate data-types |
| CActionInputPrototype | Calculate the prototype for the function |
| CActionLaneDivide | Find Varnodes with a vectorized lane scheme and attempt to split the lanes |
| CActionLikelyTrash | Get rid of registers with trash values |
| CActionMapGlobals | Create symbols for any discovered global variables in the function |
| ►CActionMarkExplicit | Find explicit Varnodes: Varnodes that have an explicit token representing them in the output |
| COpStackElement | This class holds a single entry in a stack used to traverse Varnode expressions |
| ►CActionMarkImplied | Mark all the implied Varnode objects, which will have no explicit token in the output |
| CDescTreeElement | This class holds a single entry in a stack used to forward traverse Varnode expressions |
| CActionMarkIndirectOnly | Mark illegal Varnode inputs used only in CPUI_INDIRECT ops |
| CActionMergeAdjacent | Try to merge an op's input Varnode to its output, if they are at the same storage location |
| CActionMergeCopy | Try to merge the input and output Varnodes of a CPUI_COPY op |
| CActionMergeMultiEntry | Try to merge Varnodes specified by Symbols with multiple SymbolEntrys |
| CActionMergeRequired | Make required Varnode merges as dictated by CPUI_MULTIEQUAL, CPUI_INDIRECT, and addrtied property |
| CActionMergeType | Try to merge Varnodes of the same type (if they don't hold different values at the same time) |
| CActionMultiCse | Perform Common Sub-expression Elimination on CPUI_MULTIEQUAL ops |
| ►CActionNameVars | Choose names for all high-level variables (HighVariables) |
| COpRecommend | This class is a record in a database used to store and lookup potential names |
| CActionNodeJoin | Look for conditional branch expressions that have been split and rejoin them |
| CActionNonzeroMask | Calculate the non-zero mask property on all Varnode objects |
| CActionNormalizeBranches | Flip conditional control-flow so that preferred comparison operators are used |
| CActionNormalizeSetup | Prepare function prototypes for "normalize" simplification |
| CActionOutputPrototype | Set the (already) recovered output data-type as a formal part of the prototype |
| CActionParamDouble | Deal with situations that look like double precision parameters |
| CActionPool | A pool of Rules that apply simultaneously |
| CActionPreferComplement | Attempt to normalize symmetric block structures |
| CActionPrototypeTypes | Lay down locked input and output data-type information |
| CActionPrototypeWarnings | Add warnings for prototypes that aren't modeled properly |
| CActionRedundBranch | Get rid of redundant branches: duplicate edges between the same input and output block |
| CActionRestartGroup | Action which checks if restart (sub)actions have been generated and restarts itself |
| CActionRestrictLocal | Restrict possible range of local variables |
| CActionRestructureHigh | Create symbols that map out the local stack-frame for the function |
| CActionRestructureVarnode | Create symbols that map out the local stack-frame for the function |
| CActionReturnRecovery | Determine data-flow holding the return value of the function |
| CActionReturnSplit | Split the epilog code of the function |
| CActionSegmentize | Make sure pointers into segmented spaces have the correct form |
| CActionSetCasts | Fill-in CPUI_CAST p-code ops as required by the casting strategy |
| CActionShadowVar | Check for one CPUI_MULTIEQUAL input set defining more than one Varnode |
| CActionSpacebase | Mark Varnode objects that hold stack-pointer values and set-up special data-type |
| CActionStackPtrFlow | Analyze change to the stack pointer across sub-function calls |
| CActionStart | Gather raw p-code for a function |
| CActionStartCleanUp | Start clean up after main transform phase |
| CActionStartTypes | Allow type recovery to start happening |
| CActionStop | Do any post-processing after decompilation |
| CActionStructureTransform | Give each control-flow structure an opportunity to make a final transform |
| CActionSwitchNorm | Normalize jump-table construction |
| CActionUnjustifiedParams | Adjust improperly justified parameters |
| CActionUnreachable | Remove unreachable blocks |
| CActionVarnodeProps | Transform based on Varnode properties, such as read-only and volatile |
| CAdditiveEdge | Class representing a term in an additive expression |
| CAddress | A low-level machine address for labelling bytes and data |
| CAddressResolver | Abstract class for converting native constants to addresses |
| CAddrSpace | A region where processor data is stored |
| CAddrSpaceManager | A manager for different address spaces |
| CAddTreeState | Structure for sorting out pointer expression trees |
| ►CAliasChecker | A light-weight class for analyzing pointers and aliasing on the stack |
| CAddBase | A helper class holding a Varnode pointer reference and a possible index added to it |
| ►CAncestorRealistic | Helper class for determining if Varnodes can trace their value from a legitimate source |
| CState | Node in a depth first traversal of ancestors |
| CArchitecture | Manager for all the major decompiler subsystems |
| CArchitectureCapability | Abstract extension point for building Architecture objects |
| CArchitectureGhidra | An implementation of the Architecture interface and connection to a Ghidra client |
| CArchOption | Base class for options classes that affect the configuration of the Architecture object |
| CAssemblyEmit | Abstract class for emitting disassembly to an application |
| CAttributeId | An annotation for a data element to being transferred to/from a stream |
| CAttributes | The attributes for a single XML element |
| CBadDataError | Exception for bad instruction data |
| CBfdArchitecture | Architecture that reads executable files using GNU BFD libraries |
| CBfdArchitectureCapability | Extension point for building a GNU BFD capable Architecture |
| CBlockBasic | A basic block for p-code operations |
| CBlockCondition | Two conditional blocks combined into one conditional using BOOL_AND or BOOL_OR |
| CBlockCopy | This class is used to mirror the BlockBasic objects in the fixed control-flow graph for a function |
| CBlockDoWhile | A loop structure where the condition is checked at the bottom |
| CBlockEdge | A control-flow edge between blocks (FlowBlock) |
| CBlockGoto | A block that terminates with an unstructured (goto) branch to another block |
| CBlockGraph | A control-flow block built out of sub-components |
| CBlockIf | A basic "if" block |
| CBlockInfLoop | An infinite loop structure |
| CBlockList | A series of blocks that execute in sequence |
| CBlockMap | Helper class for resolving cross-references while deserializing BlockGraph objects |
| CBlockMultiGoto | A block with multiple edges out, at least one of which is an unstructured (goto) branch |
| ►CBlockSwitch | A structured switch construction |
| CCaseOrder | A class for annotating and sorting the individual cases of the switch |
| CBlockVarnode | Helper class associating a Varnode with the block where it is defined |
| CBlockWhileDo | A loop structure where the condition is checked at the top |
| CBreakCallBack | A breakpoint object |
| CBreakTable | A collection of breakpoints for the emulator |
| CBreakTableCallBack | A basic instantiation of a breakpoint table |
| CCapabilityPoint | Class for automatically registering extension points to the decompiler |
| CCastStrategy | A strategy for applying type casts |
| CCastStrategyC | Casting strategies that are specific to the C language |
| CCastStrategyJava | Casting strategies that are specific to the Java language |
| CCircleRange | A class for manipulating integer value ranges |
| Ccircularqueue | A circular buffer template |
| CCollapseStructure | Build a code structure from a control-flow graph (BlockGraph) |
| CComment | A comment attached to a specific function and code address |
| CCommentDatabase | An interface to a container of comments |
| CCommentDatabaseGhidra | An implementation of CommentDatabase backed by a Ghidra client |
| CCommentDatabaseInternal | An in-memory implementation of the CommentDatabase API |
| CCommentOrder | Compare two Comment pointers |
| ►CCommentSorter | A class for sorting comments into and within basic blocks |
| CSubsort | The sorting key for placing a Comment within a specific basic block |
| CCompilerTag | Contents of a <compiler> tag in a .ldefs file |
| CConditionalExecution | A class for simplifying a series of conditionally executed statements |
| ►CConditionalJoin | Discover and eliminate split conditions |
| CMergePair | A pair of Varnode objects that have been split (and should be merged) |
| CConditionMarker | A helper class for describing the similarity of the boolean condition between 2 CBRANCH operations |
| ►CConsistencyChecker | Derive Varnode sizes and optimize p-code in SLEIGH Constructors |
| COptimizeRecord | Description of how a temporary register is being used within a Constructor |
| CConsoleCommands | A console command run as part of a test sequence |
| CConstantPool | An interface to the pool of constant objects for byte-code languages |
| CConstantPoolGhidra | An implementation of ConstantPool using a Ghidra client as the backing storage |
| ►CConstantPoolInternal | An implementation of the ConstantPool interface storing records internally in RAM |
| CCheapSorter | A cheap (efficient) placeholder for a reference to a constant pool record |
| CConstantSpace | Special AddrSpace for representing constants during analysis |
| CContentHandler | The SAX interface for parsing XML documents |
| CContextBitRange | Description of a context variable within the disassembly context blob |
| CContextCache | A helper class for caching the active context blob to minimize database lookups |
| CContextDatabase | An interface to a database of disassembly/decompiler context information |
| CContextGhidra | An implementation of a ContextDatabase obtaining context information via a Ghidra client |
| ►CContextInternal | An in-memory implementation of the ContextDatabase interface |
| CFreeArray | A context blob, holding context values across some range of code addresses |
| CCover | A description of the topological scope of a single variable object |
| CCoverBlock | The topological scope of a variable within a basic block |
| CCPoolRecord | A description of a byte-code object referenced by a constant |
| CDatabase | A manager for symbol scopes for a whole executable |
| CDatatype | The base datatype class for the decompiler |
| CDatatypeCompare | Compare two Datatype pointers for equivalence of their description |
| CDatatypeNameCompare | Compare two Datatype pointers: first by name, then by id |
| CDataUnavailError | Exception indicating data was not available |
| CDecoder | A class for reading structured data from a stream |
| CDecoderError | An exception thrown by the XML parser |
| CDecompileAt | Command to decompile a specific function |
| CDeregisterProgram | Command to release all resources associated with a Program (executable) in the decompiler |
| CDisassemblyCache | A container for disassembly context used by the SLEIGH engine |
| CDocument | A complete in-memory XML document |
| CDocumentStorage | A container for parsed XML documents |
| CDuplicateFunctionError | Exception thrown when a function is added more than once to the database |
| CDynamicHash | A hash utility to uniquely identify a temporary Varnode in data-flow |
| CDynamicRecommend | A name recommendation for a particular dynamic storage location |
| CEffectRecord | Description of the indirect effect a sub-function has on a memory range |
| CElement | An XML element. A node in the DOM tree |
| CElementId | An annotation for a specific collection of hierarchical data |
| CEmit | Interface for emitting the Decompiler's formal output: source code |
| CEmitMarkup | Emitter that associates markup with individual tokens |
| CEmitNoMarkup | A trivial emitter that outputs syntax straight to the stream |
| CEmitPrettyPrint | A generic source code pretty printer |
| CEmulate | A pcode-based emulator interface |
| CEmulateFunction | A light-weight emulator to calculate switch targets from switch variables |
| CEmulateMemory | An abstract Emulate class using a MemoryState object as the backing machine state |
| CEmulatePcodeCache | A SLEIGH based implementation of the Emulate interface |
| CEmulatePcodeOp | Emulation based on (existing) PcodeOps and Varnodes |
| CEmulateSnippet | Emulate a snippet of PcodeOps out of a functional context |
| CEncoder | A class for writing structured data to a stream |
| CEquateSymbol | A Symbol that holds equate information for a constant |
| CEvaluationError | |
| CExecutablePcode | A snippet of p-code that can be executed outside of normal analysis |
| CExecutablePcodeGhidra | A p-code script that uses a Ghidra client to generate the p-code ops |
| CExternRefSymbol | A function Symbol referring to an external location |
| CFieldContext | Helper function holding properties of a context field prior to calculating the context layout |
| CFieldQuality | Qualities associated (via parsing) with a token or context field |
| CFloatFormat | Encoding information for a single floating-point format |
| CFloatingEdge | Class for holding an edge while the underlying graph is being manipulated |
| CFlowBlock | Description of a control-flow block containing PcodeOps |
| ►CFlowInfo | A class for generating the control-flow structure for a single function |
| CVisitStat | A helper function describing the number of bytes in a machine instruction and the starting p-code op |
| CFlushNative | Command to flush all symbols associated with a Program (executable) |
| CFspecSpace | A special space for encoding FuncCallSpecs |
| CFuncCallSpecs | A class for analyzing parameters to a sub-function call |
| CFuncdata | Container for data structures associated with a single function |
| CFuncProto | A function prototype |
| CFunctionSymbol | A Symbol representing an executable function |
| CFunctionTestCollection | A collection of tests around a single program/function |
| CFunctionTestProperty | A single property to be searched for in the output of a function decompilation |
| CGhidraCapability | Registration point and dispatcher for commands sent to the decompiler |
| CGhidraCommand | Base class for a command to the decompiler as issued by a Ghidra client |
| CGhidraDecompCapability | The core decompiler commands capability |
| CGhidraStringManager | Implementation of the StringManager that queries through the ghidra client |
| CGhidraTranslate | An implementation of Translate that queries a Ghidra client for p-code information |
| CGuardRecord | A (putative) switch variable Varnode and a constraint imposed by a CBRANCH |
| ►CHeritage | Manage the construction of Static Single Assignment (SSA) form |
| CStackNode | Node for depth-first traversal of stack references |
| CHeritageInfo | Information about heritage passes performed for a specific address space |
| CHighEdge | A record for caching a Cover intersection test between two HighVariable objects |
| CHighIntersectTest | A cache of Cover intersection tests for HighVariables |
| CHighVariable | A high-level variable modeled as a list of low-level variables, each written once |
| CIfaceAssemblyEmit | Disassembly emitter that prints to a console stream |
| CIfaceBaseCommand | A root class for a basic set of commands |
| CIfaceCapability | Groups of console commands that are discovered by the loader |
| CIfaceCommand | A command that can be executed from the command line |
| CIfaceCommandDummy | A dummy command used during parsing |
| CIfaceData | Data specialized for a particular command module |
| CIfaceDecompCapability | Interface capability point for all decompiler commands |
| CIfaceDecompCommand | Root class for all decompiler specific commands |
| CIfaceDecompData | Common data shared by decompiler commands |
| CIfaceError | An exception specific to the command line interface |
| CIfaceExecutionError | An exception throw during the execution of a command |
| CIfaceParseError | An exception describing a parsing error in a command line |
| CIfaceStatus | A generic console mode interface and command executor |
| CIfaceTerm | Implement the command-line interface on top of a specific input stream |
| CIfcAddrrangeLoad | Create a new function at an address: load addr <address> [<funcname>] |
| CIfcAdjustVma | Change the base address of the load image: adjust vma 0xabcd0123 |
| CIfcAnalyzeRange | Run value-set analysis on the current function: analyze range full|partial <varnode> |
| CIfcBreakaction | Set a breakpoint when a Rule or Action executes: break action <actionname> |
| CIfcBreakstart | Set a break point at the start of an Action: break start <actionname> |
| CIfcCallFixup | Add a new call fix-up to the program: fixup call ... |
| CIfcCallGraphBuild | Build the call-graph for the architecture/program: callgraph build |
| CIfcCallGraphBuildQuick | Build the call-graph using quick analysis: callgraph build quick |
| CIfcCallGraphDump | Write the current call-graph to a file: callgraph dump <filename> |
| CIfcCallGraphList | List all functions in leaf order: callgraph list |
| CIfcCallGraphLoad | Load the call-graph from a file: callgraph load <filename> |
| CIfcCallOtherFixup | Add a new callother fix-up to the program: fixup callother ... |
| CIfcCleararch | Clear the current architecture/program: clear architecture |
| CIfcClosefile | Close command, closing the current bulk output file |
| CIfcComment | A comment within a command script: % A comment in a script |
| CIfcCommentInstr | Attach a comment to an address: comment <address> comment text... |
| CIfcContinue | Continue decompilation after a break point: continue |
| CIfcCountPcode | Count p-code in the current function: count pcode |
| CIfcDeadcodedelay | Change when dead code elimination starts: deadcode delay <name> <delay> |
| CIfcDecompile | Decompile the current function: decompile |
| CIfcDump | Display bytes in the load image: dump <address+size> |
| CIfcDumpbinary | Dump a memory to file: binary <address+size> <filename> |
| CIfcDuplicateHash | Check for duplicate hashes in functions: duplicate hash |
| CIfcEcho | Echo command to echo the current command line to the bulk output stream |
| CIfcExecuteTestCommand | Execute a specified range of the test script: `execute test command <#>-<#> |
| CIfcFixupApply | Apply a call-fixup to a particular function: fixup apply <fixup> <function> |
| CIfcFlowOverride | Create a control-flow override: override flow <address> branch|call|callreturn|return |
| CIfcForceDatatypeFormat | Mark constants of a data-type to be printed in a specific format: force datatype <datatype> [hex|dec|oct|bin|char] |
| CIfcForceFormat | Mark a constant to be printed in a specific format: force varnode <varnode> [hex|dec|oct|bin|char] |
| CIfcForcegoto | Force a branch to be an unstructured goto: force goto <branchaddr> <targetaddr> |
| CIfcFuncload | Make a specific function current: load function <functionname> |
| CIfcGlobalAdd | Add a memory range as discoverable global variables: global add <address+size> |
| CIfcGlobalify | Treat all normal memory as discoverable global variables: global spaces |
| CIfcGlobalRegisters | Name global registers: global registers |
| CIfcGlobalRemove | Remove a memory range from discoverable global variables: global remove <address+size> |
| CIfcGraphControlflow | Write a graph representation of control-flow to a file: graph controlflow <filename> |
| CIfcGraphDataflow | Write a graph representation of data-flow to a file: graph dataflow <filename> |
| CIfcGraphDom | Write the forward dominance graph to a file: graph dom <filename> |
| CIfcHistory | History command to list the most recent successful commands |
| CIfcIsolate | Mark a symbol as isolated from speculative merging: isolate <name> |
| CIfcJumpOverride | Provide an overriding jump-table for an indirect branch: override jumptable ... |
| CIfcListaction | List all current actions and rules for the decompiler: list action |
| CIfcListOverride | Display any overrides for the current function: list override |
| CIfcListprototypes | List known prototype models: list prototypes |
| CIfcListTestCommands | List all the script commands in the current test: list test commands |
| CIfcLoadTestFile | Load a datatest environment file: load test <filename> |
| CIfcLockPrototype | Lock in the current function's prototype: prototype lock |
| CIfcMapaddress | Map a new symbol into the program: map address <address> <typedeclaration> |
| CIfcMapconvert | Create an convert directive: map convert <format> <value> <address> <hash> |
| CIfcMapexternalref | Create an external ref symbol map externalref <address> <refaddress> [<name>] |
| CIfcMapfunction | Create a new function: map function <address> [<functionname>] [nocode] |
| CIfcMaphash | Add a dynamic symbol to the current function: map hash <address> <hash> <typedeclaration> |
| CIfcMaplabel | Create a code label: map label <name> <address> |
| CIfcMapunionfacet | Create a union field forcing directive: map facet <union> <fieldnum> <address> <hash> |
| CIfcNameVarnode | Attach a named symbol to a specific Varnode: name varnode <varnode> <name> |
| CIfcOpenfile | Open file command to redirect bulk output to a specific file stream |
| CIfcOpenfileAppend | Open file command directing bulk output to be appended to a specific file |
| CIfcOption | Adjust a decompiler option: option <optionname> [<param1>] [<param2>] [<param3>] |
| CIfcParseFile | Parse a file with C declarations: parse file <filename> |
| CIfcParseLine | Parse a line of C syntax: parse line ... |
| CIfcPointerSetting | Create a pointer with additional settings: pointer setting <name> <basetype> offset <val> |
| CIfcPreferSplit | Mark a storage location to be split: prefersplit <address+size> <splitsize> |
| CIfcPrintActionstats | Print transform statistics for the decompiler engine: print actionstats |
| CIfcPrintBlocktree | Print a description of the current functions control-flow: print tree block |
| CIfcPrintCFlat | Print current function without control-flow: print C flat |
| CIfcPrintCGlobals | Print declarations for any known global variables: print C globals |
| CIfcPrintCover | Print cover info about a HighVariable: print cover high <name> |
| CIfcPrintCStruct | Print the current function using C syntax:print C |
| CIfcPrintCTypes | Print any known type definitions: print C types |
| CIfcPrintCXml | Print the current function with C syntax and XML markup:print C xml |
| CIfcPrintdisasm | Print disassembly of a memory range: disassemble [<address1> <address2>] |
| CIfcPrintExtrapop | Print change to stack pointer for called function: print extrapop [<functionname>] |
| CIfcPrintHigh | Display all Varnodes in a HighVariable: print high <name> |
| CIfcPrintInputs | Print info about the current function's input Varnodes: print inputs |
| CIfcPrintInputsAll | Print info about input Varnodes for all functions: print inputs all |
| CIfcPrintLanguage | Print current output using a specific language: print language <langname> |
| CIfcPrintLocalrange | Print range of locals on the stack: print localrange |
| CIfcPrintMap | Print info about a scope/namespace: print map <name> |
| CIfcPrintParamMeasures | Perform parameter-id analysis on the current function: print parammeasures |
| CIfcPrintRaw | Print the raw p-code for the current function: print raw |
| CIfcPrintSpaces | Print all address spaces: print spaces |
| CIfcPrintTree | Print all Varnodes in the current function: print tree varnode |
| CIfcPrintVarnode | Print information about a Varnode: print varnode <varnode> |
| CIfcProduceC | Write decompilation for all functions to a file: produce C <filename> |
| CIfcProducePrototypes | Determine the prototype model for all functions: produce prototypes |
| CIfcProtooverride | Override the prototype of a called function: override prototype <address> <declaration> |
| CIfcQuit | Quit command to terminate processing from the given interface |
| CIfcReadonly | Mark a memory range as read-only: readonly <address+size> |
| CIfcReadSymbols | Read in symbols from the load image: read symbols |
| CIfcRemove | Remove a symbol by name: remove <symbolname> |
| CIfcRename | Rename a variable: rename <oldname> <newname> |
| CIfcResetActionstats | Reset transform statistics for the decompiler engine: reset actionstats |
| CIfcRetype | Change the data-type of a symbol: retype <symbolname> <typedeclaration> |
| CIfcSetcontextrange | Set a context variable: set context <name> <value> [<startaddress> <endaddress>] |
| CIfcSettrackedrange | Set the value of a register: set track <name> <value> [<startaddress> <endaddress>] |
| CIfcSource | Execute a command script : source <filename> |
| CIfcStructureBlocks | Structure an external control-flow graph: structure blocks <infile> <outfile> |
| CIfcTypeVarnode | Attach a typed symbol to a specific Varnode: type varnode <varnode> <typedeclaration> |
| CIfcUnlockPrototype | Unlock the current function's prototype: prototype unlock |
| CIfcVarnodeCover | Print cover information about a Varnode: print cover varnode <varnode> |
| CIfcVarnodehighCover | Print cover info about a HighVariable: print cover varnodehigh <varnode> |
| CIfcVolatile | Mark a memory range as volatile: volatile <address+size> |
| CInjectCallfixupGhidra | A call-fixup injection that uses a Ghidra client to generate the p-code ops |
| CInjectCallotherGhidra | A callother-fixup injection that uses a Ghidra client to generate the p-code ops |
| CInjectContext | Context needed to emit a p-code injection as a full set of p-code operations |
| CInjectContextGhidra | An injection context that can be serialized and sent to the Ghidra client |
| CInjectedUserOp | A user defined operation that is injected with other p-code |
| CInjectParameter | An input or output parameter to a p-code injection payload |
| CInjectPayload | An active container for a set of p-code operations that can be injected into data-flow |
| CInjectPayloadGhidra | An injection payload that uses a Ghidra client to generate the p-code ops |
| CIopSpace | Space for storing internal PcodeOp pointers as addresses |
| CJavaError | Exception that mirrors exceptions thrown by the Ghidra client |
| CJoinRecord | A record describing how logical values are split |
| CJoinRecordCompare | Comparator for JoinRecord objects |
| CJoinSpace | The pool of logically joined variables |
| CJumpAssisted | A jump-table model assisted by pseudo-op directives in the code |
| CJumpAssistOp | A user defined p-code op for assisting the recovery of jump tables |
| CJumpBasic | The basic switch model |
| CJumpBasic2 | A basic jump-table model with an added default address path |
| CJumpBasicOverride | A basic jump-table model incorporating manual override information |
| CJumpModel | A jump-table execution model |
| CJumpModelTrivial | A trivial jump-table model, where the BRANCHIND input Varnode is the switch variable |
| ►CJumpTable | A map from values to control-flow targets within a function |
| CIndexPair | An address table index and its corresponding out-edge |
| CJumptableNotReachableError | Exception thrown is there are no legal flows to a switch |
| CJumptableThunkError | Exception thrown for a thunk mechanism that looks like a jump-table |
| CJumpValues | An iterator over values a switch variable can take |
| CJumpValuesRange | Single entry switch variable that can take a range of values |
| CJumpValuesRangeDefault | A jump-table starting range with two possible execution paths |
| CLabSymbol | A Symbol that labels code internal to a function |
| CLaneDescription | Description of logical lanes within a big Varnode |
| ►CLaneDivide | Class for splitting data-flow on laned registers |
| CWorkNode | Description of a large Varnode that needs to be traced (in the worklist) |
| ►CLanedRegister | Describes a (register) storage location and the ways it might be split into lanes |
| CLanedIterator | Class for iterating over possible lane sizes |
| CLanguageDescription | Contents of the <language> tag in a .ldefs file |
| CLoadGuard | Description of a LOAD operation that needs to be guarded |
| CLoadImage | An interface into a particular binary executable image |
| CLoadImageFunc | A record indicating a function symbol |
| CLoadImageGhidra | An implementation of the LoadImage interface using a Ghidra client as the back-end |
| CLoadImageSection | A record describing a section bytes in the executable |
| CLoadImageXml | Implementation of the LoadImage interface using underlying data stored in an XML format |
| CLoadTable | A description where and how data was loaded from memory |
| CLocationMap | Map object for keeping track of which address ranges have been heritaged |
| CLoopBody | A description of the body of a loop |
| CLowlevelError | The lowest level error generated by the decompiler |
| CMacroBuilder | A class for expanding macro directives within a p-code section |
| CMapIterator | An iterator over SymbolEntry objects in multiple address spaces |
| CMapState | A container for hints about the data-type layout of an address space |
| CMemoryBank | Memory storage/state for a single AddressSpace |
| CMemoryHashOverlay | A memory bank that implements reads and writes using a hash table |
| CMemoryImage | A kind of MemoryBank which retrieves its data from an underlying LoadImage |
| CMemoryPageOverlay | Memory bank that overlays some other memory bank, using a "copy on write" behavior |
| CMemoryState | All storage/state for a pcode machine |
| CMerge | Class for merging low-level Varnodes into high-level HighVariables |
| CNameRecommend | A symbol name recommendation with its associated storage location |
| COpBehavior | Class encapsulating the action/behavior of specific pcode opcodes |
| COpBehaviorBoolAnd | CPUI_BOOL_AND behavior |
| COpBehaviorBoolNegate | CPUI_BOOL_NEGATE behavior |
| COpBehaviorBoolOr | CPUI_BOOL_OR behavior |
| COpBehaviorBoolXor | CPUI_BOOL_XOR behavior |
| COpBehaviorCopy | CPUI_COPY behavior |
| COpBehaviorEqual | CPUI_INT_EQUAL behavior |
| COpBehaviorFloatAbs | CPUI_FLOAT_ABS behavior |
| COpBehaviorFloatAdd | CPUI_FLOAT_ADD behavior |
| COpBehaviorFloatCeil | CPUI_FLOAT_CEIL behavior |
| COpBehaviorFloatDiv | CPUI_FLOAT_DIV behavior |
| COpBehaviorFloatEqual | CPUI_FLOAT_EQUAL behavior |
| COpBehaviorFloatFloat2Float | CPUI_FLOAT_FLOAT2FLOAT behavior |
| COpBehaviorFloatFloor | CPUI_FLOAT_FLOOR behavior |
| COpBehaviorFloatInt2Float | CPUI_FLOAT_INT2FLOAT behavior |
| COpBehaviorFloatLess | CPUI_FLOAT_LESS behavior |
| COpBehaviorFloatLessEqual | CPUI_FLOAT_LESSEQUAL behavior |
| COpBehaviorFloatMult | CPUI_FLOAT_MULT behavior |
| COpBehaviorFloatNan | CPUI_FLOAT_NAN behavior |
| COpBehaviorFloatNeg | CPUI_FLOAT_NEG behavior |
| COpBehaviorFloatNotEqual | CPUI_FLOAT_NOTEQUAL behavior |
| COpBehaviorFloatRound | CPUI_FLOAT_ROUND behavior |
| COpBehaviorFloatSqrt | CPUI_FLOAT_SQRT behavior |
| COpBehaviorFloatSub | CPUI_FLOAT_SUB behavior |
| COpBehaviorFloatTrunc | CPUI_FLOAT_TRUNC behavior |
| COpBehaviorInt2Comp | CPUI_INT_2COMP behavior |
| COpBehaviorIntAdd | CPUI_INT_ADD behavior |
| COpBehaviorIntAnd | CPUI_INT_AND behavior |
| COpBehaviorIntCarry | CPUI_INT_CARRY behavior |
| COpBehaviorIntDiv | CPUI_INT_DIV behavior |
| COpBehaviorIntLeft | CPUI_INT_LEFT behavior |
| COpBehaviorIntLess | CPUI_INT_LESS behavior |
| COpBehaviorIntLessEqual | CPUI_INT_LESSEQUAL behavior |
| COpBehaviorIntMult | CPUI_INT_MULT behavior |
| COpBehaviorIntNegate | CPUI_INT_NEGATE behavior |
| COpBehaviorIntOr | CPUI_INT_OR behavior |
| COpBehaviorIntRem | CPUI_INT_REM behavior |
| COpBehaviorIntRight | CPUI_INT_RIGHT behavior |
| COpBehaviorIntSborrow | CPUI_INT_SBORROW behavior |
| COpBehaviorIntScarry | CPUI_INT_SCARRY behavior |
| COpBehaviorIntSdiv | CPUI_INT_SDIV behavior |
| COpBehaviorIntSext | CPUI_INT_SEXT behavior |
| COpBehaviorIntSless | CPUI_INT_SLESS behavior |
| COpBehaviorIntSlessEqual | CPUI_INT_SLESSEQUAL behavior |
| COpBehaviorIntSrem | CPUI_INT_SREM behavior |
| COpBehaviorIntSright | CPUI_INT_SRIGHT behavior |
| COpBehaviorIntSub | CPUI_INT_SUB behavior |
| COpBehaviorIntXor | CPUI_INT_XOR behavior |
| COpBehaviorIntZext | CPUI_INT_ZEXT behavior |
| COpBehaviorLzcount | CPUI_LZCOUNT behavior |
| COpBehaviorNotEqual | CPUI_INT_NOTEQUAL behavior |
| COpBehaviorPiece | CPUI_PIECE behavior |
| COpBehaviorPopcount | CPUI_POPCOUNT behavior |
| COpBehaviorSubpiece | CPUI_SUBPIECE behavior |
| COptionAliasBlock | Set how locked data-types on the stack affect alias heuristics |
| COptionAllowContextSet | Toggle whether the disassembly engine is allowed to modify context |
| COptionCommentHeader | Toggle whether different comment types are emitted by the decompiler in the header for a function |
| COptionCommentIndent | How many characters to indent comment lines |
| COptionCommentInstruction | Toggle whether different comment types are emitted by the decompiler in the body of a function |
| COptionCommentStyle | Set the style of comment emitted by the decompiler |
| COptionConventionPrinting | Toggle whether the calling convention is printed when emitting function prototypes |
| COptionCurrentAction | Toggle a sub-group of actions within a root Action |
| COptionDatabase | A Dispatcher for possible ArchOption commands |
| COptionDefaultPrototype | Set the default prototype model for analyzing unknown functions |
| COptionErrorReinterpreted | Toggle whether off-cut reinterpretation of an instruction is a fatal error |
| COptionErrorTooManyInstructions | Toggle whether too many instructions in one function body is considered a fatal error |
| COptionErrorUnimplemented | Toggle whether unimplemented instructions are treated as a fatal error |
| COptionExtraPop | Set the extrapop parameter used by the (default) prototype model |
| COptionForLoops | Toggle whether the decompiler attempts to recover for-loop variables |
| COptionHideExtensions | Toggle whether implied extensions (ZEXT or SEXT) are printed |
| COptionIgnoreUnimplemented | Toggle whether unimplemented instructions are treated as a no-operation |
| COptionIndentIncrement | Set the number of characters to indent per nested scope |
| COptionInferConstPtr | Toggle whether the decompiler attempts to infer constant pointers |
| COptionInline | Mark/unmark a specific function as inline |
| COptionInPlaceOps | Toggle whether in-place operators (+=, *=, &=, etc.) are emitted by the decompiler |
| COptionIntegerFormat | Set the formatting strategy used by the decompiler to emit integers |
| COptionJumpLoad | Toggle whether the decompiler should try to recover the table used to evaluate a switch |
| COptionJumpTableMax | Set the maximum number of entries that can be recovered for a single jump table |
| COptionMaxInstruction | Maximum number of instructions that can be processed in a single function |
| COptionMaxLineWidth | Set the maximum number of characters per decompiled line |
| COptionNamespaceStrategy | How should namespace tokens be displayed |
| COptionNoCastPrinting | Toggle whether cast syntax is emitted by the decompiler or stripped |
| COptionNoReturn | Mark/unmark a specific function with the noreturn property |
| COptionNullPrinting | Toggle whether null pointers should be printed as the string "NULL" |
| COptionProtoEval | Set the prototype model to use when evaluating the parameters of the current function |
| COptionReadOnly | Toggle whether read-only memory locations have their value propagated |
| COptionSetAction | Establish a new root Action for the decompiler |
| COptionSetLanguage | Set the current language emitted by the decompiler |
| COptionSplitDatatypes | |
| COptionStructAlign | Alter the "structure alignment" data organization setting |
| COptionToggleRule | Toggle whether a specific Rule is applied in the current Action |
| COptionWarning | Toggle whether a warning should be issued if a specific action/rule is applied |
| COpToken | A token representing an operator in the high-level language |
| COtherSpace | Special AddrSpace for special/user-defined address spaces |
| COverlaySpace | An overlay space |
| COverride | A container of commands that override the decompiler's default behavior for a single function |
| ►CPackedDecode | A byte-based decoder designed to marshal info to the decompiler efficiently |
| CByteChunk | A bounded array of bytes |
| CPosition | An iterator into input stream |
| CPackedEncode | A byte-based encoder designed to marshal from the decompiler efficiently |
| CParamActive | Container class for ParamTrial objects |
| CParamEntry | A contiguous range of memory that can be used to pass parameters |
| ►CParamEntryRange | Class for storing ParamEntry objects in an interval range (rangemap) |
| CInitData | Helper class for initializing ParamEntryRange in a range map |
| CSubsortPosition | Helper class for subsorting on position |
| CParameterBasic | A stand-alone parameter with no backing symbol |
| CParameterPieces | Basic elements of a parameter: address, data-type, properties |
| CParameterSymbol | A parameter with a formal backing Symbol |
| CParamList | |
| CParamListMerged | A union of other input parameter passing models |
| CParamListRegister | An unstructured model for passing input parameters to a function |
| CParamListRegisterOut | A model for passing back return values from a function |
| CParamListStandard | A standard model for parameters as an ordered list of storage resources |
| CParamListStandardOut | A standard model for returning output parameters from a function |
| CParamTrial | A register or memory register that may be used to pass a parameter or return value |
| CParamUnassignedError | Exception thrown when a prototype can't be modeled properly |
| CParseError | An error generated while parsing a command or language |
| CPartialSymbolEntry | A structure for pushing nested fields to the RPN stack |
| CPartition | A range of nodes (within the weak topological ordering) that are iterated together |
| Cpartmap | A map from a linear space to value objects |
| ►CPathMeld | All paths from a (putative) switch variable to the CPUI_BRANCHIND |
| CRootedOp | A PcodeOp in the path set associated with the last Varnode in the intersection |
| CPcodeCacher | Class for caching a chunk of p-code, prior to emitting |
| CPcodeData | Data for building one p-code instruction |
| CPcodeEmit | Abstract class for emitting pcode to an application |
| CPcodeEmitCache | P-code emitter that dumps its raw Varnodes and PcodeOps to an in memory cache |
| CPcodeEmitFd | A p-code emitter for building PcodeOp objects |
| CPcodeInjectLibrary | A collection of p-code injection payloads |
| CPcodeInjectLibraryGhidra | A p-code injection library that uses a Ghidra client to generate/compile the injection p-code |
| CPcodeOp | Lowest level operation of the p-code language |
| CPcodeOpBank | Container class for PcodeOps associated with a single function |
| CPcodeOpNode | An edge in a data-flow path or graph |
| CPcodeOpRaw | A low-level representation of a single pcode operation |
| CPendingBrace | Set of print commands for displaying an open brace '{' and setting a new indent level |
| CPendPrint | Helper class for sending cancelable print commands to an ExitXml |
| CPieceNode | A node in a tree structure of CPUI_PIECE operations |
| CPrintC | The c-language token emitter |
| CPrintCCapability | Factory and static initializer for the "c-language" back-end to the decompiler |
| CPrintJava | The java-language token emitter |
| CPrintJavaCapability | Factory and static initializer for the "java-language" back-end to the decompiler |
| ►CPrintLanguage | The base class API for emitting a high-level language |
| CAtom | A single non-operator token emitted by the decompiler |
| CNodePending | A pending data-flow node; waiting to be placed on the reverse polish notation stack |
| CReversePolish | An entry on the reverse polish notation (RPN) stack |
| CPrintLanguageCapability | Base class for high-level language capabilities |
| CPriorityQueue | Priority queue for the phi-node (MULTIEQUAL) placement algorithm |
| CPropagationState | A class that holds a data-type traversal state during type propagation |
| CProtoModel | A prototype model: a model for passing parameters between functions |
| CProtoModelMerged | A prototype model made by merging together other models |
| CProtoParameter | A function parameter viewed as a name, data-type, and storage address |
| CProtoStore | A collection parameter descriptions making up a function prototype |
| CProtoStoreInternal | A collection of parameter descriptions without backing symbols |
| CProtoStoreSymbol | A collection of parameter descriptions backed by Symbol information |
| CPrototypePieces | Raw components of a function prototype (obtained from parsing source code) |
| CRange | A contiguous range of bytes in some address space |
| CRangeHint | Partial data-type information mapped to a specific range of bytes |
| CRangeList | A disjoint set of Ranges, possibly across multiple address spaces |
| ►Crangemap | An interval map container |
| CAddrRange | The internal sub-range object for the interval map |
| CPartIterator | An iterator into the interval map container |
| CRangeProperties | A partially parsed description of a Range |
| CRawBinaryArchitecture | Architecture that reads its binary as a raw file |
| CRawBinaryArchitectureCapability | Extension point for building an Architecture that reads in raw images |
| CRawLoadImage | A simple raw binary loadimage |
| CRecovError | A generic recoverable error |
| CRegisterProgram | Command to register a new Program (executable) with the decompiler |
| CRelativeRecord | Class for describing a relative p-code branch destination |
| CResolvedUnion | A data-type resolved from an associated TypeUnion or TypeStruct |
| CResolveEdge | A data-flow edge to which a resolved data-type can be assigned |
| CRtlPair | A helper class to associate a named Constructor section with its symbol scope |
| CRule | Class for performing a single transformation on a PcodeOp or Varnode |
| CRule2Comp2Mult | Eliminate INT_2COMP: -V => V * -1 |
| CRule2Comp2Sub | Cleanup: Convert INT_ADD back to INT_SUB: V + -W ==> V - W |
| CRuleAddMultCollapse | Collapse constants in an additive or multiplicative expression |
| CRuleAddUnsigned | Cleanup: Convert INT_ADD of constants to INT_SUB: V + 0xff... => V - 0x00... |
| CRuleAndCommute | Commute INT_AND with INT_LEFT and INT_RIGHT: (V << W) & d => (V & (W >> c)) << c |
| CRuleAndCompare | Simplify INT_ZEXT and SUBPIECE in masked comparison: zext(V) & c == 0 => V & (c & mask) == 0 |
| CRuleAndDistribute | Distribute INT_AND through INT_OR if result is simpler |
| CRuleAndMask | Collapse unnecessary INT_AND |
| CRuleAndOrLump | Collapse constants in logical expressions: (V & c) & d => V & (c & d) |
| CRuleAndPiece | Convert PIECE to INT_ZEXT where appropriate: V & concat(W,X) => zext(X) |
| CRuleAndZext | Convert INT_AND to INT_ZEXT where appropriate: sext(X) & 0xffff => zext(X) |
| CRuleBitUndistribute | Undo distributed operations through INT_AND, INT_OR, and INT_XOR |
| CRuleBooleanNegate | Simplify comparisons with boolean values: V == false => !V, V == true => V |
| CRuleBoolNegate | Apply a set of identities involving BOOL_NEGATE |
| CRuleBoolZext | Simplify boolean expressions of the form zext(V) * -1 |
| CRuleBxor2NotEqual | Eliminate BOOL_XOR: V ^^ W => V != W |
| CRuleCarryElim | Transform INT_CARRY using a constant: carry(V,c) => -c <= V |
| CRuleCollapseConstants | Collapse constant expressions |
| CRuleCollectTerms | Collect terms in a sum: V * c + V * d => V * (c + d) |
| CRuleConcatCommute | Commute PIECE with INT_AND, INT_OR, and INT_XOR |
| CRuleConcatLeftShift | Simplify concatenation of extended value: concat(V, zext(W) << c) => concat( concat(V,W), 0) |
| CRuleConcatShift | Simplify INT_RIGHT canceling PIECE: concat(V,W) >> c => zext(V) |
| CRuleConcatZero | Simplify concatenation with zero: concat(V,0) => zext(V) << c |
| CRuleConcatZext | Commute PIECE with INT_ZEXT: concat(zext(V),W) => zext(concat(V,W)) |
| ►CRuleConditionalMove | Simplify various conditional move situations |
| CBoolExpress | Class for categorizing and rebuilding a boolean expression |
| CRuleCondNegate | Flip conditions to match structuring cues |
| CRuleDivChain | Collapse two consecutive divisions: (x / c1) / c2 => x / (c1*c2) |
| CRuleDivOpt | Convert INT_MULT and shift forms into INT_DIV or INT_SDIV |
| CRuleDivTermAdd | Simplify expressions associated with optimized division expressions |
| CRuleDivTermAdd2 | Simplify another expression associated with optimized division |
| CRuleDoubleArithShift | Simplify two sequential INT_SRIGHT: (x s>> c) s>> d => x s>> saturate(c + d) |
| CRuleDoubleShift | Simplify chained shifts INT_LEFT and INT_RIGHT |
| CRuleDoubleSub | Simplify chained SUBPIECE: sub( sub(V,c), d) => sub(V, c+d) |
| CRuleDumptyHump | Simplify join and break apart: sub( concat(V,W), c) => sub(W,c) |
| CRuleEarlyRemoval | Get rid of unused PcodeOp objects where we can guarantee the output is unused |
| CRuleEqual2Constant | Simplify INT_EQUAL applied to arithmetic expressions |
| CRuleEqual2Zero | Simplify INT_EQUAL applied to 0: 0 == V + W * -1 => V == W or 0 == V + c => V == -c |
| CRuleEquality | Collapse INT_EQUAL and INT_NOTEQUAL: f(V,W) == f(V,W) => true |
| CRuleExtensionPush | Duplicate CPUI_INT_ZEXT and CPUI_INT_SEXT operations if the result is used in multiple pointer calculations |
| CRuleFloatCast | Replace (casttosmall)(casttobig)V with identity or with single cast |
| CRuleFloatRange | Merge range conditions of the form: V f< c, c f< V, V f== c etc |
| CRuleFuncPtrEncoding | Eliminate ARM/THUMB style masking of the low order bits on function pointers |
| CRuleHighOrderAnd | Simplify INT_AND when applied to aligned INT_ADD: (V + c) & 0xfff0 => V + (c & 0xfff0) |
| CRuleHumptyDumpty | Simplify break and rejoin: concat( sub(V,c), sub(V,0) ) => V |
| CRuleHumptyOr | Simplify masked pieces INT_ORed together: (V & ff00) | (V & 00ff) => V |
| CRuleIdentityEl | Collapse operations using identity element: V + 0 => V |
| CRuleIgnoreNan | Treat FLOAT_NAN as always evaluating to false |
| CRuleIndirectCollapse | Remove a CPUI_INDIRECT if its blocking PcodeOp is dead |
| CRuleIntLessEqual | Convert LESSEQUAL to LESS: V <= c => V < (c+1) |
| CRuleLeftRight | Transform canceling INT_RIGHT or INT_SRIGHT of INT_LEFT |
| CRuleLess2Zero | Simplify INT_LESS applied to extremal constants |
| CRuleLessEqual | Simplify 'less than or equal': V < W || V == W => V <= W |
| CRuleLessEqual2Zero | Simplify INT_LESSEQUAL applied to extremal constants |
| CRuleLessNotEqual | Simplify INT_LESSEQUAL && INT_NOTEQUAL: V <= W && V != W => V < W |
| CRuleLessOne | Transform INT_LESS of 0 or 1: V < 1 => V == 0, V <= 0 => V == 0 |
| CRuleLoadVarnode | Convert LOAD operations using a constant offset to COPY |
| CRuleLogic2Bool | Convert logical to boolean operations: V & W => V && W, V | W => V || W |
| CRuleLzcountShiftBool | Simplify equality checks that use lzcount: lzcount(X) >> c => X == 0 if X is 2^c bits wide |
| CRuleModOpt | Simplify expressions that optimize INT_REM and INT_SREM |
| CRuleMultiCollapse | Collapse MULTIEQUAL whose inputs all trace to the same value |
| CRuleMultNegOne | Cleanup: Convert INT_2COMP from INT_MULT: V * -1 => -V |
| CRuleNegateIdentity | Apply INT_NEGATE identities: V & ~V => #0, V | ~V -> #-1 |
| CRuleNegateNegate | Simplify INT_NEGATE chains: ~~V => V |
| CRuleNotDistribute | Distribute BOOL_NEGATE: !(V && W) => !V || !W |
| CRuleOrCollapse | Collapse unnecessary INT_OR |
| CRuleOrConsume | Simply OR with unconsumed input: `V = A | B => V = B if nzm(A) & consume(V) == 0 |
| CRuleOrMask | Simplify INT_OR with full mask: V = W | 0xffff => V = W |
| CRuleOrMultiBool | Simplify boolean expressions that are combined through INT_OR |
| ►CRuleOrPredicate | Simplify predication constructions involving the INT_OR operator |
| CMultiPredicate | A helper class to mark up predicated INT_OR expressions |
| CRulePiece2Sext | Concatenation with sign bits becomes an extension: concat( V s>> #0x1f , V) => sext(V) |
| CRulePiece2Zext | Concatenation with 0 becomes an extension: V = concat(#0,W) => V = zext(W) |
| CRulePiecePathology | Search for concatenations with unlikely things to inform return/parameter consumption calculation |
| CRulePieceStructure | Concatenating structure pieces gets printed as explicit write statements |
| CRulePopcountBoolXor | Simplify boolean expressions that are combined through POPCOUNT |
| CRulePositiveDiv | Signed division of positive values is unsigned division |
| CRulePropagateCopy | Propagate the input of a COPY to all the places that read the output |
| CRulePtraddUndo | Remove PTRADD operations with mismatched data-type information |
| CRulePtrArith | Transform pointer arithmetic |
| CRulePtrFlow | Mark Varnode and PcodeOp objects that are carrying or operating on pointers |
| CRulePtrsubCharConstant | Cleanup: Set-up to print string constants |
| CRulePtrsubUndo | Remove PTRSUB operations with mismatched data-type information |
| CRulePullsubIndirect | Pull-back SUBPIECE through INDIRECT |
| CRulePullsubMulti | Pull SUBPIECE back through MULTIEQUAL |
| CRulePushMulti | Simplify MULTIEQUAL operations where the branches hold the same value |
| CRulePushPtr | Push a Varnode with known pointer data-type to the bottom of its additive expression |
| CRuleRangeMeld | Merge range conditions of the form: V s< c, c s< V, V == c, V != c |
| CRuleRightShiftAnd | Simplify INT_RIGHT and INT_SRIGHT ops where an INT_AND mask becomes unnecessary |
| CRuleSborrow | Simplify signed comparisons using INT_SBORROW |
| CRuleSegment | Propagate constants through a SEGMENTOP |
| CRuleSelectCse | Look for common sub-expressions (built out of a restricted set of ops) |
| CRuleShift2Mult | Convert INT_LEFT to INT_MULT: V << 2 => V * 4 |
| CRuleShiftAnd | Eliminate any INT_AND when the bits it zeroes out are discarded by a shift |
| CRuleShiftBitops | Shifting away all non-zero bits of one-side of a logical/arithmetic op |
| CRuleShiftCompare | Transform shifts in comparisons: V >> c == d => V == (d << c) |
| CRuleShiftPiece | Convert "shift and add" to PIECE: (zext(V) << 16) + zext(W) => concat(V,W) |
| CRuleShiftSub | Simplify SUBPIECE applied to INT_LEFT: sub( V << 8*k, c) => sub(V,c-k) |
| CRuleSignDiv2 | Convert INT_SRIGHT form into INT_SDIV: (V + -1*(V s>> 31)) s>> 1 => V s/ 2 |
| CRuleSignForm | Normalize sign extraction: sub(sext(V),c) => V s>> 31 |
| CRuleSignForm2 | Normalize sign extraction: sub(sext(V) * small,c) s>> 31 => V s>> 31 |
| CRuleSignMod2nOpt | Convert INT_SREM forms: (V + (sign >> (64-n)) & (2^n-1)) - (sign >> (64-n) => V s% 2^n |
| CRuleSignMod2nOpt2 | Convert INT_SREM form: V - (Vadj & ~(2^n-1)) => V s% 2^n |
| CRuleSignMod2Opt | Convert INT_SREM form: (V - sign)&1 + sign => V s% 2 |
| CRuleSignNearMult | Simplify division form: (V + (V s>> 0x1f)>>(32-n)) & (-1<<n) => (V s/ 2^n) * 2^n |
| CRuleSignShift | Normalize sign-bit extraction: V >> 0x1f => (V s>> 0x1f) * -1 |
| CRuleSLess2Zero | Simplify INT_SLESS applied to 0 or -1 |
| CRuleSlessToLess | Convert INT_SLESS to INT_LESS when comparing positive values |
| CRuleSplitCopy | Split COPY ops based on TypePartialStruct |
| CRuleSplitFlow | Try to detect and split artificially joined Varnodes |
| CRuleSplitLoad | Split LOAD ops based on TypePartialStruct |
| CRuleSplitStore | Split STORE ops based on TypePartialStruct |
| CRuleStoreVarnode | Convert STORE operations using a constant offset to COPY |
| CRuleStructOffset0 | Convert a LOAD or STORE to the first element of a structure to a PTRSUB |
| CRuleSub2Add | Eliminate INT_SUB: V - W => V + W * -1 |
| CRuleSubCancel | Simplify composition of SUBPIECE with INT_ZEXT, INT_SEXT, and INT_AND |
| CRuleSubCommute | Commute SUBPIECE operations with earlier operations where possible |
| CRuleSubExtComm | Commute SUBPIECE and INT_ZEXT: sub(zext(V),c) => zext(sub(V,c)) |
| CRuleSubfloatConvert | Perform SubfloatFlow analysis triggered by FLOAT_FLOAT2FLOAT |
| CRuleSubNormal | Pull-back SUBPIECE through INT_RIGHT and INT_SRIGHT |
| CRuleSubRight | Cleanup: Convert truncation to cast: sub(V,c) => sub(V>>c*8,0) |
| CRuleSubvarAnd | Perform SubVariableFlow analysis triggered by INT_AND |
| CRuleSubvarCompZero | Perform SubvariableFlow analysis triggered by testing of a single bit |
| CRuleSubvarSext | Perform SubvariableFlow analysis triggered by INT_SEXT |
| CRuleSubvarShift | Perform SubvariableFlow analysis triggered by INT_RIGHT |
| CRuleSubvarSubpiece | Perform SubVariableFlow analysis triggered by SUBPIECE |
| CRuleSubvarZext | Perform SubvariableFlow analysis triggered by INT_ZEXT |
| CRuleSubZext | Simplify INT_ZEXT applied to SUBPIECE expressions |
| CRuleSwitchSingle | Convert BRANCHIND with only one computed destination to a BRANCH |
| CRuleTermOrder | Order the inputs to commutative operations |
| CRuleTestSign | Convert sign-bit test to signed comparison: (V s>> 0x1f) != 0 => V s< 0 |
| CRuleThreeWayCompare | Simplify expressions involving three-way comparisons |
| CRuleTransformCpool | Transform CPOOLREF operations by looking up the value in the constant pool |
| CRuleTrivialArith | Simplify trivial arithmetic expressions |
| CRuleTrivialBool | Simplify boolean expressions when one side is constant |
| CRuleTrivialShift | Simplify trivial shifts: V << 0 => V, V << #64 => 0 |
| CRuleXorCollapse | Eliminate INT_XOR in comparisons: (V ^ W) == 0 => V == W |
| CRuleXorSwap | Simplify limited chains of XOR operations |
| CRuleZextCommute | Commute INT_ZEXT with INT_RIGHT: zext(V) >> W => zext(V >> W) |
| CRuleZextEliminate | Eliminate INT_ZEXT in comparisons: zext(V) == c => V == c |
| CRuleZextShiftZext | Simplify multiple INT_ZEXT operations: zext( zext(V) << c ) => zext(V) << c |
| CRuleZextSless | Transform INT_ZEXT and INT_SLESS: zext(V) s< c => V < c |
| CScope | A collection of Symbol objects within a single (namespace or functional) scope |
| CScopeGhidra | An implementation of the Scope interface by querying a Ghidra client for Symbol information |
| CScopeGhidraNamespace | A global namespace Scope |
| CScopeInternal | An in-memory implementation of the Scope interface |
| CScopeLocal | A Symbol scope for local variables of a particular function |
| ►CScopeMapper | An Address range associated with the symbol Scope that owns it |
| CNullSubsort | Helper class for not doing any sub-sorting of overlapping ScopeMapper ranges |
| ►CScoreProtoModel | Class for calculating "goodness of fit" of parameter trials against a prototype model |
| CPEntry | A record mapping trials to parameter entries in the prototype model |
| ►CScoreUnionFields | Analyze data-flow to resolve which field of a union data-type is being accessed |
| CTrial | A trial data-type fitted to a specific place in the data-flow |
| CVisitMark | A mark accumulated when a given Varnode is visited with a specific field index |
| CSectionVector | A collection of named p-code sections for a single Constructor |
| CSegmentedResolver | A resolver for segmented architectures |
| CSegmentOp | The segmented address operator |
| CSeqNum | A class for uniquely labelling and comparing PcodeOps |
| CSetAction | Command to set the root Action used by the decompiler or toggle output components |
| CSetOptions | Command to toggle options within the decompiler |
| CSizePass | Label for describing extent of address range that has been heritaged |
| CSleigh | A full SLEIGH engine |
| CSleighArchitecture | An Architecture that uses the decompiler's native SLEIGH translation engine |
| CSleighBase | Common core of classes that read or write SLEIGH specification files natively |
| CSleighBuilder | Build p-code from a pre-parsed instruction |
| CSleighCompile | SLEIGH specification compiling |
| CSleighPcode | Parsing for the semantic section of Constructors |
| CSourceFileIndexer | Class for recording source file information for SLEIGH constructors |
| CSpacebaseSpace | A virtual space stack space |
| CSpaceQuality | Qualities associated (via parsing) with an address space |
| ►CSplitDatatype | Split a p-code COPY, LOAD, or STORE op based on underlying composite data-type |
| CComponent | A helper class describing a pair of matching data-types for the split |
| CRootPointer | A helper class describing the pointer being passed to a LOAD or STORE |
| CSplitFlow | Class for splitting up Varnodes that hold 2 logical variables |
| CStackEqn | A stack equation |
| CStackSolver | A class that solves for stack-pointer changes across unknown sub-functions |
| ►CStringManager | Storage for decoding and storing strings associated with an address |
| CStringData | String data (a sequence of bytes) stored by StringManager |
| CStringManagerUnicode | An implementation of StringManager that understands terminated unicode strings |
| CStructureGraph | Command to structure a control-flow graph |
| CSubfloatFlow | Class for tracing changes of precision in floating point variables |
| ►CSubvariableFlow | Class for shrinking big Varnodes carrying smaller logical values |
| CPatchRecord | Operation with a new logical value as (part of) input, but output Varnode is unchanged |
| CReplaceOp | Placeholder node for PcodeOp operating on smaller logical values |
| CReplaceVarnode | Placeholder node for Varnode holding a smaller logical value |
| CSymbol | The base class for a symbol in a symbol table or scope |
| CSymbolCompareName | Comparator for sorting Symbol objects by name |
| ►CSymbolEntry | A storage location for a particular Symbol |
| CEntryInitData | Initialization data for a SymbolEntry to facilitate a rangemap |
| CEntrySubsort | Class for sub-sorting different SymbolEntry objects at the same address |
| CTermOrder | A class for ordering Varnode terms in an additive expression |
| CTermPatternOp | A user defined p-code op that has a dynamically defined procedure |
| CTokenSplit | A token/command object in the pretty printing stream |
| CToOpEdge | An edge between a Varnode and a PcodeOp |
| ►CTraceDAG | Algorithm for selecting unstructured edges based an Directed Acyclic Graphs (DAG) |
| CBadEdgeScore | Record for scoring a BlockTrace for suitability as an unstructured branch |
| CBlockTrace | A trace of a single path out of a BranchPoint |
| CBranchPoint | |
| CTrackedContext | A tracked register (Varnode) and the value it contains |
| CTransformManager | Class for splitting larger registers holding smaller logical lanes |
| CTransformOp | Placeholder node for PcodeOp that will exist after a transform is applied to a function |
| CTransformVar | Placeholder node for Varnode that will exist after a transform is applied to a function |
| CTranslate | The interface to a translation engine for a processor |
| CTraverseNode | Node for a forward traversal of a Varnode expression |
| CTreeHandler | A SAX interface implementation for constructing an in-memory DOM model |
| CTruncationTag | Object for describing how a space should be truncated |
| CTypeArray | Datatype object representing an array of elements |
| CTypeBase | Base class for the fundamental atomic types |
| CTypeChar | Base type for character data-types: i.e. char |
| CTypeCode | Datatype object representing executable code |
| CTypeEnum | An enumerated Datatype object: an integer with named values |
| CTypeFactory | Container class for all Datatype objects in an Architecture |
| CTypeFactoryGhidra | An implementation of the TypeFactory interface, query a Ghidra client for data-type information |
| CTypeField | A field within a structure or union |
| CTypeOp | Associate data-type and behavior information with a specific p-code op-code |
| CTypeOpBinary | A generic binary operator: two inputs and one output |
| CTypeOpBoolAnd | Information about the BOOL_AND op-code |
| CTypeOpBoolNegate | Information about the BOOL_NEGATE op-code |
| CTypeOpBoolOr | Information about the BOOL_OR op-code |
| CTypeOpBoolXor | Information about the BOOL_XOR op-code |
| CTypeOpBranch | Information about the BRANCH op-code |
| CTypeOpBranchind | Information about the BRANCHIND op-code |
| CTypeOpCall | Information about the CALL op-code |
| CTypeOpCallind | Information about the CALLIND op-code |
| CTypeOpCallother | Information about the CALLOTHER op-code (user defined p-code operations) |
| CTypeOpCast | Information about the CAST op-code |
| CTypeOpCbranch | Information about the CBRANCH op-code |
| CTypeOpCopy | Information about the COPY op-code |
| CTypeOpCpoolref | Information about the CPOOLREF op-code |
| CTypeOpEqual | Information about the INT_EQUAL op-code |
| CTypeOpExtract | Information about the EXTRACT op-code |
| CTypeOpFloatAbs | Information about the FLOAT_ABS op-code |
| CTypeOpFloatAdd | Information about the FLOAT_ADD op-code |
| CTypeOpFloatCeil | Information about the FLOAT_CEIL op-code |
| CTypeOpFloatDiv | Information about the FLOAT_DIV op-code |
| CTypeOpFloatEqual | Information about the FLOAT_EQUAL op-code |
| CTypeOpFloatFloat2Float | Information about the FLOAT_FLOAT2FLOAT op-code |
| CTypeOpFloatFloor | Information about the FLOAT_FLOOR op-code |
| CTypeOpFloatInt2Float | Information about the FLOAT_INT2FLOAT op-code |
| CTypeOpFloatLess | Information about the FLOAT_LESS op-code |
| CTypeOpFloatLessEqual | Information about the FLOAT_LESSEQUAL op-code |
| CTypeOpFloatMult | Information about the FLOAT_MULT op-code |
| CTypeOpFloatNan | Information about the FLOAT_NAN op-code |
| CTypeOpFloatNeg | Information about the FLOAT_NEG op-code |
| CTypeOpFloatNotEqual | Information about the FLOAT_NOTEQUAL op-code |
| CTypeOpFloatRound | Information about the FLOAT_ROUND op-code |
| CTypeOpFloatSqrt | Information about the FLOAT_SQRT op-code |
| CTypeOpFloatSub | Information about the FLOAT_SUB op-code |
| CTypeOpFloatTrunc | Information about the FLOAT_TRUNC op-code |
| CTypeOpFunc | A generic functional operator |
| CTypeOpIndirect | Information about the INDIRECT op-code |
| CTypeOpInsert | Information about the INSERT op-code |
| CTypeOpInt2Comp | Information about the INT_2COMP op-code |
| CTypeOpIntAdd | Information about the INT_ADD op-code |
| CTypeOpIntAnd | Information about the INT_AND op-code |
| CTypeOpIntCarry | Information about the INT_CARRY op-code |
| CTypeOpIntDiv | Information about the INT_DIV op-code |
| CTypeOpIntLeft | Information about the INT_LEFT op-code |
| CTypeOpIntLess | Information about the INT_LESS op-code |
| CTypeOpIntLessEqual | Information about the INT_LESSEQUAL op-code |
| CTypeOpIntMult | Information about the INT_MULT op-code |
| CTypeOpIntNegate | Information about the INT_NEGATE op-code |
| CTypeOpIntOr | Information about the INT_OR op-code |
| CTypeOpIntRem | Information about the INT_REM op-code |
| CTypeOpIntRight | Information about the INT_RIGHT op-code |
| CTypeOpIntSborrow | Information about the INT_SBORROW op-code |
| CTypeOpIntScarry | Information about the INT_SCARRY op-code |
| CTypeOpIntSdiv | Information about the INT_SDIV op-code |
| CTypeOpIntSext | Information about the INT_SEXT op-code |
| CTypeOpIntSless | Information about the INT_SLESS op-code |
| CTypeOpIntSlessEqual | Information about the INT_SLESSEQUAL op-code |
| CTypeOpIntSrem | Information about the INT_SREM op-code |
| CTypeOpIntSright | Information about the INT_SRIGHT op-code |
| CTypeOpIntSub | Information about the INT_SUB op-code |
| CTypeOpIntXor | Information about the INT_XOR op-code |
| CTypeOpIntZext | Information about the INT_ZEXT op-code |
| CTypeOpLoad | Information about the LOAD op-code |
| CTypeOpLzcount | Information about the LZCOUNT op-code |
| CTypeOpMulti | Information about the MULTIEQUAL op-code |
| CTypeOpNew | Information about the NEW op-code |
| CTypeOpNotEqual | Information about the INT_NOTEQUAL op-code |
| CTypeOpPiece | Information about the PIECE op-code |
| CTypeOpPopcount | Information about the POPCOUNT op-code |
| CTypeOpPtradd | Information about the PTRADD op-code |
| CTypeOpPtrsub | Information about the PTRSUB op-code |
| CTypeOpReturn | Information about the RETURN op-code |
| CTypeOpSegment | Information about the SEGMENTOP op-code |
| CTypeOpStore | Information about the STORE op-code |
| CTypeOpSubpiece | Information about the SUBPIECE op-code |
| CTypeOpUnary | A generic unary operator: one input and one output |
| CTypePartialStruct | A data-type that holds part of a TypeStruct or TypeArray |
| CTypePartialUnion | An internal data-type for holding information about a variable's relative position within a union data-type |
| CTypePointer | Datatype object representing a pointer |
| CTypePointerRel | Relative pointer: A pointer with a fixed offset into a specific structure or other data-type |
| CTypeRecommend | Data-type for a storage location when there is no Symbol (yet) |
| CTypeSpacebase | Special Datatype object used to describe pointers that index into the symbol table |
| CTypeStruct | A composite Datatype object: A structure with component fields |
| CTypeUnicode | The unicode data-type: i.e. wchar |
| CTypeUnion | A collection of overlapping Datatype objects: A union of component fields |
| CTypeVoid | Formal "void" data-type object |
| CUnimplError | Exception for encountering unimplemented pcode |
| CUnionFacetSymbol | A Symbol that forces a particular union field at a particular point in the body of a function |
| CUniqueSpace | The pool of temporary storage registers |
| CUnitTest | Simple unit test class |
| CUnknownProtoModel | An unrecognized prototype model |
| CUnspecializedPcodeOp | A user defined p-code op with no specialization |
| CUserOpManage | Manager/container for description objects (UserPcodeOp) of user defined p-code ops |
| CUserPcodeOp | The base class for a detailed definition of a user-defined p-code operation |
| ►CValueSet | A range of values attached to a Varnode within a data-flow subsystem |
| CEquation | An external that can be applied to a ValueSet |
| CValueSetRead | A special form of ValueSet associated with the read point of a Varnode |
| ►CValueSetSolver | Class that determines a ValueSet for each Varnode in a data-flow system |
| CValueSetEdge | An iterator over out-bound edges for a single ValueSet node in a data-flow system |
| ►CVariableGroup | Forward declaration |
| CPieceCompareByOffset | Compare two VariablePiece pointers by offset then by size |
| CVariablePiece | Information about how a HighVariable fits into a larger group or Symbol |
| CVarnode | A low-level variable or contiguous set of bytes described by an Address and a size |
| CVarnodeBank | A container for Varnode objects from a specific function |
| CVarnodeCompareDefLoc | Compare two Varnode pointers by definition then location |
| CVarnodeCompareLocDef | Compare two Varnode pointers by location then definition |
| CVarnodeData | Data defining a specific memory location |
| CVolatileOp | A base class for operations that access volatile memory |
| CVolatileReadOp | An operation that reads from volatile memory |
| CVolatileWriteOp | An operation that writes to volatile memory |
| CWidener | Class holding a particular widening strategy for the ValueSetSolver iteration algorithm |
| CWidenerFull | Class for doing normal widening |
| CWidenerNone | Class for freezing value sets at a specific iteration (to accelerate convergence) |
| CWithBlock | Subtable, pattern, and context information applied across a with block |
| CXmlArchitecture | An Architecture that loads executables using an XML format |
| CXmlArchitectureCapability | Extension for building an XML format capable Architecture |
| CXmlDecode | An XML based decoder |
| CXmlEncode | An XML based encoder |
