| 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 |
| 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 |
| CAddForm | |
| 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 |
| 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) |
| CBlockFor | A loop structure with an initializer list, condition block, and post-body block statement |
| 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 |
| 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 |
| CDecompileAt | Command to decompile a specific function |
| CDeregisterProgram | Command to release all resources associated with a Program (executable) in the decompiler |
| CDisassemblyCache | |
| CDocument | A complete in-memory XML document |
| 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 |
| CEmitNoXml | A trivial emitter that outputs syntax straight to the stream |
| CEmitPrettyPrint | A generic source code pretty printer |
| CEmitXml | Base class (and interface) for pretty printing and XML markup of tokens |
| 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 |
| CEqual1Form | |
| CEqual2Form | |
| CEqual3Form | |
| 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 |
| CFileStreamState | |
| 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 |
| 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 |
| CHighVariable | A high-level variable modeled as a list of low-level variables, each written once |
| CIndirectForm | |
| 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 | |
| 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 |
| CLessConstForm | |
| CLessThreeWay | |
| 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 |
| CLogicalForm | |
| CLoopBody | A description of the body of a loop |
| CLowlevelError | The lowest level error generated by the decompiler |
| 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 |
| 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 |
| COpFollow | A simple node used to dynamically define a sequence of operations |
| 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 |
| 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 | |
| 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 |
| 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 |
| 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 |
| CParamIDAnalysis | |
| CParamList | |
| CParamListMerged | A union of other input parameter passing models |
| CParamListRegister | An unstructured model for passing input parameters to a function |
| CParamListStandard | A standard model for parameters as an ordered list of storage resources |
| CParamListStandardOut | A standard model for passing back return values from a function |
| ►CParamMeasure | |
| CWalkState | |
| 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 | |
| CPcodeData | |
| 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 |
| CPcodeOpEdge | Class representing a term in an additive expression |
| CPcodeOpRaw | A low-level representation of a single pcode operation |
| CPhiForm | |
| ►CPreferSplitManager | |
| CSplitInstance | |
| CPreferSplitRecord | |
| 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 |
| 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 | |
| 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 |
| CBoolExpress | Class for categorizing and rebuilding a boolean expression |
| 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 |
| 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 |
| 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 |
| 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 | |
| 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 |
| 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 |
| CShiftForm | |
| CSizePass | Label for describing extent of address range that has been heritaged |
| CSleigh | |
| 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 | |
| CSpacebaseSpace | A virtual space stack space |
| CSplitFlow | Class for splitting up Varnodes that hold 2 logical variables |
| CSplitVarnode | |
| 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 | |
| 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 |
| CSubForm | |
| ►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 |
| 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 | Specifies subfields of a structure or what a pointer points to |
| 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 |
| 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 |
| CTypePointer | Datatype object representing a pointer |
| 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 |
| CTypeVoid | Formal "void" data-type object |
| CUnimplError | Exception for encountering unimplemented pcode |
| CUniqueSpace | The pool of temporary storage registers |
| 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 |
| 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) |
| CXmlArchitecture | An Architecture that loads executables using an XML format |
| CXmlArchitectureCapability | Extension for building an XML format capable Architecture |
| CXmlError | An exception thrown by the XML parser |
| Cyy_buffer_state | |
| Cyy_trans_info | |
| Cyyalloc | |
| CYYSTYPE | |
