Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12]

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
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
CActionRestartGroup	Action which checks if restart (sub)actions have been generated and restarts itself
CActionRestrictLocal	Restrict possible range of local variables
CActionRestructureHigh	Create symbols that map out the local stack-frame for the function
CActionRestructureVarnode	Create symbols that map out the local stack-frame for the function
CActionReturnRecovery	Determine data-flow holding the return value of the function
CActionReturnSplit	Split the epilog code of the function
CActionSegmentize	Make sure pointers into segmented spaces have the correct form
CActionSetCasts	Fill-in CPUI_CAST p-code ops as required by the casting strategy
CActionShadowVar	Check for one CPUI_MULTIEQUAL input set defining more than one Varnode
CActionSpacebase	Mark Varnode objects that hold stack-pointer values and set-up special data-type
CActionStackPtrFlow	Analyze change to the stack pointer across sub-function calls
CActionStart	Gather raw p-code for a function
CActionStartCleanUp	Start clean up after main transform phase
CActionStartTypes	Allow type recovery to start happening
CActionStop	Do any post-processing after decompilation
CActionStructureTransform	Give each control-flow structure an opportunity to make a final transform
CActionSwitchNorm	Normalize jump-table construction
CActionUnjustifiedParams	Adjust improperly justified parameters
CActionUnreachable	Remove unreachable blocks
CActionVarnodeProps	Transform based on Varnode properties, such as read-only and volatile
CAddForm
CAddress	A low-level machine address for labelling bytes and data
CAddressResolver	Abstract class for converting native constants to addresses
CAddrLink
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
CAndExpression
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
CArrayModifier
CAssemblyEmit	Abstract class for emitting disassembly to an application
CAssemblyRaw
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
CBinaryExpression
CBitrangeSymbol
CBlockBasic	A basic block for p-code operations
CBlockCondition	Two conditional blocks combined into one conditional using BOOL_AND or BOOL_OR
CBlockCopy	This class is used to mirror the BlockBasic objects in the fixed control-flow graph for a function
CBlockDoWhile	A loop structure where the condition is checked at the bottom
CBlockEdge	A control-flow edge between blocks (FlowBlock)
CBlockGoto	A block that terminates with an unstructured (goto) branch to another block
CBlockGraph	A control-flow block built out of sub-components
CBlockIf	A basic "if" block
CBlockInfLoop	An infinite loop structure
CBlockList	A series of blocks that execute in sequence
CBlockMap	Helper class for resolving cross-references while deserializing BlockGraph objects
CBlockMultiGoto	A block with multiple edges out, at least one of which is an unstructured (goto) branch
CBlockSwitch	A structured switch construction
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
CCallGraph
CCallGraphEdge
CCallGraphNode
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
CCodeDataAnalysis
CCodeUnit
CCollapseStructure	Build a code structure from a control-flow graph (BlockGraph)
CCombinePattern
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
CConsoleCommands	A console command run as part of a test sequence
CConstantAbsolute
CConstantConsumed
CConstantExpression
CConstantHeritageKnown
CConstantIsConstant
CConstantNamed
CConstantNZMask
CConstantOffset
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
CConstantSpace	Special AddrSpace for representing constants during analysis
CConstantValue
CConstantVarnodeSize
CConstraintBoolean
CConstraintConstCompare
CConstraintDef
CConstraintDescend
CConstraintGroup
CConstraintLoneDescend
CConstraintNamedExpression
CConstraintNewOp
CConstraintNewUniqueOut
CConstraintOpcode
CConstraintOpCompare
CConstraintOpCopy
CConstraintOpInput
CConstraintOpInputAny
CConstraintOpOutput
CConstraintOr
CConstraintOtherInput
CConstraintParamConst
CConstraintParamConstVal
CConstraintRemoveInput
CConstraintSetInput
CConstraintSetInputConstVal
CConstraintSetOpcode
CConstraintVarCompare
CConstraintVarConst
CConstraintVarnodeCopy
CConstructor
CConstructState
CConstructTpl
CConstTpl
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
CContextChange
CContextCommit
CContextDatabase	An interface to a database of disassembly/decompiler context information
CContextField
CContextGhidra	An implementation of a ContextDatabase obtaining context information via a Ghidra client
CContextInternal	An in-memory implementation of the ContextDatabase interface
CContextOp
CContextPattern
CContextSet
CContextSymbol
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
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
CDecisionNode
CDecisionProperties
CDecompileAt	Command to decompile a specific function
CDeregisterProgram	Command to release all resources associated with a Program (executable) in the decompiler
CDisassemblyCache	A container for disassembly context used by the SLEIGH engine
CDisassemblyEngine
CDisassemblyResult
CDisjointPattern
CDivExpression
CDocument	A complete in-memory XML document
CDocumentStorage	A container for parsed XML documents
CDummyConstConstraint
CDummyOpConstraint
CDummyTranslate
CDummyVarnodeConstraint
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
CEndInstructionValue
CEndSymbol
CEnumerator
CEpsilonSymbol
CEqual1Form
CEqual2Form
CEqual3Form
CEqualEquation
CEquateSymbol	A Symbol that holds equate information for a constant
CEquationAnd
CEquationCat
CEquationLeftEllipsis
CEquationOr
CEquationRightEllipsis
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
CExecutablePcodeSleigh
CExprTree
CExternRefSymbol	A function Symbol referring to an external location
CFamilySymbol
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
CFlowDestSymbol
CFlowInfo	A class for generating the control-flow structure for a single function
CFlowRefSymbol
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
CFunctionModifier
CFunctionSymbol	A Symbol representing an executable function
CFunctionTestCollection	A collection of tests around a single program/function
CFunctionTestProperty	A single property to be searched for in the output of a function decompilation
CGhidraCapability	Registration point and dispatcher for commands sent to the decompiler
CGhidraCommand	Base class for a command to the decompiler as issued by a Ghidra client
CGhidraDecompCapability	The core decompiler commands capability
CGhidraStringManager	Implementation of the StringManager that queries through the ghidra client
CGhidraTranslate	An implementation of Translate that queries a Ghidra client for p-code information
CGrammarLexer
CGrammarToken
CGreaterEqualEquation
CGreaterEquation
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
CIfaceAssemblyEmit	Disassembly emitter that prints to a console stream
CIfaceBaseCommand	A root class for a basic set of commands
CIfaceCapability	Groups of console commands that are discovered by the loader
CIfaceCodeDataCapability
CIfaceCodeDataCommand
CIfaceCommand	A command that can be executed from the command line
CIfaceCommandDummy	A dummy command used during parsing
CIfaceData	Data specialized for a particular command module
CIfaceDecompCapability	Interface capability point for all decompiler commands
CIfaceDecompCommand	Root class for all decompiler specific commands
CIfaceDecompData	Common data shared by decompiler commands
CIfaceError	An exception specific to the command line interface
CIfaceExecutionError	An exception throw during the execution of a command
CIfaceParseError	An exception describing a parsing error in a command line
CIfaceStatus	A generic console mode interface and command executor
CIfaceTerm	Implement the command-line interface on top of a specific input stream
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
CIfcClosefile	Close command, closing the current bulk output file
CIfcCodeDataDumpCrossRefs
CIfcCodeDataDumpModelHits
CIfcCodeDataDumpStarts
CIfcCodeDataDumpTargetHits
CIfcCodeDataDumpUnlinked
CIfcCodeDataInit
CIfcCodeDataRun
CIfcCodeDataTarget
CIfcComment	A comment within a command script: % A comment in a script
CIfcCommentInstr	Attach a comment to an address: comment <address> comment text...
CIfcContinue	Continue decompilation after a break point: continue
CIfcCountPcode	Count p-code in the current function: count pcode
CIfcDeadcodedelay	Change when dead code elimination starts: deadcode delay <name> <delay>
CIfcDecompile	Decompile the current function: decompile
CIfcDump	Display bytes in the load image: dump <address+size>
CIfcDumpbinary	Dump a memory to file: binary <address+size> <filename>
CIfcDuplicateHash	Check for duplicate hashes in functions: duplicate hash
CIfcEcho	Echo command to echo the current command line to the bulk output stream
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>
CIfcHistory	History command to list the most recent successful commands
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>
CIfcOpenfile	Open file command to redirect bulk output to a specific file stream
CIfcOpenfileAppend	Open file command directing bulk output to be appended to a specific file
CIfcOption	Adjust a decompiler option: option <optionname> [<param1>] [<param2>] [<param3>]
CIfcParseFile	Parse a file with C declarations: parse file <filename>
CIfcParseLine	Parse a line of C syntax: parse line ...
CIfcPreferSplit	Mark a storage location to be split: prefersplit <address+size> <splitsize>
CIfcPrintActionstats	Print transform statistics for the decompiler engine: print actionstats
CIfcPrintBlocktree	Print a description of the current functions control-flow: print tree block
CIfcPrintCFlat	Print current function without control-flow: print C flat
CIfcPrintCGlobals	Print declarations for any known global variables: print C globals
CIfcPrintCover	Print cover info about a HighVariable: print cover high <name>
CIfcPrintCStruct	Print the current function using C syntax:print C
CIfcPrintCTypes	Print any known type definitions: print C types
CIfcPrintCXml	Print the current function with C syntax and XML markup:print C xml
CIfcPrintdisasm	Print disassembly of a memory range: disassemble [<address1> <address2>]
CIfcPrintExtrapop	Print change to stack pointer for called function: print extrapop [<functionname>]
CIfcPrintHigh	Display all Varnodes in a HighVariable: print high <name>
CIfcPrintInputs	Print info about the current function's input Varnodes: print inputs
CIfcPrintInputsAll	Print info about input Varnodes for all functions: print inputs all
CIfcPrintLanguage	Print current output using a specific language: print language <langname>
CIfcPrintLocalrange	Print range of locals on the stack: print localrange
CIfcPrintMap	Print info about a scope/namespace: print map <name>
CIfcPrintParamMeasures	Perform parameter-id analysis on the current function: print parammeasures
CIfcPrintRaw	Print the raw p-code for the current function: print raw
CIfcPrintSpaces	Print all address spaces: print spaces
CIfcPrintTree	Print all Varnodes in the current function: print tree varnode
CIfcPrintVarnode	Print information about a Varnode: print varnode <varnode>
CIfcProduceC	Write decompilation for all functions to a file: produce C <filename>
CIfcProducePrototypes	Determine the prototype model for all functions: produce prototypes
CIfcProtooverride	Override the prototype of a called function: override prototype <address> <declaration>
CIfcQuit	Quit command to terminate processing from the given interface
CIfcReadonly	Mark a memory range as read-only: readonly <address+size>
CIfcReadSymbols	Read in symbols from the load image: read symbols
CIfcRemove	Remove a symbol by name: remove <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>
CImportRecord
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
CInjectContextSleigh
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
CInjectPayloadCallfixup
CInjectPayloadCallother
CInjectPayloadDynamic
CInjectPayloadGhidra	An injection payload that uses a Ghidra client to generate the p-code ops
CInjectPayloadSleigh
CInstructionPattern
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
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
CLabelSymbol
CLabSymbol	A Symbol that labels code internal to a function
CLaneDescription	Description of logical lanes within a big Varnode
CLaneDivide	Class for splitting data-flow on laned registers
►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
CLeafIterator
CLeftShiftExpression
CLessConstForm
CLessEqualEquation
CLessEquation
CLessThreeWay
CLoadGuard	Description of a LOAD operation that needs to be guarded
CLoadImage	An interface into a particular binary executable image
CLoadImageBfd
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
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
CMacroBuilder
CMacroSymbol
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
CMinusExpression
CMultExpression
CMultForm
CMyLoadImage
CNameRecommend	A symbol name recommendation with its associated storage location
CNameSymbol
CNameValue	A parsed name/value pair
CNotEqualEquation
CNotExpression
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
COperandEquation
COperandResolve
COperandSymbol
COperandValue
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
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
COpToken	A token representing an operator in the high-level language
COpTpl
COrExpression
COrPattern
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)
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
CParserContext
CParserWalker
CParserWalkerChange
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
CPattern
CPatternBlock
CPatternEquation
CPatternExpression
CPatternlessSymbol
CPatternValue
CPcodeBuilder
CPcodeCacher	Class for caching a chunk of p-code, prior to emitting
CPcodeCompile
CPcodeData	Data for building one p-code instruction
CPcodeEmit	Abstract class for emitting pcode to an application
CPcodeEmitCache	P-code emitter that dumps its raw Varnodes and PcodeOps to an in memory cache
CPcodeEmitFd	A p-code emitter for building PcodeOp objects
CPcodeInjectLibrary	A collection of p-code injection payloads
CPcodeInjectLibraryGhidra	A p-code injection library that uses a Ghidra client to generate/compile the injection p-code
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
CPcodeRawOut
CPcodeSnippet
CPhiForm
CPlusExpression
CPointerModifier
CPreferSplitManager
CPreferSplitRecord
CPrintC	The c-language token emitter
CPrintCCapability	Factory and static initializer for the "c-language" back-end to the decompiler
CPrintfCallBack
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)
CPutsCallBack
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
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	Class for describing a relative p-code branch destination
CRHSConstant
CRightShiftExpression
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)
CRuleCompile
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
CRuleLexer
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
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
CScoreProtoModel	Class for calculating "goodness of fit" of parameter trials against a prototype model
CSectionSymbol
CSectionVector
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	A full SLEIGH engine
CSleighArchitecture	An Architecture that uses the decompiler's native SLEIGH translation engine
CSleighBase	Common core of classes that read or write SLEIGH specification files natively
CSleighBuilder	Build p-code from a pre-parsed instruction
CSleighCompile
CSleighError
CSleighPcode
CSleighSymbol
CSourceFileIndexer	Class for recording source file information for SLEIGH constructors
CSpacebaseSpace	A virtual space stack space
CSpaceQuality
CSpaceSymbol
CSpecificSymbol
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
CStarQuality
CStartInstructionValue
CStartSymbol
►CStringManager	Storage for decoding and storing strings associated with an address
CStringData	String data (a sequence of bytes) stored by StringManager
CStringManagerUnicode	An implementation of StringManager that understands terminated unicode strings
CStructureGraph	Command to structure a control-flow graph
CSubExpression
CSubfloatFlow	Class for tracing changes of precision in floating point variables
CSubForm
CSubtableSymbol
CSubvariableFlow	Class for shrinking big Varnodes carrying smaller logical values
CSymbol	The base class for a symbol in a symbol table or scope
CSymbolCompare
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
CSymbolScope
CSymbolTable
CTargetFeature
CTargetHit
CTerminateCallBack
CTermOrder	A class for ordering Varnode terms in an additive expression
CTermPatternOp	A user defined p-code op that has a dynamically defined procedure
CToken
CTokenField
CTokenPattern
CTokenSplit	A token/command object in the pretty printing stream
CTokenSymbol
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
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
CTraverseConstraint
CTraverseCountState
CTraverseDescendState
CTraverseGroupState
CTreeHandler	A SAX interface implementation for constructing an in-memory DOM model
CTripleSymbol
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
CTypeDeclarator
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
CTypeModifier
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
CTypeSpecifiers
CTypeStruct	A composite Datatype object: A "structure" with component "fields"
CTypeUnicode	The unicode data-type: i.e. wchar
CTypeVoid	Formal "void" data-type object
CUnaryExpression
CUnconstrainedEquation
CUnifyConstraint
CUnifyCPrinter
CUnifyDatatype
CUnifyState
CUnimplError	Exception for encountering unimplemented pcode
CUniqueSpace	The pool of temporary storage registers
CUnitTest	Simple unit test class
CUnspecializedPcodeOp	A user defined p-code op with no specialization
CUserOpManage	Manager/container for description objects (UserPcodeOp) of user defined p-code ops
CUserOpSymbol
CUserPcodeOp	The base class for a detailed definition of a user-defined p-code operation
CValExpressEquation
CValueMapSymbol
►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
CValueSymbol
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
CVarnodeListSymbol
CVarnodeSymbol
CVarnodeTpl
CVolatileOp	A base class for operations that access volatile memory
CVolatileReadOp	An operation that reads from volatile memory
CVolatileWriteOp	An operation that writes to volatile memory
CWidener	Class holding a particular widening strategy for the ValueSetSolver iteration algorithm
CWidenerFull	Class for doing normal widening
CWidenerNone	Class for freezing value sets at a specific iteration (to accelerate convergence)
CWithBlock
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
CXmlScan	The XML character scanner
CXorExpression
Cyy_buffer_state
Cyy_trans_info
Cyyalloc
CYYSTYPE