| ►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 |
| 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 |
| CActionRestartGroup | Action which checks if restart (sub)actions have been generated and restarts itself |
| 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 |
| CActionMarkImplied | Mark all the implied Varnode objects, which will have no explicit token in the output |
| 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) |
| 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 |
| 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 |
| CActionDatabase | Database of root Action objects that can be used to transform a function |
| CActionGroupList | The list of groups defining a root Action |
| CAliasChecker::AddBase | A helper class holding a Varnode pointer reference and a possible index added to it |
| CAddForm | |
| CAddress | A low-level machine address for labelling bytes and data |
| ►CAddressResolver | Abstract class for converting native constants to addresses |
| CSegmentedResolver | A resolver for segmented architectures |
| CAddrLink | |
| ►CAddrSpace | A region where processor data is stored |
| CConstantSpace | Special AddrSpace for representing constants during analysis |
| CFspecSpace | A special space for encoding FuncCallSpecs |
| CIopSpace | Space for storing internal PcodeOp pointers as addresses |
| CJoinSpace | The pool of logically joined variables |
| COtherSpace | Special AddrSpace for special/user-defined address spaces |
| COverlaySpace | An overlay space |
| CSpacebaseSpace | A virtual space stack space |
| CUniqueSpace | The pool of temporary storage registers |
| ►CAddrSpaceManager | A manager for different address spaces |
| ►CArchitecture | Manager for all the major decompiler subsystems |
| CArchitectureGhidra | An implementation of the Architecture interface and connection to a Ghidra client |
| ►CSleighArchitecture | An Architecture that uses the decompiler's native SLEIGH translation engine |
| CBfdArchitecture | Architecture that reads executable files using GNU BFD libraries |
| CRawBinaryArchitecture | Architecture that reads its binary as a raw file |
| CXmlArchitecture | An Architecture that loads executables using an XML format |
| ►CTranslate | The interface to a translation engine for a processor |
| CDummyTranslate | |
| CGhidraTranslate | An implementation of Translate that queries a Ghidra client for p-code information |
| ►CSleighBase | Common core of classes that read or write SLEIGH specification files natively |
| CSleigh | A full SLEIGH engine |
| CSleighCompile | |
| CAddTreeState | Structure for sorting out pointer expression trees |
| CAliasChecker | A light-weight class for analyzing pointers and aliasing on the stack |
| CAncestorRealistic | Helper class for determining if Varnodes can trace their value from a legitimate source |
| ►CArchOption | Base class for options classes that affect the configuration of the Architecture object |
| 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 |
| 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 |
| 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 |
| 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 |
| ►CAssemblyEmit | Abstract class for emitting disassembly to an application |
| CAssemblyRaw | |
| CIfaceAssemblyEmit | Disassembly emitter that prints to a console stream |
| CPrintLanguage::Atom | A single non-operator token emitted by the decompiler |
| CAttributes | The attributes for a single XML element |
| CBlockEdge | A control-flow edge between blocks (FlowBlock) |
| CBlockMap | Helper class for resolving cross-references while deserializing BlockGraph objects |
| CBlockVarnode | Helper class associating a Varnode with the block where it is defined |
| ►CBreakCallBack | A breakpoint object |
| CPrintfCallBack | |
| CPutsCallBack | |
| CTerminateCallBack | |
| ►CBreakTable | A collection of breakpoints for the emulator |
| CBreakTableCallBack | A basic instantiation of a breakpoint table |
| CCallGraph | |
| CCallGraphEdge | |
| CCallGraphNode | |
| ►CCapabilityPoint | Class for automatically registering extension points to the decompiler |
| ►CArchitectureCapability | Abstract extension point for building Architecture objects |
| CBfdArchitectureCapability | Extension point for building a GNU BFD capable Architecture |
| CRawBinaryArchitectureCapability | Extension point for building an Architecture that reads in raw images |
| CXmlArchitectureCapability | Extension for building an XML format capable Architecture |
| ►CGhidraCapability | Registration point and dispatcher for commands sent to the decompiler |
| CGhidraDecompCapability | The core decompiler commands capability |
| ►CIfaceCapability | Groups of console commands that are discovered by the loader |
| CIfaceCodeDataCapability | |
| CIfaceDecompCapability | Interface capability point for all decompiler commands |
| ►CPrintLanguageCapability | Base class for high-level language capabilities |
| CPrintCCapability | Factory and static initializer for the "c-language" back-end to the decompiler |
| CPrintJavaCapability | Factory and static initializer for the "java-language" back-end 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< _type > | A circular buffer template |
| Ccircularqueue< int4 > | |
| Ccircularqueue< TokenSplit > | |
| CCodeUnit | |
| 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 |
| 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 |
| CConditionMarker | A helper class for describing the similarity of the boolean condition between 2 CBRANCH operations |
| CConsistencyChecker | |
| ►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 |
| CConstructor | |
| CConstructState | |
| CConstructTpl | |
| CConstTpl | |
| ►CContentHandler | The SAX interface for parsing XML documents |
| CTreeHandler | A SAX interface implementation for constructing an in-memory DOM model |
| 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 |
| ►CContextChange | |
| CContextCommit | |
| CContextOp | |
| ►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 |
| CContextSet | |
| CCover | A description of the topological scope of a single variable object |
| CCoverBlock | The topological scope of a variable within a basic block |
| CCParse | |
| 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 |
| 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 |
| CTypeEnum | An enumerated Datatype object: an integer with named values |
| CTypeUnicode | The unicode data-type: i.e. wchar |
| CTypeCode | Datatype object representing executable code |
| CTypePointer | Datatype object representing a pointer |
| CTypeSpacebase | Special Datatype object used to describe pointers that index into the symbol table |
| CTypeStruct | A composite Datatype object: A "structure" with component "fields" |
| CTypeVoid | Formal "void" data-type object |
| CDatatypeCompare | Compare two Datatype pointers for equivalence of their description |
| CDatatypeNameCompare | Compare two Datatype pointers: first by name, then by id |
| CDecisionNode | |
| CDecisionProperties | |
| CDisassemblyCache | A container for disassembly context used by the SLEIGH engine |
| CDisassemblyResult | |
| CDocumentStorage | A container for parsed XML documents |
| 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 |
| CDocument | A complete in-memory XML document |
| ►CEmitXml | Base class (and interface) for pretty printing and XML markup of tokens |
| CEmitNoXml | A trivial emitter that outputs syntax straight to the stream |
| CEmitPrettyPrint | A generic source code pretty printer |
| ►CEmulate | A pcode-based emulator interface |
| ►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 |
| CEmulateFunction | A light-weight emulator to calculate switch targets from switch variables |
| CEmulateSnippet | Emulate a snippet of PcodeOps out of a functional context |
| CSymbolEntry::EntryInitData | Initialization data for a SymbolEntry to facilitate a rangemap |
| CSymbolEntry::EntrySubsort | Class for sub-sorting different SymbolEntry objects at the same address |
| CEnumerator | |
| CEqual1Form | |
| CEqual2Form | |
| CEqual3Form | |
| CValueSet::Equation | An external that can be applied to a ValueSet |
| CExprTree | |
| CFieldContext | |
| CFieldQuality | |
| CFileManage | |
| CFileStreamState | |
| CFixedHandle | |
| 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 |
| CBlockBasic | A basic block for p-code operations |
| CBlockCopy | This class is used to mirror the BlockBasic objects in the fixed control-flow graph for a function |
| ►CBlockGraph | A control-flow block built out of sub-components |
| CBlockCondition | Two conditional blocks combined into one conditional using BOOL_AND or BOOL_OR |
| CBlockDoWhile | A loop structure where the condition is checked at the bottom |
| CBlockGoto | A block that terminates with an unstructured (goto) branch to another block |
| CBlockIf | A basic "if" block |
| CBlockInfLoop | An infinite loop structure |
| CBlockList | A series of blocks that execute in sequence |
| CBlockMultiGoto | A block with multiple edges out, at least one of which is an unstructured (goto) branch |
| CBlockSwitch | A structured switch construction |
| CBlockWhileDo | A loop structure where the condition is checked at the top |
| CFlowInfo | A class for generating the control-flow structure for a single function |
| CFuncdata | Container for data structures associated with a single function |
| ►CFuncProto | A function prototype |
| CFuncCallSpecs | A class for analyzing parameters to a sub-function call |
| 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 |
| ►CGhidraCommand | Base class for a command to the decompiler as issued by a Ghidra client |
| CDecompileAt | Command to decompile a specific function |
| CDeregisterProgram | Command to release all resources associated with a Program (executable) in the decompiler |
| CFlushNative | Command to flush all symbols associated with a Program (executable) |
| CRegisterProgram | Command to register a new Program (executable) with the decompiler |
| CSetAction | Command to set the root Action used by the decompiler or toggle output components |
| CSetOptions | Command to toggle options within the decompiler |
| CStructureGraph | Command to structure a control-flow graph |
| CGrammarLexer | |
| CGrammarToken | |
| CGuardRecord | A (putative) switch variable Varnode and a constraint imposed by a CBRANCH |
| CHandleTpl | |
| CHeritage | Manage the construction of Static Single Assignment (SSA) form |
| CHeritageInfo | Information about heritage passes performed for a specific address space |
| CHighEdge | A record for caching a Cover intersection test between two HighVariable objects |
| CHighVariable | A high-level variable modeled as a list of low-level variables, each written once |
| CIdentRec | |
| ►CIfaceCommand | A command that can be executed from the command line |
| ►CIfaceBaseCommand | A root class for a basic set of commands |
| CIfcClosefile | Close command, closing the current bulk output file |
| CIfcEcho | Echo command to echo the current command line to the bulk output stream |
| CIfcHistory | History command to list the most recent successful commands |
| 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 |
| CIfcQuit | Quit command to terminate processing from the given interface |
| ►CIfaceCodeDataCommand | |
| CIfcCodeDataDumpCrossRefs | |
| CIfcCodeDataDumpModelHits | |
| CIfcCodeDataDumpStarts | |
| CIfcCodeDataDumpTargetHits | |
| CIfcCodeDataDumpUnlinked | |
| CIfcCodeDataInit | |
| CIfcCodeDataRun | |
| CIfcCodeDataTarget | |
| CIfaceCommandDummy | A dummy command used during parsing |
| ►CIfaceDecompCommand | Root class for all decompiler specific commands |
| CIfcAddpath | |
| 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 |
| 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 |
| CIfcFlowOverride | Create a control-flow override: override flow <address> branch|call|callreturn|return |
| CIfcForceDec | Mark a constant to be printed in decimal format: force dec <varnode> |
| CIfcForcegoto | Force a branch to be an unstructured goto: force goto <branchaddr> <targetaddr> |
| CIfcForceHex | Mark a constant to be printed in hex format: force hex <varnode> |
| 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> |
| 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 |
| CIfcLoadFile | |
| CIfcLockPrototype | Lock in the current function's prototype: prototype lock |
| CIfcMapaddress | Map a new symbol into the program: map address <address> <typedeclaration> |
| 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> |
| CIfcNameVarnode | Attach a named symbol to a specific Varnode: name varnode <varnode> <name> |
| 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 ... |
| 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> |
| 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 <varname> |
| CIfcRename | Rename a variable: rename <oldname> <newname> |
| CIfcResetActionstats | Reset transform statistics for the decompiler engine: reset actionstats |
| CIfcRestore | |
| CIfcRetype | Change the data-type of a symbol: retype <varname> <typedeclaration> |
| CIfcSave | |
| 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> |
| ►CIfaceData | Data specialized for a particular command module |
| CCodeDataAnalysis | |
| 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 |
| CConsoleCommands | A console command run as part of a test sequence |
| CIfaceTerm | Implement the command-line interface on top of a specific input stream |
| CImportRecord | |
| CIndirectForm | |
| ►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 |
| CInjectContextSleigh | |
| 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 |
| ►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 |
| CExecutablePcodeSleigh | |
| CInjectPayloadDynamic | |
| ►CInjectPayloadGhidra | An injection payload that uses a Ghidra client to generate the p-code ops |
| 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 |
| ►CInjectPayloadSleigh | |
| CInjectPayloadCallfixup | |
| CInjectPayloadCallother | |
| CJoinRecord | A record describing how logical values are split |
| CJoinRecordCompare | Comparator for JoinRecord objects |
| ►CJumpModel | A jump-table execution model |
| CJumpAssisted | A jump-table model assisted by pseudo-op directives in the code |
| ►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 |
| 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 |
| ►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 |
| CLaneDescription | Description of logical lanes within a big Varnode |
| CLanedRegister::LanedIterator | Class for iterating over possible lane sizes |
| CLanedRegister | Describes a (register) storage location and the ways it might be split into lanes |
| CLanguageDescription | Contents of the <language> tag in a .ldefs file |
| CLeafIterator | |
| CLessConstForm | |
| CLessThreeWay | |
| CLoadGuard | Description of a LOAD operation that needs to be guarded |
| ►CLoadImage | An interface into a particular binary executable image |
| CLoadImageBfd | |
| CLoadImageGhidra | An implementation of the LoadImage interface using a Ghidra client as the back-end |
| CLoadImageXml | Implementation of the LoadImage interface using underlying data stored in an XML format |
| CMyLoadImage | |
| CRawLoadImage | A simple raw binary loadimage |
| CLoadImageFunc | A record indicating a function symbol |
| CLoadImageSection | A record describing a section bytes in the executable |
| CLoadTable | A description where and how data was loaded from memory |
| CLocation | |
| CLocationMap | Map object for keeping track of which address ranges have been heritaged |
| CLogicalForm | |
| CLoopBody | A description of the body of a loop |
| ►CLowlevelError | The lowest level error generated by the decompiler |
| CBadDataError | Exception for bad instruction data |
| CDataUnavailError | Exception indicating data was not available |
| CEvaluationError | |
| CJavaError | Exception that mirrors exceptions thrown by the Ghidra client |
| 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 |
| CParamUnassignedError | Exception thrown when a prototype can't be modeled properly |
| CParseError | An error generated while parsing a command or language |
| CRecovError | A generic recoverable error |
| CSleighError | |
| CUnimplError | Exception for encountering unimplemented pcode |
| 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 |
| CMultForm | |
| CNameRecommend | A symbol name recommendation with its associated storage location |
| CNameValue | A parsed name/value pair |
| CPrintLanguage::NodePending | A pending data-flow node; waiting to be placed on the reverse polish notation stack |
| ►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 |
| COpBehaviorNotEqual | CPUI_INT_NOTEQUAL behavior |
| COpBehaviorPiece | CPUI_PIECE behavior |
| COpBehaviorPopcount | CPUI_POPCOUNT behavior |
| COpBehaviorSubpiece | CPUI_SUBPIECE behavior |
| COperandResolve | |
| COpFollow | A simple node used to dynamically define a sequence of operations |
| COptionDatabase | A Dispatcher for possible ArchOption commands |
| COpToken | A token representing an operator in the high-level language |
| COpTpl | |
| COverride | A container of commands that override the decompiler's default behavior for a single function |
| 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) |
| CParameterPieces | Basic elements of a parameter: address, data-type, properties |
| CParamIDAnalysis | |
| ►CParamList | |
| ►CParamListStandard | A standard model for parameters as an ordered list of storage resources |
| CParamListMerged | A union of other input parameter passing models |
| CParamListRegister | An unstructured model for passing input parameters to a function |
| CParamListStandardOut | A standard model for passing back return values from a function |
| CParamMeasure | |
| CParamTrial | A register or memory register that may be used to pass a parameter or return value |
| CParserContext | |
| ►CParserWalker | |
| CParserWalkerChange | |
| CPartialSymbolEntry | A structure for pushing nested fields to the RPN stack |
| Crangemap< _recordtype >::PartIterator | An iterator into the interval map container |
| CPartition | A range of nodes (within the weak topological ordering) that are iterated together |
| Cpartmap< _linetype, _valuetype > | A map from a linear space to value objects |
| Cpartmap< Address, FreeArray > | |
| Cpartmap< Address, TrackedSet > | |
| Cpartmap< Address, uint4 > | |
| CPathMeld | All paths from a (putative) switch variable to the CPUI_BRANCHIND |
| ►CPattern | |
| ►CDisjointPattern | |
| CCombinePattern | |
| CContextPattern | |
| CInstructionPattern | |
| COrPattern | |
| CPatternBlock | |
| ►CPatternEquation | |
| CEquationAnd | |
| CEquationCat | |
| CEquationLeftEllipsis | |
| CEquationOr | |
| CEquationRightEllipsis | |
| COperandEquation | |
| CUnconstrainedEquation | |
| ►CValExpressEquation | |
| CEqualEquation | |
| CGreaterEqualEquation | |
| CGreaterEquation | |
| CLessEqualEquation | |
| CLessEquation | |
| CNotEqualEquation | |
| ►CPatternExpression | |
| ►CBinaryExpression | |
| CAndExpression | |
| CDivExpression | |
| CLeftShiftExpression | |
| CMultExpression | |
| COrExpression | |
| CPlusExpression | |
| CRightShiftExpression | |
| CSubExpression | |
| CXorExpression | |
| ►CPatternValue | |
| CConstantValue | |
| CContextField | |
| CEndInstructionValue | |
| COperandValue | |
| CStartInstructionValue | |
| CTokenField | |
| ►CUnaryExpression | |
| CMinusExpression | |
| CNotExpression | |
| ►CPcodeBuilder | |
| CMacroBuilder | |
| CSleighBuilder | Build p-code from a pre-parsed instruction |
| CPcodeCacher | Class for caching a chunk of p-code, prior to emitting |
| ►CPcodeCompile | |
| CPcodeSnippet | |
| CSleighPcode | |
| CPcodeData | Data for building one p-code instruction |
| ►CPcodeEmit | Abstract class for emitting pcode to an application |
| CDisassemblyEngine | |
| 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 |
| CPcodeRawOut | |
| ►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 |
| CPcodeInjectLibrarySleigh | |
| CPcodeLexer | |
| CPcodeOp | Lowest level operation of the p-code language |
| CPcodeOpBank | Container class for PcodeOps associated with a single function |
| CPcodeOpEdge | Class representing a term in an additive expression |
| CPcodeOpNode | An edge in a data-flow path or graph |
| CPcodeOpRaw | A low-level representation of a single pcode operation |
| CPhiForm | |
| CPreferSplitManager | |
| CPreferSplitRecord | |
| ►CPrintLanguage | The base class API for emitting a high-level language |
| ►CPrintC | The c-language token emitter |
| CPrintJava | The java-language token emitter |
| 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 |
| CParameterBasic | A stand-alone parameter with no backing symbol |
| CParameterSymbol | A parameter with a formal backing Symbol |
| ►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< _recordtype > | An interval map container |
| Crangemap< ScopeMapper > | |
| CRelativeRecord | Class for describing a relative p-code branch destination |
| CPrintLanguage::ReversePolish | An entry on the reverse polish notation (RPN) stack |
| ►CRHSConstant | |
| CConstantAbsolute | |
| CConstantConsumed | |
| CConstantExpression | |
| CConstantHeritageKnown | |
| CConstantIsConstant | |
| CConstantNamed | |
| CConstantNZMask | |
| CConstantOffset | |
| CConstantVarnodeSize | |
| CRtlPair | |
| ►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) |
| 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 |
| CRuleCondNegate | Flip conditions to match structuring cues |
| 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) |
| CRuleDoubleIn | |
| CRuleDoubleLoad | |
| 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 |
| CRuleEmbed | Simplify PIECE intended as embedding: concat(V, sub(W,0)) => W & 0xff | (zext(W) << 8) |
| 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 |
| 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 |
| CRuleGeneric | |
| 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 |
| 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 |
| CRuleOrPredicate | Simplify predication constructions involving the INT_OR operator |
| 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 |
| 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*c, c) => sub(V,0) |
| 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 |
| 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 |
| CRuleSplitFlow | Try to detect and split artificially joined Varnodes |
| 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 or INT_SEXT |
| 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 |
| CRuleCompile | |
| CRuleLexer | |
| ►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 |
| ►CScopeInternal | An in-memory implementation of the Scope interface |
| CScopeGhidraNamespace | A global namespace Scope |
| CScopeLocal | A Symbol scope for local variables of a particular function |
| CScopeMapper | An Address range associated with the symbol Scope that owns it |
| CScoreProtoModel | Class for calculating "goodness of fit" of parameter trials against a prototype model |
| CSectionVector | |
| CSeqNum | A class for uniquely labelling and comparing PcodeOps |
| CShiftForm | |
| CSizePass | Label for describing extent of address range that has been heritaged |
| ►CSleighSymbol | |
| CBitrangeSymbol | |
| CLabelSymbol | |
| CMacroSymbol | |
| CSectionSymbol | |
| CSpaceSymbol | |
| CTokenSymbol | |
| ►CTripleSymbol | |
| ►CFamilySymbol | |
| ►CValueSymbol | |
| CContextSymbol | |
| CNameSymbol | |
| CValueMapSymbol | |
| CVarnodeListSymbol | |
| ►CSpecificSymbol | |
| CEndSymbol | |
| CFlowDestSymbol | |
| CFlowRefSymbol | |
| COperandSymbol | |
| ►CPatternlessSymbol | |
| CEpsilonSymbol | |
| CVarnodeSymbol | |
| CStartSymbol | |
| CSubtableSymbol | |
| CUserOpSymbol | |
| CSourceFileIndexer | Class for recording source file information for SLEIGH constructors |
| CSpaceQuality | |
| CSplitVarnode | |
| CStackEqn | A stack equation |
| CStackSolver | A class that solves for stack-pointer changes across unknown sub-functions |
| CStarQuality | |
| CStringManager::StringData | String data (a sequence of bytes) stored by StringManager |
| ►CStringManager | Storage for decoding and storing strings associated with an address |
| CGhidraStringManager | Implementation of the StringManager that queries through the ghidra client |
| CStringManagerUnicode | An implementation of StringManager that understands terminated unicode strings |
| CSubForm | |
| CSubvariableFlow | Class for shrinking big Varnodes carrying smaller logical values |
| ►CSymbol | The base class for a symbol in a symbol table or scope |
| CEquateSymbol | A Symbol that holds equate information for a constant |
| CExternRefSymbol | A function Symbol referring to an external location |
| CFunctionSymbol | A Symbol representing an executable function |
| CLabSymbol | A Symbol that labels code internal to a function |
| CSymbolCompare | |
| CSymbolCompareName | Comparator for sorting Symbol objects by name |
| CSymbolEntry | A storage location for a particular Symbol |
| CSymbolScope | |
| CSymbolTable | |
| CTargetFeature | |
| CTargetHit | |
| CTermOrder | A class for ordering Varnode terms in an additive expression |
| CToken | |
| CTokenPattern | |
| 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) |
| CTrackedContext | A tracked register (Varnode) and the value it contains |
| ►CTransformManager | Class for splitting larger registers holding smaller logical lanes |
| CLaneDivide | Class for splitting data-flow on laned registers |
| CSplitFlow | Class for splitting up Varnodes that hold 2 logical variables |
| CSubfloatFlow | Class for tracing changes of precision in floating point variables |
| 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 |
| ►CTraverseConstraint | |
| CTraverseCountState | |
| CTraverseDescendState | |
| CTraverseGroupState | |
| CTruncationTag | Object for describing how a space should be truncated |
| CTypeDeclarator | |
| ►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 | Specifies subfields of a structure or what a pointer points to |
| ►CTypeModifier | |
| CArrayModifier | |
| CFunctionModifier | |
| CPointerModifier | |
| ►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 |
| CTypeOpBoolOr | Information about the BOOL_OR op-code |
| CTypeOpBoolXor | Information about the BOOL_XOR op-code |
| CTypeOpEqual | Information about the INT_EQUAL op-code |
| CTypeOpFloatAdd | Information about the FLOAT_ADD op-code |
| CTypeOpFloatDiv | Information about the FLOAT_DIV op-code |
| CTypeOpFloatEqual | Information about the FLOAT_EQUAL 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 |
| CTypeOpFloatNotEqual | Information about the FLOAT_NOTEQUAL op-code |
| CTypeOpFloatSub | Information about the FLOAT_SUB op-code |
| CTypeOpIntAdd | Information about the INT_ADD op-code |
| CTypeOpIntAnd | Information about the INT_AND 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 |
| CTypeOpIntOr | Information about the INT_OR op-code |
| CTypeOpIntRem | Information about the INT_REM op-code |
| CTypeOpIntRight | Information about the INT_RIGHT op-code |
| CTypeOpIntSdiv | Information about the INT_SDIV 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 |
| CTypeOpNotEqual | Information about the INT_NOTEQUAL 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 |
| ►CTypeOpFunc | A generic functional operator |
| CTypeOpExtract | Information about the EXTRACT op-code |
| CTypeOpFloatAbs | Information about the FLOAT_ABS op-code |
| CTypeOpFloatCeil | Information about the FLOAT_CEIL 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 |
| CTypeOpFloatNan | Information about the FLOAT_NAN op-code |
| CTypeOpFloatRound | Information about the FLOAT_ROUND op-code |
| CTypeOpFloatSqrt | Information about the FLOAT_SQRT op-code |
| CTypeOpFloatTrunc | Information about the FLOAT_TRUNC op-code |
| CTypeOpInsert | Information about the INSERT op-code |
| CTypeOpIntCarry | Information about the INT_CARRY op-code |
| CTypeOpIntSborrow | Information about the INT_SBORROW op-code |
| CTypeOpIntScarry | Information about the INT_SCARRY op-code |
| CTypeOpIntSext | Information about the INT_SEXT op-code |
| CTypeOpIntZext | Information about the INT_ZEXT op-code |
| CTypeOpPiece | Information about the PIECE op-code |
| CTypeOpPopcount | Information about the POPCOUNT op-code |
| CTypeOpSubpiece | Information about the SUBPIECE op-code |
| CTypeOpIndirect | Information about the INDIRECT op-code |
| CTypeOpLoad | Information about the LOAD op-code |
| CTypeOpMulti | Information about the MULTIEQUAL op-code |
| CTypeOpNew | Information about the NEW 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 |
| ►CTypeOpUnary | A generic unary operator: one input and one output |
| CTypeOpBoolNegate | Information about the BOOL_NEGATE op-code |
| CTypeOpFloatNeg | Information about the FLOAT_NEG op-code |
| CTypeOpInt2Comp | Information about the INT_2COMP op-code |
| CTypeOpIntNegate | Information about the INT_NEGATE op-code |
| CTypeRecommend | Data-type for a storage location when there is no Symbol (yet) |
| CTypeSpecifiers | |
| ►CUnifyConstraint | |
| CConstraintBoolean | |
| CConstraintConstCompare | |
| CConstraintDef | |
| CConstraintDescend | |
| ►CConstraintGroup | |
| CConstraintOr | |
| CConstraintLoneDescend | |
| CConstraintNamedExpression | |
| CConstraintNewOp | |
| CConstraintNewUniqueOut | |
| CConstraintOpcode | |
| CConstraintOpCompare | |
| CConstraintOpCopy | |
| CConstraintOpInput | |
| CConstraintOpInputAny | |
| CConstraintOpOutput | |
| CConstraintOtherInput | |
| CConstraintParamConst | |
| CConstraintParamConstVal | |
| CConstraintRemoveInput | |
| CConstraintSetInput | |
| CConstraintSetInputConstVal | |
| CConstraintSetOpcode | |
| CConstraintVarCompare | |
| CConstraintVarConst | |
| CConstraintVarnodeCopy | |
| CDummyConstConstraint | |
| CDummyOpConstraint | |
| CDummyVarnodeConstraint | |
| CUnifyCPrinter | |
| CUnifyDatatype | |
| CUnifyState | |
| CUnitTest | Simple unit test class |
| 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 |
| CInjectedUserOp | A user defined operation that is injected with other p-code |
| CJumpAssistOp | A user defined p-code op for assisting the recovery of jump tables |
| ►CTermPatternOp | A user defined p-code op that has a dynamically defined procedure |
| CSegmentOp | The segmented address operator |
| CUnspecializedPcodeOp | A user defined p-code op with no specialization |
| ►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 |
| CValueSet | A range of values attached to a Varnode within a data-flow subsystem |
| 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 |
| 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 |
| CVarnodeTpl | |
| CParamMeasure::WalkState | |
| ►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 | |
| CXmlError | An exception thrown by the XML parser |
| CXmlScan | The XML character scanner |
| Cyy_buffer_state | |
| Cyy_trans_info | |
| Cyyalloc | |
| CYYSTYPE | |
