ROSE  0.9.9.168
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345678]
 CAbstractHandle::abstract_handleTo specify a construct using a specifier Can be used alone or with parent handles when relative specifiers are used
 CAbstractHandle::abstract_nodeUsers should provide a concrete node implementation especially a constructor/builder to avoid duplicated creation of abstract_node
 CRose::BinaryAnalysis::AbstractLocationAbstract location
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterStateGeneric::AccessCreatesLocationsGuardGuards whether access is able to create new locations
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterStateGeneric::AccessModifiesExistingLocationsGuardGuards whether access can change set of existing locations
 CRose::Registry< T, U >::Add< V >A static registration template
 CSawyer::Container::BitVectorSupport::AddBits< Word >
 CAstDOTGenerationExtended_Defaults::AddressExtraNodeInfo
 CSawyer::Container::AddressMapConstraints< AddressMap >Constraints are used to select addresses from a memory map
 CSawyer::Container::AddressMapTraits< AddressMap >
 CSawyer::Container::AddressMapTraits< const AddressMap >
 CSawyer::Container::AddressSegment< A, T >A homogeneous interval of an address space
 CSawyer::Container::AddressSegment< rose_addr_t, uint8_t >
 CRose::BinaryAnalysis::Partitioner2::AddressUsageMapAddress usage map
 CRose::BinaryAnalysis::Partitioner2::AddressUserAddress usage item
 CRose::BinaryAnalysis::Partitioner2::AddressUsersList of virtual address users
 Cadjacency_list
 Cstd::allocator< T >STL class
 CRose::BinaryAnalysis::CallingConvention::AnalysisFunction calling convention
 CRose::BinaryAnalysis::ReturnValueUsed::Analysis
 CRose::BinaryAnalysis::StackDelta::AnalysisStack delta anzalyzer
 CRose::BinaryAnalysis::PointerDetection::AnalysisPointer analysis
 CAnalysis
 CRose::EditDistance::LinearEditDistance::Analysis< NodeType >Edit distance analysis
 CRose::EditDistance::TreeEditDistance::AnalysisAnalysis object for tree edit distance
 CSawyer::Container::BitVectorSupport::AndBits< Word >
 CRose::BinaryAnalysis::Partitioner2::BasicBlockCallback::ArgsArguments passed to the callback
 CSawyer::Container::SegmentPredicate< A, T >::Args
 Cstd::array< T >STL class
 CRose::BinaryAnalysis::AsmFunctionIndexFunctions indexed by entry address
 CRose::BinaryAnalysis::AsmUnparserUnparses binary AST into text
 CAssemblerVirtual base class for instruction assemblers
 CAST_FILE_IOClass holding static data and functions supporting File I/O
 CAstAttribute
 CRose::BinaryAnalysis::Partitioner2::AstConstructionSettingsSettings that control building the AST
 CAstInheritedAttribute
 CAstNodePtrSynAttr
 CAstPDFGeneration
 CAstRestructure
 CAstSharedMemoryParallelProcessingSynchronizationBase
 CAstSharedMemoryParallelProcessingSynchronizationInfo
 CAstSuccessorsSelectors
 CAstSynthesizedAttribute
 CRose::BinaryAnalysis::MemoryMap::AttachAttach with ptrace first when reading a process?
 CRose::BinaryAnalysis::Partitioner2::CfgAdjustmentCallback::AttachedBasicBlockArguments for attaching a basic block
 CAttachPreprocessingInfoTreeTraversalInheritedAttrribute
 CAttachPreprocessingInfoTreeTraversalSynthesizedAttribute
 CAttributeListMap
 Cstd::auto_ptr< T >STL class
 CVirtualBinCFG::AuxiliaryInformation
 CRose::BinaryAnalysis::Partitioner2::GraphViz::BaseEmitter< G >Base class for generating GraphViz output
 CRose::BinaryAnalysis::Partitioner2::GraphViz::BaseEmitter< ControlFlowGraph >
 CRose::BinaryAnalysis::Partitioner2::GraphViz::BaseEmitter< FunctionCallGraph::Graph >
 CRose::FileSystem::baseNameMatchesPredicate returning true for matching names
 CRose::BinaryAnalysis::Partitioner2::BasePartitionerSettingsSettings that directly control a partitioner
 Cstd::basic_string< Char >STL class
 Cstd::basic_string< char >
 Cstd::basic_string< wchar_t >
 CRose::BinaryAnalysis::Partitioner2::BasicBlockConfigConfiguration information for a basic block
 CRose::BinaryAnalysis::BestMapAddressFinds best address for mapping code
 CSawyer::Container::BiMap< S, T >One-to-one mapping between source and target values
 CSawyer::Container::BiMap< ControlFlowGraph::ConstVertexIterator, ControlFlowGraph::ConstVertexIterator >
 Cbinary_function
 CRose::BinaryAnalysis::BinaryLoaderBase class for loading a static or dynamic object
 CRose::BinaryAnalysis::BinaryToSourceConvert binary to low-level C source code
 CBitPattern< T >Describes a pattern of bits in a finite number of words
 CBitPattern< uint16_t >
 Cstd::bitset< Bits >STL class
 CSawyer::Container::BitVectorSupport::bitsPerWord< Word >Number of bits per word
 CSawyer::Container::BitVectorBit vectors
 CBot
 CSawyer::Container::Algorithm::BreadthFirstTraversalTagOrder tag for breadth-first traversals
 CSawyer::Cached< T >Implements cache data members
 CSawyer::Cached< bool >
 CSawyer::Cached< std::set< rose_addr_t > >
 CSawyer::Cached< Successors >
 CRose::BinaryAnalysis::AsmUnparser::CallbackLists
 CSawyer::Callbacks< Callback >
 CSawyer::Callbacks< BasicBlockCallback::Ptr >
 CSawyer::Callbacks< CfgAdjustmentCallback::Ptr >
 CSawyer::Callbacks< Sawyer::Container::SegmentPredicate< Address, Value > * >
 CCallGraphBuilder
 CNewCallGraph::CallGraphEdgeInfo
 CNewCallGraph::CallGraphFileStructure
 CNewCallGraph::CallGraphNodeInfo
 CRose::BinaryAnalysis::ReturnValueUsed::CallSiteResults
 CRose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::MemoryListState::CellCompressorFunctor for handling a memory read that found more than one cell that might alias the requested address
 CStaticCFG::CFG
 CRose::BinaryAnalysis::Partitioner2::CfgEdgeControl flow graph edge
 CVirtualCFG::CFGEdgeA control flow edge connecting two CFG nodes, with an edge condition to indicate edge types
 CVirtualBinCFG::CFGEdge
 CVirtualCFG::CFGNodeA node in the control flow graph
 CVirtualBinCFG::CFGNode
 CRose::BinaryAnalysis::Partitioner2::CfgPathA path through a control flow graph
 CVirtualCFG::CFGPath
 CVirtualCFG::cfgRWTransaction
 CVirtualCFG::CfgToDotImpl< NodeT, EdgeT, Debug >
 CRose::BinaryAnalysis::Partitioner2::CfgVertexControl flow graph vertex
 CChainableTypeLayoutGeneratorBasic type layout engine – handles bookkeeping, plus handing typedefs and
 CVirtualCFG::iterator::checkpoint
 CVirtualCFG::dataflow::checkpoint
 Cssa_private::ChildUsesAttribute that describes the variables used by a given expression
 Cssa_unfiltered_cfg::ChildUsesAttribute that describes the variables used by a given expression
 CClassHierarchyWrapper
 CSawyer::Container::BitVectorSupport::ClearBits< Word >
 CSgAsmCoffSymbol::COFFSymbol_disk
 CSawyer::Message::ColorSetColors to use for each message importance
 CSawyer::Message::ColorSpecANSI Color specification for text written to a terminal
 CSqlDatabase::ColumnTraits< typename >
 CSqlDatabase::ColumnTraits< NoColumn >
 CSawyer::CommandLine::Boost::command_line_parserWrapper around Sawyer's CommandLine class
 CSawyer::Container::Algorithm::CommonSubgraphIsomorphism< Graph, SolutionProcessor, EquivalenceP >Common subgraph isomorphism solver
 CSawyer::Container::BitVectorSupport::CompareBits< Word >
 CcompareSgGraphNode
 Cstd::complexSTL class
 CRose::BinaryAnalysis::Partitioner2::ConfigurationHolds configuration information
 CSageInterface::const_int_expr_t
 Cstd::list< T >::const_iteratorSTL iterator class
 Cstd::forward_list< T >::const_iteratorSTL iterator class
 Cstd::map< K, T >::const_iteratorSTL iterator class
 Cstd::unordered_map< K, T >::const_iteratorSTL iterator class
 CSgSharedVector< _Tp >::const_iterator
 Cstd::basic_string< Char >::const_iteratorSTL iterator class
 Cstd::multimap< K, T >::const_iteratorSTL iterator class
 Cstd::unordered_multimap< K, T >::const_iteratorSTL iterator class
 Cstd::set< K >::const_iteratorSTL iterator class
 Cstd::string::const_iteratorSTL iterator class
 Cstd::unordered_set< K >::const_iteratorSTL iterator class
 Cstd::multiset< K >::const_iteratorSTL iterator class
 Cstd::wstring::const_iteratorSTL iterator class
 Cstd::unordered_multiset< K >::const_iteratorSTL iterator class
 Cstd::vector< T >::const_iteratorSTL iterator class
 Cstd::deque< T >::const_iteratorSTL iterator class
 Cstd::list< T >::const_reverse_iteratorSTL iterator class
 Cstd::forward_list< T >::const_reverse_iteratorSTL iterator class
 Cstd::map< K, T >::const_reverse_iteratorSTL iterator class
 Cstd::unordered_map< K, T >::const_reverse_iteratorSTL iterator class
 Cstd::multimap< K, T >::const_reverse_iteratorSTL iterator class
 Cstd::basic_string< Char >::const_reverse_iteratorSTL iterator class
 Cstd::unordered_multimap< K, T >::const_reverse_iteratorSTL iterator class
 Cstd::set< K >::const_reverse_iteratorSTL iterator class
 Cstd::string::const_reverse_iteratorSTL iterator class
 Cstd::unordered_set< K >::const_reverse_iteratorSTL iterator class
 Cstd::multiset< K >::const_reverse_iteratorSTL iterator class
 Cstd::wstring::const_reverse_iteratorSTL iterator class
 Cstd::unordered_multiset< K >::const_reverse_iteratorSTL iterator class
 Cstd::vector< T >::const_reverse_iteratorSTL iterator class
 Cstd::deque< T >::const_reverse_iteratorSTL iterator class
 CSawyer::Boost::ConstEdgeIdPropertyMap< Graph >
 CSawyer::Boost::ConstEdgePropertyMap< Graph >
 CSawyer::Container::Map< K, T, Cmp, Alloc >::ConstKeyIteratorBidirectional iterator over keys
 Csg::ConstLike< T1, T2 >Projects the constness of T1 on T2
 Csg::ConstLike< const T1, T2 >
 CSawyer::Container::IndexedList< T, Alloc >::ConstNodeIteratorList const node bidirectional iterator
 CSawyer::Container::Map< K, T, Cmp, Alloc >::ConstNodeIteratorBidirectional iterator over key/value nodes
 CSawyer::Container::IndexedList< T, Alloc >::ConstValueIteratorList const value bidirectional iterator
 CSawyer::Container::Map< K, T, Cmp, Alloc >::ConstValueIteratorBidirectional iterator over values
 CSawyer::Boost::ConstVertexIdPropertyMap< Graph >
 CSawyer::Boost::ConstVertexPropertyMap< Graph >
 CAstDOTGenerationExtended_Defaults::ContainerSizeExtraNodeInfo
 CRose::BinaryAnalysis::ControlFlowBinary control flow analysis
 CRose::BinaryAnalysis::Partitioner2::GraphViz::CoordinateTwo dimensional display plane coordinate
 CSawyer::Container::BitVectorSupport::CopyBits< Word >
 CCopyType
 CSawyer::Container::BitVectorSupport::CountClearBits< Word >
 CSawyer::Container::BitVectorSupport::CountSetBits< Word >
 CSawyer::Container::Algorithm::CsiEquivalence< Graph >Vertex equivalence for common subgraph isomorphism
 CSawyer::Container::Algorithm::CsiShowSolution< Graph >Functor called for each common subgraph isomorphism solution
 CRose::BinaryAnalysis::InstructionSemantics2::MultiSemantics::RiscOperators::CursorIterates over valid subdomains whose inputs are valid
 CSawyer::CommandLine::CursorInput stream for command line arguments
 CRose::BinaryAnalysis::Partitioner2::DataBlockConfigConfiguration information for a data block
 CDataConverterEncodes and decodes a buffer using an algorithm defined in subclasses
 CRose::BinaryAnalysis::DataFlowVarious tools for data-flow analysis
 Cssa_private::DataflowCfgFilterFilter which determines which CFG nodes appear in the CFg used to propagate reaching definitions
 CRose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdgeInformation per dataflow edge
 CVirtualCFG::DataflowEdge
 CVirtualCFG::DataflowNode
 CDDE_data
 CSageInterface::DeclarationSets
 CSawyer::Container::BitVectorSupport::Decrement< Word >
 Cdefault_dfs_visitor
 Cdefault_preprocessing_hooks
 CSawyer::DefaultAllocatorDefault allocator
 CRose::BinaryAnalysis::ControlFlow::DefaultEdgePropertyWriter< CFG >Default edge property writer is a no-op
 CAstDOTGenerationExtended_Defaults::DefaultExtraEdgeInfo
 CAstDOTGenerationExtended_Defaults::DefaultExtraEdgeOptions
 CAstDOTGenerationExtended_Defaults::DefaultExtraNodeInfo
 CAstDOTGenerationExtended_Defaults::DefaultExtraNodeOptions
 Csg::DefaultHandler< SageNode >
 Csg::DefaultHandler< const SgProject >
 CRose::BinaryAnalysis::ControlFlow::DefaultVertexPropertyWriter< CFG >Default vertex property writer is a no-op
 CRose::BinaryAnalysis::DataFlow::DefaultVertexUnpackerFunctor to return instructions for a cfg vertex
 CRose::BinaryAnalysis::Demangler
 CSawyer::Container::DenseIntegerSet< T >Unordered set of densely-packed integers
 CSawyer::Container::DenseIntegerSet< size_t >
 CSawyer::Container::Algorithm::DepthFirstTraversalTagOrder tag for depth-first traversals
 Cstd::deque< T >STL class
 CRose::BinaryAnalysis::Partitioner2::CfgAdjustmentCallback::DetachedBasicBlockArguments for detaching a basic block
 CRose::BinaryAnalysis::Partitioner2::DataFlow::DfCfgVertexCFG vertex for data-flow analysis
 CRose::BinaryAnalysis::DisassemblerVirtual base class for instruction disassemblers
 CRose::BinaryAnalysis::Partitioner2::DisassemblerSettingsSettings that control the disassembler
 CRose::BinaryAnalysis::Partitioner2::ModulesPe::PeDescrambler::DispatchEntryOne dispatch table entry in native format
 Csg::DispatchHandler< _ReturnType >
 CSawyer::Container::DistinctList< T, Cmp >A doubly-linked list of distinct items
 CSawyer::Container::DistinctList< rose_addr_t >
 CSawyer::Container::DistinctList< size_t >
 CDistributedMemoryAnalysisPostTraversal< InheritedAttributeType >
 CDistributedMemoryAnalysisPreTraversal< InheritedAttributeType >
 CRose::BinaryAnalysis::Dominance
 CSgAsmDOSExtendedHeader::DOSExtendedHeader_disk
 CSgAsmDOSFileHeader::DOSFileHeader_diskOn-disk format of DOS file header
 CSgAsmDOSFileHeader::DOSRelocEntry_disk
 CDOTGenerationThis class defines the DOT output (graphical representation) of the AST
 CDOTGeneration< SgNode * >
 CDOTInheritedAttributeThis class defines the DOT output (graphical representation) of the AST
 CDOTRepresentationThis class defines the DOT output (graphical representation) of the AST
 CDOTSynthesizedAttributeThis class defines the DOT output (graphical representation) of the AST
 Cdottable
 CEasyStorage< A >
 CSawyer::Container::Graph< V, E, VKey, EKey, Alloc >::EdgeEdge node
 CRose::BinaryAnalysis::Partitioner2::FunctionCallGraph::EdgeInformation about each edge in the call graph
 CEdge
 CEdge2
 CSawyer::Boost::edge_id_t
 CSawyer::Boost::edge_value_t
 Cssa_private::CFG< CFGNodeT, CFGEdgeT >::EdgeCopierThis class is used to copy edges when calling copy_graph()
 CBackstroke::CFG< CFGNodeFilter >::EdgeCopierThis class is used to copy edges when calling copy_graph()
 CRose::BinaryAnalysis::ControlFlow::EdgeFilterFilter for edges
 CRose::BinaryAnalysis::FunctionCall::EdgeFilterFilter for edges
 CRose::BinaryAnalysis::Partitioner2::GraphViz::EdgePositionPosition of an edge
 CSawyer::Boost::EdgePropertyMap< Graph >
 CRose::EditDistance::TreeEditDistance::EditA single edit operation
 CSgAsmElfDynamicEntry::Elf32DynamicEntry_diskDisk format
 CSgAsmElfFileHeader::Elf32FileHeader_diskFile format of an ELF header
 CSgAsmElfRelocEntry::Elf32RelaEntry_disk
 CSgAsmElfRelocEntry::Elf32RelEntry_disk
 CSgAsmElfSectionTableEntry::Elf32SectionTableEntry_diskFile format of an ELF Section header
 CSgAsmElfSegmentTableEntry::Elf32SegmentTableEntry_diskFile format of an ELF Segment header
 CSgAsmElfSymbol::Elf32SymbolEntry_disk32-bit format of an ELF symbol
 CSgAsmElfDynamicEntry::Elf64DynamicEntry_disk
 CSgAsmElfFileHeader::Elf64FileHeader_disk
 CSgAsmElfRelocEntry::Elf64RelaEntry_disk
 CSgAsmElfRelocEntry::Elf64RelEntry_disk
 CSgAsmElfSectionTableEntry::Elf64SectionTableEntry_disk
 CSgAsmElfSegmentTableEntry::Elf64SegmentTableEntry_disk
 CSgAsmElfSymbol::Elf64SymbolEntry_disk
 CSgAsmAsmElfSymverDefinedAux::ElfSymverDefinedAux_diskDisk format
 CSgAsmElfSymverDefinedEntry::ElfSymverDefinedEntry_diskDisk format
 CSgAsmElfSymverNeededAux::ElfSymverNeededAux_diskDisk format
 CSgAsmElfSymverNeededEntry::ElfSymverNeededEntry_diskDisk format
 Cenable_shared_from_this
 CRose::BinaryAnalysis::Strings::EncodedStringAn encoder plus interval
 CRose::BinaryAnalysis::DataFlow::Engine< CFG, State, TransferFunction, MergeFunction >Data-flow engine
 CRose::BinaryAnalysis::Partitioner2::EngineSettingsSettings for controling the engine behavior
 CeqstrName equality operator support for symbol tables within ROSE
 Crose_hash::eqstr_graph_edge
 Crose_hash::eqstr_graph_node
 Crose_hash::eqstr_integer_pair
 Crose_hash::eqstr_string
 Cstd::error_categorySTL class
 Cstd::error_codeSTL class
 Cstd::error_conditionSTL class
 CSawyer::Document::Markup::ErrorLocationInformation about the location of an exception
 CException
 Cstd::exceptionSTL class
 CSawyer::CommandLine::ExcursionGuardGuards a cursor and restores it when the guard is destroyed
 CRose::BinaryAnalysis::SymbolicExpr::ExpressionLesspCompare two expressions for STL containers
 CExtractFunctionArgumentsThis normalization makes sure each function call argument is a side-effect free expression of only one variable
 CSawyer::Message::FacilitiesCollection of facilities
 CSawyer::Message::FacilitiesGuardSaves and restores facilities
 CSawyer::Message::FacilityCollection of streams
 CRose::BinaryAnalysis::FeasiblePathFeasible path analysis
 Cfile_pos_info
 CVirtualCFG::FilteredCFGEdge< FilterFunction >
 CVirtualCFG::FilteredCFGNode< FilterFunction >
 CSawyer::Container::Algorithm::FirstIsomorphicSubgraph< Graph >
 CLibraryIdentification::FlattenAST_SynthesizedAttribute
 CRose::BinaryAnalysis::AsmFunctionIndex::Footnotes
 CFormatRestorerRestores output stream flags to original values
 CRose::BinaryAnalysis::SymbolicExpr::FormatterControls formatting of expression trees when printing
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::FormatterFormat for printing things
 CFormatter
 Cstd::forward_list< T >STL class
 CSawyer::Container::Algorithm::ForwardTraversalTagDirection tag for forward traversals
 CBackstroke::FullCFGNodeFilter
 CfuncSideEffectUses
 CFunction
 CRose::BinaryAnalysis::FunctionCallBinary function call analysis
 CRose::BinaryAnalysis::Partitioner2::FunctionCallGraphFunction call information
 CFunctionCallInfoStores a function call expression, along with associated information about its context
 CFunctionCallInheritedAttribute
 CRose::BinaryAnalysis::Partitioner2::FunctionConfigConfiguration information for a function
 CFunctionData
 Cssa_private::FunctionFilterThis filter determines which function declarations get processed in the analysis
 Cssa_unfiltered_cfg::FunctionFilterThis filter determines which function declarations get processed in the analysis
 CLibraryIdentification::FunctionIdentification
 CRose::BinaryAnalysis::FunctionSimilarityAnalysis to test the similarity of two functions
 CFunctionState
 CRose::BinaryAnalysis::ControlFlow::FunctionSubgraphInfo< CFG >List of vertices and intra-function edges for one function
 CRose::BinaryAnalysis::FeasiblePath::FunctionSummaryInformation stored per V_USER_DEFINED path vertex
 CConstrGraph::geIterator
 CRose::BinaryAnalysis::AsmFunctionIndex::OutputCallback::GeneralArgsBase class for callback arguments
 CRose::BinaryAnalysis::AsmUnparser::UnparserCallback::GeneralArgsArguments common to all unparser callback lists
 CgenerateDOTExtended< ExtraNodeInfo_t, ExtraNodeOptions_t, ExtraEdgeInfo_t, ExtraEdgeOptions_t >
 CgenerateDOTExtended_withIncludes< ExtraNodeInfo_t, ExtraNodeOptions_t, ExtraEdgeInfo_t, ExtraEdgeOptions_t >
 CgenerateDOTExtendedforMultipleFile< ExtraNodeInfo_t, ExtraNodeOptions_t, ExtraEdgeInfo_t, ExtraEdgeOptions_t >
 CCommandlineProcessing::GenericSwitchArgsType for storing generic switch arguments
 CIntegerOps::GenMask< T, n >Bit mask constant with bits 0 through n-1 set
 CgenUID
 CRose::Color::GradientMapping from floating point to color
 CSawyer::Document::Markup::GrammarGrammar declaration
 CSawyer::Container::Graph< V, E, VKey, EKey, Alloc >Graph containing user-defined vertices and edges
 CSawyer::Container::Graph< AbstractLocation, DataFlowEdge >
 CSawyer::Container::Graph< CfgVertex, CfgEdge >
 CSawyer::Container::Graph< FunctionPtr, Edge >
 Cboost::graph_traits< const Sawyer::Container::Graph< V, E, VKey, EKey, Alloc > >
 Cboost::graph_traits< Sawyer::Container::Graph< V, E, VKey, EKey, Alloc > >
 CSawyer::Container::GraphBimapIndex< VertexOrEdgeKey, VertexOrEdgeConstIterator >Map based index is the default index type when indexes are present
 CSawyer::Container::GraphEdgeNoKey< EdgeValue >Type of edge key for graphs that do not index their edges
 CSawyer::Container::GraphHashIndex< VertexOrEdgeKey, VertexOrEdgeConstIterator >Hash-based indexing
 CSawyer::Container::GraphIndexTraits< VertexOrEdgeKey, VertexOrEdgeConstIterator >Traits for vertex and edge indexing
 CSawyer::Container::GraphIndexTraits< EdgeKey, ConstEdgeIterator >
 CSawyer::Container::GraphIndexTraits< GraphEdgeNoKey< EdgeValue >, ConstEdgeIterator >
 CSawyer::Container::GraphIndexTraits< GraphVertexNoKey< VertexValue >, ConstVertexIterator >
 CSawyer::Container::GraphIndexTraits< VertexKey, ConstVertexIterator >
 CSawyer::Container::GraphTraits< G >Traits for graphs
 CSawyer::Container::GraphTraits< const G >
 CSawyer::Container::GraphTraits< Graph >
 CSawyer::Container::Algorithm::GraphTraversal< G, Order, Direction >Base class for graph traversals
 CSawyer::Container::Algorithm::GraphTraversal< Graph, BreadthFirstTraversalTag, ForwardTraversalTag >
 CSawyer::Container::Algorithm::GraphTraversal< Graph, BreadthFirstTraversalTag, ReverseTraversalTag >
 CSawyer::Container::Algorithm::GraphTraversal< Graph, DepthFirstTraversalTag, ForwardTraversalTag >
 CSawyer::Container::Algorithm::GraphTraversal< Graph, DepthFirstTraversalTag, ReverseTraversalTag >
 CSawyer::Container::Algorithm::GraphTraversal< Graph, Order, Direction >
 CSawyer::Container::GraphVertexNoKey< VertexValue >Type of vertex key for graphs that do not index their vertices
 CSawyer::Container::GraphVoidIndex< VertexOrEdgeKey, VertexOrEdgeConstIterator >Fake index for graphs that don't have an index
 Chash< std::string >
 Crose_hash::hash_graph_node
 Crose_hash::hash_integerHash name support for symbol tables within ROSE
 Crose_hash::hash_integer_pair
 Chash_NameHash name support for symbol tables within ROSE
 CSqlDatabase::Header< T >
 CSqlDatabase::Header< NoColumn >
 CSqlDatabase::Header< std::string >
 CHexdumpFormatSettings that control how the lowest-level SgAsmExecutableFileFormat::hexdump function behaves
 CSawyer::Container::BitVectorSupport::HighToLow
 CSawyer::Message::HighWater
 CRose::Color::HSVColors in HSV space
 CSawyer::Container::Algorithm::IdAccumulator< Graph >Accumulates vertex or edge IDs
 CSgAsmNERelocEntry::iname_type
 CIncludeDirective
 CSawyer::Container::BitVectorSupport::Increment< Word >
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::IndentAdjusts a Formatter for one additional level of indentation
 CRose::BinaryAnalysis::InstructionSemantics2::LlvmSemantics::RiscOperators::IndentCause indentation until this object is destroyed
 CSawyer::Container::IndexedList< T, Alloc >Doubly-linked list with constant-time indexing
 CSawyer::Container::IndexedList< Edge, Allocator >
 CSawyer::Container::IndexedList< Vertex, Allocator >
 CSawyer::Container::IndexedListTraits< T >Traits for indexed lists
 CSawyer::Container::IndexedListTraits< const T >
 Csg::InitNameClonerFunctor copying an initialized name into a different scope
 CRose::BinaryAnalysis::Partitioner2::InlinerBinary inliner
 CRose::BinaryAnalysis::InsnCFGVertexWriter< Graph >A vertex property writer for instruction-based CFGs
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InsnProcessorFunctor that knows how to dispatch a single kind of instruction
 CBackstroke::InterestingCFGNodeFilter
 CVirtualCFG::InterestingEdge
 CVirtualCFG::InterestingNode
 CRose::BinaryAnalysis::Partitioner2::DataFlow::InterproceduralPredicatePredicate that decides when to use inter-procedural data-flow
 CSawyer::Container::Interval< T >Range of values delimited by endpoints
 CSawyer::Container::Interval< A >
 CSawyer::Container::Interval< Address >
 CSawyer::Container::Interval< rose_addr_t >
 CSawyer::Container::Interval< size_t >
 CSawyer::Container::IntervalMap< I, T, Policy >An associative container whose keys are non-overlapping intervals
 CSawyer::Container::IntervalMap< AddressInterval, AddressUsers >
 CSawyer::Container::IntervalMap< AddressInterval, int >
 CSawyer::Container::IntervalMap< I, int >
 CSawyer::Container::IntervalMap< I, S >
 CSawyer::Container::IntervalMap< Interval, int >
 CSawyer::Container::IntervalMap< Interval< A >, AddressSegment< A, T >, AddressMapImpl::SegmentMergePolicy< A, T > >
 CSawyer::Container::IntervalMap< Interval< rose_addr_t >, AddressSegment< rose_addr_t, uint8_t >, AddressMapImpl::SegmentMergePolicy< rose_addr_t, uint8_t > >
 CSawyer::Container::IntervalMapTraits< IntervalMap >Traits for IntervalMap
 CSawyer::Container::IntervalMapTraits< const IntervalMap >
 CSawyer::Container::IntervalSet< I >A container holding a set of values
 CSawyer::Container::IntervalSet< AddressInterval >
 CSawyer::Container::IntervalSet< Interval >
 CIntraPartitionDataflowCheckpoint
 CSawyer::Container::BitVectorSupport::InvertBits< Word >
 CSgAsmNERelocEntry::iord_type
 Cstd::ios_baseSTL class
 CSgAsmNERelocEntry::iref_type
 Cstd::list< T >::iteratorSTL iterator class
 Cstd::forward_list< T >::iteratorSTL iterator class
 CSqlDatabase::Statement::iteratorIterates over the result rows
 Cstd::map< K, T >::iteratorSTL iterator class
 Cstd::unordered_map< K, T >::iteratorSTL iterator class
 CSgSharedVector< _Tp >::iterator
 Cstd::multimap< K, T >::iteratorSTL iterator class
 Cstd::basic_string< Char >::iteratorSTL iterator class
 Cstd::unordered_multimap< K, T >::iteratorSTL iterator class
 Citerator
 Cstd::set< K >::iteratorSTL iterator class
 Cstd::string::iteratorSTL iterator class
 Cstd::unordered_set< K >::iteratorSTL iterator class
 CCGFunction::iterator
 CVirtualCFG::iterator
 Cstd::wstring::iteratorSTL iterator class
 Cstd::multiset< K >::iteratorSTL iterator class
 Cstd::unordered_multiset< K >::iteratorSTL iterator class
 CRose::Registry< T, U >::iteratorIterators for registry entries
 Cstd::vector< T >::iteratorSTL iterator class
 Cstd::deque< T >::iteratorSTL iterator class
 Citerator_facade
 CRose::iterator_range< IteratorT >A range adaptor for a pair of iterators
 CRose::ParallelSort::Private::Job< RandomAccessIterator, Compare >
 CSawyer::Container::BitVectorSupport::LeastSignificantClearBit< Word >
 CSawyer::Container::BitVectorSupport::LeastSignificantDifference< Word >
 CSawyer::Container::BitVectorSupport::LeastSignificantSetBit< Word >
 CSgAsmLEEntryPoint::LEEntryPoint_disk
 CSgAsmLEFileHeader::LEFileHeader_disk
 CConstrGraph::leIterator
 CSgAsmLEPageTableEntry::LEPageTableEntry_disk
 CSgAsmLESectionTableEntry::LESectionTableEntry_disk
 CRose::EditDistance::LevenshteinStack< T >
 CSawyer::CommandLine::LexicalCast< T >
 CSawyer::CommandLine::LexicalCast< boost::any >
 CSawyer::CommandLine::LexicalCast< Optional< T > >
 CSawyer::CommandLine::LexicalCast< Sawyer::Container::Map< std::string, T > >
 CSawyer::CommandLine::LexicalCast< Sawyer::Container::Set< T > >
 CSawyer::CommandLine::LexicalCast< std::list< T > >
 CSawyer::CommandLine::LexicalCast< std::map< std::string, T > >
 CSawyer::CommandLine::LexicalCast< std::set< T > >
 CSawyer::CommandLine::LexicalCast< std::vector< T > >
 CLibraryIdentification::library_handle
 CLinearCongruentialGeneratorLinear congruential generator
 CRose::BinaryAnalysis::AsmUnparser::LinePrefixDetails for line prefixes
 CSawyer::Container::LineVectorA buffer of characters indexed by line number
 CROSE_Callbacks::List< T >List of callback functors
 Cstd::list< T >STL class
 Cstd::list< BasicBlockCallback::Ptr >
 Cstd::list< Callback >
 Cstd::list< CallbackType * >
 Cstd::list< CallSite >
 Cstd::list< CfgAdjustmentCallback::Ptr >
 Cstd::list< Chunk * >
 Cstd::list< const CGFunction * >
 Cstd::list< DataflowNode >
 Cstd::list< DestinationPtr >
 Cstd::list< InheritedAttribute >
 Cstd::list< int >
 Cstd::list< IntArithLogical::exprLeafOrNode * >
 Cstd::list< Item >
 Cstd::list< KeyVal >
 Cstd::list< MemoryCellPtr >
 Cstd::list< modRequest * >
 Cstd::list< partSplit * >
 CROSE_Callbacks::List< Rose::BinaryAnalysis::AsmFunctionIndex::OutputCallback >
 CROSE_Callbacks::List< Rose::BinaryAnalysis::AsmUnparser::UnparserCallback >
 Cstd::list< Rose::BinaryAnalysis::Partitioner2::GraphViz::BaseEmitter::PseudoEdge >
 Cstd::list< Rose::ParallelSort::Private::Work< RandomAccessIterator > >
 Cstd::list< Sawyer::Container::SegmentPredicate< Address, Value > * >
 Cstd::list< SgExpression * >
 Cstd::list< SgNode * >
 Cstd::list< size_t * >
 Cstd::list< SpearAbstractVar * >
 Cstd::list< std::pair< SgIncludeDirectiveStatement *, SgStatement * > >
 Cstd::list< std::string >
 Cstd::list< T * >
 Cstd::list< token_type >
 Cstd::list< Variable >
 Cstd::list< VariableTaint >
 Cstd::list< VirtualCFG::DataflowNode >
 Cstd::list< Work >
 CRose::Registry< T, U >::listenerAbstract base class for registry listeners, which are informed when new entries are added to the registry
 CRose::BinaryAnalysis::Partitioner2::LoaderSettingsSettings for loading specimens
 CSawyer::CommandLine::LocationPosition within a command-line
 CSawyer::LockGuard2< Mutex >Locks multiple mutexes
 CSawyer::LockGuard2< NullMutex >
 CLogicalCond
 CSawyer::Container::BitVectorSupport::LowToHighTags for traversal directions
 CAstDOTGenerationExtended_Defaults::LValueExtraNodeInfo
 CRose::BinaryAnalysis::DisassemblerM68k::M68kInterface for disassembling a single instruction
 CRose::BinaryAnalysis::MagicNumber
 CVirtualCFG::MakeClosure< FindSuccessors, FindEnd, DontAddChildren, Join, FilteredEdge >
 CSawyer::Container::Map< K, T, Cmp, Alloc >Container associating values with keys
 Cstd::map< K, T >STL class
 Cstd::map< Analysis *, bool >
 Cstd::map< Analysis *, std::vector< Lattice * > >
 Cstd::map< Analysis *, std::vector< NodeFact * > >
 CSawyer::Container::Map< CellKey, MemoryCellPtr >
 Cstd::map< CFGNode, NodeReachingDefTable >
 Cstd::map< CFGNode, std::set< ssa_private::UniqueNameTraversal::VarName > >
 Cstd::map< CFGNodeType, Vertex >
 Cstd::map< const CGFunction *, int >
 Cstd::map< const SgNode *, SgNode * >
 Cstd::map< DataflowNode, std::vector< NodeState * > >
 CSawyer::Container::Map< double, HSV >
 Cstd::map< Edge, int >
 Cstd::map< Function, std::map< varID, int > >
 Cstd::map< Function, std::set< DataflowNode > >
 Cstd::map< Function, std::set< Function > >
 CSawyer::Container::Map< Function::Ptr, InlinedFunctions >
 CSawyer::Container::Map< Id, boost::any >
 Cstd::map< int, Edge >
 Cstd::map< int, int >
 Cstd::map< int, ROSEAttributesList * >
 Cstd::map< int, SgGraphNode * >
 Cstd::map< int, SgLocatedNode * >
 Cstd::map< int, std::set< int > >
 Cstd::map< int, std::set< std::vector< int > > >
 Cstd::map< int, std::string >
 Cstd::map< int, std::vector< int > >
 Cstd::map< int, std::vector< std::vector< int > > >
 Cstd::map< int, Vertex >
 Cstd::map< int, wrap_data_used_by_AttachPreprocessingInfoTreeTrav_t >
 CSawyer::Container::Map< Interval, Value, IntervalCompare >
 Cstd::map< IntraPartitionDataflow *, IntraPartitionDataflowCheckpoint * >
 Cstd::map< IntraPartitionDataflow *, std::list< partSplit * > >
 CSawyer::Container::Map< Item, typename Items::iterator, Comparator >
 Cstd::map< Key, T, Compare, Alloc >
 Cstd::map< Key, Value, Comparator, Alloc >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const CellKey, MemoryCellPtr > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const double, HSV > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Function::Ptr, InlinedFunctions > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Id, boost::any > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Interval, Value > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Item, typename Items::iterator > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Label, Value > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Location, std::vector< size_t > > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const MajorMinor, BitSet > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Partitioner2::Function::Ptr, FunctionInfo > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const RegisterDescriptor, size_t > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const RegStore, BitAddressSet > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const RegStore, BitProperties > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const RegStore, RegPairs > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, BasicBlockConfig > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, CallSiteResults > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, ControlFlowGraph::VertexIterator > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, DataBlockConfig > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, Function::Ptr > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, FunctionConfig > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, FunctionSummary > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, Graph::VertexIterator > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, InstructionSemantics2::BaseSemantics::SValuePtr > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, SgAsmInstruction * > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, size_t > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, std::string > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const rose_addr_t, SValuePair > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const size_t, Graph > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Source, Target > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, Facility * > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, FunctionConfig > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, Organization > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, Sawyer::CommandLine::SwitchAction::Ptr > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, Sawyer::Document::Markup::Function::Ptr > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, SgAsmType * > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, size_t > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, std::string > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, std::vector< bool > > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, std::vector< size_t > > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const std::string, T > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const SymbolicExpr::Ptr, StringTypePair > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const SymbolicExpr::Ptr, YExprTypePair > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const Target, Source > > >
 Cstd::map< Key, Value, Comparator, std::allocator< std::pair< const VertexOrEdgeKey, VertexOrEdgeConstIterator > > >
 CSawyer::Container::Map< Label, Value >
 CSawyer::Container::Map< Location, std::vector< size_t > >
 CSawyer::Container::Map< MajorMinor, BitSet >
 Cstd::map< omp_construct_enum, bool >
 Cstd::map< omp_construct_enum, std::pair< std::string, SgExpression * > >
 Cstd::map< omp_construct_enum, std::vector< std::pair< std::string, SgNode * > > >
 CSawyer::Container::Map< Partitioner2::Function::Ptr, FunctionInfo >
 Cstd::map< Range, Value, RangeCompare >
 Cstd::map< ReachingDefPtr, std::set< CFGEdge > >
 Cstd::map< ReachingDefPtr, std::set< FilteredCfgEdge > >
 CSawyer::Container::Map< RegisterDescriptor, size_t >
 Cstd::map< RegisterDescriptor, std::vector< std::string > >
 CSawyer::Container::Map< RegStore, BitAddressSet >
 CSawyer::Container::Map< RegStore, BitProperties >
 CSawyer::Container::Map< RegStore, RegPairs >
 CSawyer::Container::Map< rose_addr_t, BasicBlockConfig >
 CSawyer::Container::Map< rose_addr_t, CallSiteResults >
 CSawyer::Container::Map< rose_addr_t, ControlFlowGraph::VertexIterator >
 CSawyer::Container::Map< rose_addr_t, DataBlockConfig >
 CSawyer::Container::Map< rose_addr_t, Function::Ptr >
 CSawyer::Container::Map< rose_addr_t, FunctionConfig >
 CSawyer::Container::Map< rose_addr_t, FunctionSummary >
 CSawyer::Container::Map< rose_addr_t, Graph::VertexIterator >
 CSawyer::Container::Map< rose_addr_t, InstructionSemantics2::BaseSemantics::SValuePtr >
 CSawyer::Container::Map< rose_addr_t, SgAsmInstruction * >
 Cstd::map< rose_addr_t, SgAsmInstruction * >
 Cstd::map< rose_addr_t, SgAsmInstruction *, std::less< rose_addr_t >, std::allocator< std::pair< const rose_addr_t, SgAsmInstruction * > > >
 CSawyer::Container::Map< rose_addr_t, size_t >
 CSawyer::Container::Map< rose_addr_t, std::string >
 CSawyer::Container::Map< rose_addr_t, SValuePair >
 Cstd::map< SgAsmBlock *, CFG_Vertex >
 Cstd::map< SgAsmElfSymbol *, VersionedSymbol * >
 Cstd::map< SgAsmFunction *, CG_Vertex >
 Cstd::map< SgAsmInstruction *, AddressSet >
 Cstd::map< SgAsmStatement *, AddressSet >
 Cstd::map< SgDeclarationStatement *, std::set< SgDeclarationStatement * > * >
 Cstd::map< SgForStatement *, bool >
 Cstd::map< SgForStatement *, std::pair< SgVariableDeclaration *, SgVariableDeclaration * > >
 Cstd::map< SgGraphNode *, bool >
 Cstd::map< SgGraphNode *, InheritedAttributeType >
 Cstd::map< SgGraphNode *, int >
 Cstd::map< SgGraphNode *, std::set< SgGraphNode * > >
 Cstd::map< SgGraphNode *, std::set< std::vector< SgGraphNode * > > >
 Cstd::map< SgGraphNode *, std::vector< SgGraphNode * > >
 Cstd::map< SgGraphNode *, std::vector< std::set< int > > >
 Cstd::map< SgGraphNode *, std::vector< std::vector< SgGraphNode * > > >
 Cstd::map< SgNode *, int >
 Cstd::map< SgNode *, std::set< SgVarRefExp * > >
 Cstd::map< SgNode *, std::string >
 Cstd::map< SgSymbol *, std::vector< std::pair< omp_construct_enum, SgExpression * > > >
 Cstd::map< SgSymbol *, std::vector< std::pair< SgExpression *, SgExpression * > > >
 Cstd::map< SgSymbol *, std::vector< std::pair< SgOmpClause::omp_map_dist_data_enum, SgExpression * > > >
 CSawyer::Container::Map< size_t, Graph >
 CSawyer::Container::Map< Source, Target >
 Cstd::map< SrcInfo, ExtentMap >
 Cstd::map< std::pair< std::string, int >, PreprocessingInfo * >
 Cstd::map< std::pair< std::string, void * >, FiniteVarsExprsProductLattice * >
 Cstd::map< std::string, CONSTRUCTOR >
 CSawyer::Container::Map< std::string, Facility * >
 CSawyer::Container::Map< std::string, FunctionConfig >
 Cstd::map< std::string, int >
 Cstd::map< std::string, NewCallGraph::CallGraphEdgeInfo * >
 Cstd::map< std::string, NewCallGraph::CallGraphNodeInfo * >
 CSawyer::Container::Map< std::string, Organization >
 Cstd::map< std::string, RegisterDescriptor >
 Cstd::map< std::string, ROSEAttributesList * >
 CSawyer::Container::Map< std::string, Sawyer::CommandLine::SwitchAction::Ptr >
 CSawyer::Container::Map< std::string, Sawyer::Document::Markup::Function::Ptr >
 CSawyer::Container::Map< std::string, SgAsmType * >
 CSawyer::Container::Map< std::string, size_t >
 Cstd::map< std::string, std::pair< size_t, uint64_t > >
 Cstd::map< std::string, std::set< PreprocessingInfo * > >
 CSawyer::Container::Map< std::string, std::string >
 CSawyer::Container::Map< std::string, std::vector< bool > >
 Cstd::map< std::string, std::vector< omp_construct_enum > >
 CSawyer::Container::Map< std::string, std::vector< size_t > >
 Cstd::map< std::string, SymbolMapEntry >
 Cstd::map< std::string, T >
 CSawyer::Container::Map< std::string, T >
 Cstd::map< std::string, void * >
 Cstd::map< std::vector< int >, int >
 Cstd::map< SymbolicExpr::Hash, LeafPtr, std::less< SymbolicExpr::Hash >, std::allocator< std::pair< const SymbolicExpr::Hash, LeafPtr > > >
 CSawyer::Container::Map< SymbolicExpr::Ptr, StringTypePair >
 CSawyer::Container::Map< SymbolicExpr::Ptr, YExprTypePair >
 Cstd::map< T, size_t, key_compare >
 CSawyer::Container::Map< Target, Source >
 Cstd::map< uint16_t, SgAsmElfSymverDefinedEntry * >
 Cstd::map< uint16_t, SgAsmElfSymverNeededAux * >
 Cstd::map< uint64_t, std::string >
 Cstd::map< uint64_t, std::string, std::less< uint64_t >, std::allocator< std::pair< const uint64_t, std::string > > >
 Cstd::map< uint64_t, uint64_t >
 Cstd::map< uint64_t, uint64_t, std::less< uint64_t >, std::allocator< std::pair< const uint64_t, uint64_t > > >
 Cstd::map< unsigned char, std::string >
 Cstd::map< varID, affineInequality >
 Cstd::map< varID, int >
 Cstd::map< varID, Lattice * >
 Cstd::map< varID, std::map< varID, affineInequality > >
 Cstd::map< Vertex, int >
 Cstd::map< Vertex, Vertex >
 CSawyer::Container::Map< VertexOrEdgeKey, VertexOrEdgeConstIterator >
 Cstd::map< VirtualCFG::CFGNode, SgGraphNode * >
 Cstd::map< VirtualCFG::FilteredCFGNode, Vertex >
 CSawyer::Container::TraceDetail::MapIndex< K, V >
 CSawyer::Container::AddressMapImpl::MatchedConstraints< AddressMap >
 CRose::BinaryAnalysis::Matrix< T >Matrix values
 CSawyer::Container::Algorithm::MaximumIsomorphicSubgraphs< Graph >
 CSawyer::Container::DenseIntegerSet< T >::Member
 CMemoryState
 CRose::BinaryAnalysis::TaintedFlow::MergeFunction
 CSawyer::Container::MergePolicy< I, T >Policy indicating how values are merged and split
 CSawyer::Container::MergePolicy< AddressInterval, AddressUsers >
 CSawyer::Container::MergePolicy< AddressInterval, int >
 CSawyer::Container::MergePolicy< I, int >
 CSawyer::Container::MergePolicy< I, S >
 CSawyer::Container::MergePolicy< Interval, int >
 CSawyer::Message::MesgA single message
 CSawyer::Message::MesgPropsProperties for messages
 CRose::BinaryAnalysis::DisassemblerMips::Mips32Interface for disassembling a single instruction
 CSawyer::Container::BitVectorSupport::MostSignificantClearBit< Word >
 CSawyer::Container::BitVectorSupport::MostSignificantDifference< Word >
 CSawyer::Container::BitVectorSupport::MostSignificantSetBit< Word >
 CSawyer::MultiInstanceTls< T >Thread local data per object instance
 Cstd::multimap< K, T >STL class
 Cstd::multimap< SgNode *, NodeT >
 Cstd::multiset< K >STL class
 CSawyer::MultiThreadedTagTag indicating that an algorithm or API should assume multiple threads
 Cmutex
 CMyLoop
 CAstDOTGenerationExtended_Defaults::NamedExtraNodeInfo
 CSgAsmNEFileHeader::NEFileHeader_disk
 CSgAsmNESectionTableEntry::NESectionTableEntry_disk
 CSqlDatabase::NoColumn
 CSawyer::Container::IndexedList< T, Alloc >::NodeCombination user-defined value and ID number
 CRose::EditDistance::LinearEditDistance::NodeType for comparing two AST nodes
 CRose::Registry< T, U >::nodeNode in linked list of entries
 CConstrGraph::NodeDesc
 CSawyer::Container::IndexedList< T, Alloc >::NodeIteratorList node bidirectional iterator
 CSawyer::Container::Map< K, T, Cmp, Alloc >::NodeIteratorBidirectional iterator over key/value nodes
 CSgAsmFunction::NodeSelectorSelection functor for SgAsmFunction::get_extent()
 CNodeState
 Cnoncopyable
 CRose::BinaryAnalysis::NoOperationAnalysis that looks for no-op equivalents
 CSawyer::NothingRepresents no value
 CSawyer::NullBarrier
 CSawyer::NullLockGuard
 CSawyer::NullMutex
 CIntegerOpsPrivate::NumBits< T >
 CSawyer::CommandLine::NumericCast< Target, Source >
 CSawyer::CommandLine::NumericCast< Optional< Target >, Source >
 CSawyer::CommandLine::NumericCast< Sawyer::Container::Map< std::string, Target >, Source >
 CSawyer::CommandLine::NumericCast< Sawyer::Container::Set< Target >, Source >
 CSawyer::CommandLine::NumericCast< std::list< Target >, Source >
 CSawyer::CommandLine::NumericCast< std::map< std::string, Target >, Source >
 CSawyer::CommandLine::NumericCast< std::set< Target >, Source >
 CSawyer::CommandLine::NumericCast< std::vector< Target >, Source >
 COmpSupport::OmpAttributeOne attribute object stores all information within an OpenMP pragma (directive and clauses)
 CSgFunctionModifier::opencl_work_group_size_t
 CSawyer::Optional< T >Holds a value or nothing
 CSawyer::Optional< Address >
 CSawyer::Optional< BaseSemantics::StatePtr >
 CSawyer::Optional< bool >
 CSawyer::Optional< CodePoint >
 CSawyer::Optional< double >
 CSawyer::Optional< Importance >
 CSawyer::Optional< int >
 CSawyer::Optional< int64_t >
 CSawyer::Optional< Interval< Address > >
 CSawyer::Optional< Label >
 CSawyer::Optional< rose_addr_t >
 CSawyer::Optional< Sawyer::Container::Algorithm::GraphTraversal::Work >
 CSawyer::Optional< Sawyer::Container::Graph::ConstVertexIterator >
 CSawyer::Optional< size_t >
 CSawyer::Optional< std::string >
 CSawyer::Optional< TokenEnum >
 CSawyer::Optional< unsigned >
 CSawyer::Optional< Value >
 COptionDeclaration
 CRose::Options
 CSawyer::CommandLine::Boost::options_descriptionReplacement for basic use of boost::program_options::options_description
 CSawyer::Container::BitVectorSupport::OrBits< Word >
 CRose::BinaryAnalysis::Partitioner2::GraphViz::OrganizationOrganizational information
 CSgAsmNERelocEntry::osfixup_type
 CRose::BinaryAnalysis::AsmFunctionIndex::OutputCallbackBase class for printing table cells
 CRose::BinaryAnalysis::Partitioner2::OwnedDataBlockShared reference to data block
 Cpair
 CRose::BinaryAnalysis::CallingConvention::ParameterLocationAbstract parameter location
 CSawyer::CommandLine::Boost::parsed_valuesWrapper around parsed values
 CSawyer::CommandLine::ParsedValueInformation about a parsed switch value
 CSawyer::CommandLine::ParserThe parser for a program command line
 CSawyer::CommandLine::ParserResultThe result from parsing a command line
 CSawyer::CommandLine::ParsingProperties
 CRose::BinaryAnalysis::Partitioner2::PartitionerSettingsSettings that control the engine partitioning
 CpartSplit
 CRose::BinaryAnalysis::FeasiblePath::PathProcessorPath searching functor
 CPDFGenerationThis class defines the PDF output of the AST
 CPDFInheritedAttributeThis class defines the PDF output (graphical representation) of the AST
 CSgAsmPEFileHeader::PE32OptHeader_disk
 CSgAsmPEFileHeader::PE64OptHeader_disk
 CSgAsmPEExportDirectory::PEExportDirectory_disk
 CSgAsmPEFileHeader::PEFileHeader_disk
 CSgAsmPEImportDirectory::PEImportDirectory_disk
 CSgAsmPESectionTableEntry::PESectionTableEntry_disk
 CRose::PluginAction
 CRose::BinaryAnalysis::PointerDetection::PointerDescriptorDescription of one pointer
 CRose::BinaryAnalysis::PointerDetection::PointerDescriptorLesspFunctor to compare two PointerLocation objects
 CSawyer::PoolAllocatorBase< smallestCell, sizeDelta, nPools, chunkSize, Sync >Small object allocation from memory pools
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::MemoryCell::PredicatePredicate for matching cells
 CPreOrderTraversal
 CPrePostOrderTraversal
 CSqlDatabase::PrePostRow< Table >Called before and after printing each row of a table
 CSqlDatabase::PrePostRow< SqlDatabase::Table >
 CPreprocessingInfoFor preprocessing information including source comments, #include , #if, #define, etc
 Cprintable
 Cstd::priority_queue< T >STL class
 CSawyer::ProgressBar< T, S >Progress bars
 CSawyer::ProgressBarImpl
 CRose::ProgressTaskRAII sub-task progress
 Cboost::property_map< Graph, Sawyer::Boost::edge_id_t >
 Cboost::property_map< Graph, Sawyer::Boost::edge_value_t >
 Cboost::property_map< Graph, Sawyer::Boost::vertex_id_t >
 Cboost::property_map< Graph, Sawyer::Boost::vertex_value_t >
 CSawyer::ProxyAllocator< Allocator >Allocator proxy
 CRose::BinaryAnalysis::Partitioner2::GraphViz::BaseEmitter< G >::PseudoEdge
 Cstd::queue< T >STL class
 CPreprocessingInfo::r_include_directive
 CPreprocessingInfo::r_macro_def
 CRange< T >A contiguous range of values
 CRangeMap< R, T >::RangeCompareThe value attached to each range in this RangeMap
 CRangeMap< R, T >A container of ranges, somewhat like a set
 CRangeMap< Extent >
 CRangeMap< Extent, RangeMapLocationInfo >
 CRangeMapNumeric< R, T >Scalar value type for a RangeMap
 CRangeMapValue< R, T >Scalar value type for a RangeMap
 CRangeMapValue< Extent, SrcInfo >
 CRangeMapVoid< R >Value type for a RangeMap with no useful data attached to the ranges
 CRose::BinaryAnalysis::ReachabilityAnalysis that computes reachability of CFG vertices
 CReachingDef
 Cssa_unfiltered_cfg::ReachingDef
 CRose::RecursionCounterTrack recursion depth in a function
 CRose::BinaryAnalysis::Partitioner2::ReferenceReference to a function, basic block, instruction, or address
 CSawyer::Document::Markup::ReflowA class that can reflow and indent paragraphs
 CRegisterDescriptorDescribes (part of) a physical CPU register
 CRegisterDictionaryDefines registers available for a particular architecture
 CRegisterNamesPrints a register name even when no dictionary is available or when the dictionary doesn't contain an entry for the specified descriptor
 CRose::BinaryAnalysis::RegisterPartsHolds a set of registers without regard for register boundaries
 CRegisterState
 CRose::Registry< T, U >A global registry used in conjunction with static constructors to make pluggable components (like targets or garbage collectors) "just work" when linked with an executable
 CRose::RegistryTraits< T >Traits for registry entries
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterStateGeneric::RegPairA register descriptor and its value
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterStateGeneric::RegStoreRegister map keys
 CSawyer::Container::BitVectorSupport::RemoveConst< T >For removing const qualifiers
 CSawyer::Container::BitVectorSupport::RemoveConst< const T >
 CSqlDatabase::Renderer< T >Renders a column value as a string
 CSqlDatabase::Renderer< std::string >
 CSqlDatabase::Renderer< T00 >
 CSqlDatabase::Renderer< T01 >
 CSqlDatabase::Renderer< T02 >
 CSqlDatabase::Renderer< T03 >
 CSqlDatabase::Renderer< T04 >
 CSqlDatabase::Renderer< T05 >
 CSqlDatabase::Renderer< T06 >
 CSqlDatabase::Renderer< T07 >
 CSqlDatabase::Renderer< T08 >
 CSqlDatabase::Renderer< T09 >
 CSqlDatabase::Renderer< T10 >
 CSqlDatabase::Renderer< T11 >
 CSqlDatabase::Renderer< T12 >
 CSqlDatabase::Renderer< T13 >
 CSqlDatabase::Renderer< T14 >
 CSqlDatabase::Renderer< T15 >
 CSqlDatabase::Renderer< time_t >
 CSqlDatabase::Renderer< uint64_t >
 CSqlDatabase::Table< T00, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15 >::RenderersFunctors for rendering column values
 CRose::Progress::ReportA single progress report
 CRose::BinaryAnalysis::Partitioner2::BasicBlockCallback::ResultsResults coordinated across all callbacks
 Cstd::list< T >::reverse_iteratorSTL iterator class
 Cstd::forward_list< T >::reverse_iteratorSTL iterator class
 Cstd::map< K, T >::reverse_iteratorSTL iterator class
 Cstd::unordered_map< K, T >::reverse_iteratorSTL iterator class
 Cstd::multimap< K, T >::reverse_iteratorSTL iterator class
 Cstd::basic_string< Char >::reverse_iteratorSTL iterator class
 Cstd::unordered_multimap< K, T >::reverse_iteratorSTL iterator class
 Cstd::set< K >::reverse_iteratorSTL iterator class
 Cstd::string::reverse_iteratorSTL iterator class
 Cstd::unordered_set< K >::reverse_iteratorSTL iterator class
 Cstd::multiset< K >::reverse_iteratorSTL iterator class
 Cstd::wstring::reverse_iteratorSTL iterator class
 Cstd::unordered_multiset< K >::reverse_iteratorSTL iterator class
 Cstd::vector< T >::reverse_iteratorSTL iterator class
 Cstd::deque< T >::reverse_iteratorSTL iterator class
 CSawyer::Container::Algorithm::ReverseTraversalTagDirection tag for reverse traversals
 CRose::Color::RGBColors in RGB space
 CRiscOperators
 CROSE_BaseGrammar
 CPreprocessingInfo::rose_macro_call
 Crose_rva_tA relative virtual address optionally associated with a SgAsmSection
 CROSE_VisitorPattern
 CROSE_VisitTraversal
 CROSEAttributesList
 CROSEAttributesListContainer
 CSqlDatabase::RowSeparator< T >
 CSqlDatabase::RowSeparator< NoColumn >
 CRTIMemberDataAccess to C++ Run Time Information (RTI)
 CSgAsmPERVASizePair::RVASizePair_diskFile format for an RVA/Size pair
 Csg::ScopeSetterFunctor setting the scope of a sage node to a specified (at Functor construction time) scope
 CSawyer::Container::AddressMapImpl::SegmentMergePolicy< A, T >
 CSawyer::Container::AddressMapImpl::SegmentMergePolicy< rose_addr_t, uint8_t >
 CSawyer::Container::SegmentPredicate< A, T >Base class for testing segment constraints
 CSawyer::Container::SegmentPredicate< Address, Value >
 CRose::BinaryAnalysis::DataFlow::SemanticsMergeBasic merge operation for instruction semantics
 CSawyer::Container::Set< T, C, A >Ordered set of values
 Cstd::set< K >STL class
 Cstd::set< Analysis * >
 Cstd::set< CFGEdge >
 Cstd::set< CGFunction >
 Cstd::set< const CGFunction * >
 Cstd::set< ControlFlowGraph::ConstEdgeIterator >
 Cstd::set< ControlFlowGraph::ConstVertexIterator >
 Cstd::set< DataflowNode >
 Cstd::set< FilteredCfgEdge >
 Cstd::set< Function >
 CSawyer::Container::Set< Function::Ptr >
 Cstd::set< Function::Ptr, std::less< Function::Ptr >, std::allocator< Function::Ptr > >
 Cstd::set< FunctionState * >
 Cstd::set< Importance >
 CSawyer::Container::Set< InputOutputProperty >
 Cstd::set< InputOutputProperty, std::less< InputOutputProperty >, std::allocator< InputOutputProperty > >
 Cstd::set< int >
 Cstd::set< IntraPartitionDataflow * >
 Cstd::set< PointerDescriptor, PointerDescriptorLessp >
 Cstd::set< PreprocessingInfo * >
 Cstd::set< RegisterDescriptor >
 Cstd::set< rose_addr_t >
 CSawyer::Container::Set< rose_addr_t >
 Cstd::set< rose_addr_t, std::less< rose_addr_t >, std::allocator< rose_addr_t > >
 Cstd::set< SgAsmInstruction * >
 Cstd::set< SgDeclarationStatement * >
 Cstd::set< SgDirectedGraphEdge * >
 Cstd::set< SgExpression * >
 Cstd::set< SgGraphNode * >
 Cstd::set< SgNode * >
 Cstd::set< SgSymbol * >
 Cstd::set< SgVarRefExp * >
 Cstd::set< ssa_private::UniqueNameTraversal::VarName >
 Cstd::set< std::map< int, std::set< int > > >
 Cstd::set< std::pair< SgGraphNode *, SgGraphNode * > >
 Cstd::set< std::vector< int > >
 Cstd::set< std::vector< SgGraphNode * > >
 CSawyer::Container::Set< T >
 Cstd::set< T >
 Cstd::set< T, C, A >
 Cstd::set< T, std::less< T >, std::allocator< T > >
 Cstd::set< varAffineInequality >
 Cstd::set< varID >
 Cstd::set< VirtualCFG::CFGNode >
 Cstd::set< VirtualCFG::DataflowNode >
 CSawyer::Container::BitVectorSupport::SetBits< Word >
 CRose::BinaryAnalysis::Partitioner2::Engine::SettingsSettings for the engine
 CRose::BinaryAnalysis::Partitioner2::Modules::CfgGraphVizDumper::Settings
 CRose::BinaryAnalysis::Partitioner2::Modules::HexDumper::Settings
 CRose::BinaryAnalysis::Partitioner2::Modules::Debugger::Settings
 CRose::BinaryAnalysis::Partitioner2::Trigger::Settings
 CRose::BinaryAnalysis::Partitioner2::Modules::InstructionLister::Settings
 CRose::BinaryAnalysis::FeasiblePath::SettingsSettings that control this analysis
 CRose::BinaryAnalysis::Strings::StringFinder::SettingsSettings and properties
 CRose::BinaryAnalysis::PointerDetection::SettingsSettings to control the pointer analysis
 CRose::BinaryAnalysis::Unparser::SettingsSettings that control unparsing
 CRose::BinaryAnalysis::BinaryToSource::SettingsSettings to control this translator's behavior
 CSgAsmGenericStrtab
 CSgBinaryNodeThis class represents the base class for all IR nodes supporting the binary representation of software within Sage III
 CSgCopyHelpSupporting class from copy mechanism within ROSE
 CSgGraphTraversal< CFG >
 CSgGraphTraversal< CFGforT >
 CSgGraphTraversal< newGraph >
 CSgNodeThis class represents the base class for all IR nodes within Sage III
 CSgSharedVector< _Tp >
 CSgTreeTraversal< InheritedAttributeType, SynthesizedAttributeType >This class is temporary. Do not use
 CSgTreeTraversal< AttachPreprocessingInfoTreeTraversalInheritedAttrribute, AttachPreprocessingInfoTreeTraversalSynthesizedAttribute >
 CSgTreeTraversal< DummyAttribute, AstNodePtrSynAttr >
 CSgTreeTraversal< DummyAttribute, ChildUses >
 CSgTreeTraversal< DummyAttribute, DummyAttribute >
 CSgTreeTraversal< DummyAttribute, FlattenAST_SynthesizedAttribute >
 CSgTreeTraversal< DummyAttribute, std::vector< SynthesizedAttributeType > * >
 CSgTreeTraversal< DummyAttribute, SynthesizedAttributeType >
 CSgTreeTraversal< DummyAttribute, VariableReferenceSet >
 CSgTreeTraversal< FunctionCallInheritedAttribute, bool >
 CSgTreeTraversal< InheritedAttributeType, DummyAttribute >
 CSgTreeTraversal< size_t, Sawyer::Nothing >
 CSgTreeTraversal< std::vector< InheritedAttributeType > *, DummyAttribute >
 CSgTreeTraversal< std::vector< InheritedAttributeType > *, std::vector< SynthesizedAttributeType > * >
 CSawyer::SharedFromThis< T >Creates SharedPointer from this
 CSawyer::SharedFromThis< Destination >
 CSawyer::SharedFromThis< Function >
 CSawyer::SharedFromThis< Node >
 CSawyer::SharedFromThis< Prefix >
 CSawyer::SharedFromThis< SValue >
 CSawyer::SharedFromThis< ValueParser >
 CSawyer::SharedObjectBase class for reference counted objects
 CSawyer::SharedPointer< T >Reference-counting smart pointer
 CSawyer::SharedPointer< Base >
 CSawyer::SharedPointer< BasicBlock >
 CSawyer::SharedPointer< BasicBlockWorkList >
 CSawyer::SharedPointer< CharacterEncodingForm >
 CSawyer::SharedPointer< CharacterEncodingScheme >
 CSawyer::SharedPointer< class Definition >
 CSawyer::SharedPointer< class Gang >
 CSawyer::SharedPointer< class Merger >
 CSawyer::SharedPointer< class Prefix >
 CSawyer::SharedPointer< class SValue >
 CSawyer::SharedPointer< CodeConstants >
 CSawyer::SharedPointer< CodePointPredicate >
 CSawyer::SharedPointer< DataBlock >
 CSawyer::SharedPointer< Definition >
 CSawyer::SharedPointer< Function >
 CSawyer::SharedPointer< InstructionProvider >
 CSawyer::SharedPointer< LengthEncodingScheme >
 CSawyer::SharedPointer< MemoryMap >
 CSawyer::SharedPointer< Node >
 CSawyer::SharedPointer< Progress >
 CSawyer::SharedPointer< ShouldInline >
 CSawyer::SharedPointer< StateNormalizer >
 CSawyer::SharedPointer< StringEncodingScheme >
 CSawyer::SharedPointer< StringSetParser >
 CSawyer::SharedPointer< SwitchAction >
 CSawyer::SharedPointer< ValueAugmenter >
 CSawyer::SharedPointer< ValueParser >
 CSawyer::SharedPointer< ValueSaver >
 CIntegerOpsPrivate::SHL1Helper< T, Count, TooBig >
 CIntegerOpsPrivate::SHL1Helper< T, Count, false >
 CIntegerOpsPrivate::SHL1Helper< T, Count, true >
 CSgAsmExecutableFileFormat::ShortReadException for reading past the end of something
 CSgAsmExecutableFileFormat::ShortWriteException for writing past the end of something
 CRose::BinaryAnalysis::InstructionSemantics2::SourceAstSemantics::RiscOperators::SideEffectSide effect
 CRose::SimpleRegistryEntry< T >A simple registry entry which provides only a name, description, and no-argument constructor
 CRose::BinaryAnalysis::SymbolicExpr::SimplifierOperator-specific simplification methods
 CSawyer::SingleThreadedTagTag indicating that an algorithm or API can assume only a single thread
 CRose::BinaryAnalysis::AsmUnparser::SkipBackDetails for skip/back reporting
 CSawyer::SmallObjectSmall object support
 Cstd::smart_ptr< T >STL class
 CRose::BinaryAnalysis::SmtSolverInterface to Satisfiability Modulo Theory (SMT) solvers
 CRose::BinaryAnalysis::AsmFunctionIndex::SortByBeginAddrFunctor for sorting by function beginning address
 CRose::BinaryAnalysis::AsmFunctionIndex::SortByBytesSizeFunctor for sorting by number of bytes in function
 CRose::BinaryAnalysis::AsmFunctionIndex::SortByEntryAddrFunctor for sorting by function entry virtual address
 CRose::BinaryAnalysis::AsmFunctionIndex::SortByInsnsSizeFunctor for sorting by number of instructions in function
 CRose::BinaryAnalysis::AsmFunctionIndex::SortByNameFunctor to sort functions by name
 CRegisterDictionary::SortBySizeCompares number of bits in register descriptors
 CAbstractHandle::source_positionSource position information:
 CAbstractHandle::source_position_pair
 CSourceLocationInheritedAttribute
 CSpearExpr
 CAbstractHandle::specifierConstruct specifier could be used to specify a construct by name, position, numbering, labels, etc (e_name, foo) (e_position, 15)
 CSawyer::Message::SProxy
 CRose::BinaryAnalysis::DwarfLineMapper::SrcInfoSource location info
 CRose::BinaryAnalysis::SRecordMotorola S-Record
 Cssa_unfiltered_cfg::SSA_UnfilteredCfg
 CSawyer::Container::Stack< T >Stack-based container
 Cstd::stack< T >STL class
 CSawyer::Container::Stack< size_t >
 CSawyer::StackAllocator< T >Stack-like allocator
 CSawyer::StackAllocator< size_t >
 CStackFrameVector< T >
 CRose::BinaryAnalysis::StackVariableA multi-byte variable that appears on the stack
 CRose::BinaryAnalysis::StackVariableLocationInformation about the location of a stack variable
 CRose::BinaryAnalysis::StackVariableMetaMeta information for a stack variable
 CRose::BinaryAnalysis::Unparser::StateState for unparsing
 CState
 CRose::BinaryAnalysis::TaintedFlow::StateTaint state
 CSageInterface::StatementGeneratorInterface for creating a statement whose computation writes its answer into a given variable
 CStaticSingleAssignmentStatic single assignment analysis
 CRose::BinaryAnalysis::SmtSolver::StatsSMT solver statistics
 CSawyer::StopwatchSimple elapsed time
 CSawyer::Attribute::Storage< SyncTag >API and storage for attributes
 CSawyer::Attribute::Storage<>
 Cstream_element
 Cstreambuf
 CRose::Diagnostics::StreamPrintfIntermediate class for printing to C++ ostreams with a printf-like API
 CRose::BinaryAnalysis::Strings::StringFinderAnalysis to find encoded strings
 CRose::StringifierShortens names of long stringifiers
 CRose::StringUtility::StringWithLineNumberString with source location information
 CStructCustomizedSizesSupport for cross compilation or extended UPC support
 CStructLayoutEntry
 CStructLayoutInfo
 CRose::EditDistance::TreeEditDistance::SubstitutionPredicateBase class for substitution prediates
 CRose::BinaryAnalysis::Partitioner2::BasicBlock::SuccessorBasic block successor
 CSawyer::Container::Trace< T, IndexTag >::SuccessorCompressed next-label list
 CSuper
 CSValue
 CSawyer::Container::BitVectorSupport::SwapBits< Word >
 CSawyer::CommandLine::SwitchDescribes one command-line switch
 CSawyer::CommandLine::SwitchArgumentDescribes one argument of a command-line switch
 CSawyer::CommandLine::SwitchGroupA collection of related switch declarations
 CRose::BinaryAnalysis::SymbolicExprParserParses symbolic expressions from text
 CRose::BinaryAnalysis::BinaryLoaderElf::SymbolMapEntryAn entry for a SymbolMap
 CRose::BinaryAnalysis::BinaryLoaderElf::SymverResolver
 CSawyer::SynchronizationTraits< SyncTag >Traits for thread synchronization
 CSawyer::SynchronizationTraits< MultiThreadedTag >
 CSawyer::SynchronizationTraits< Sawyer::Sawyer::SingleThreadedTag >
 CSawyer::SynchronizationTraits< Sawyer::SingleThreadedTag >
 CSawyer::SynchronizationTraits< SingleThreadedTag >
 Cstd::system_errorSTL class
 CSqlDatabase::Table< T00, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15 >In-memory representation of a database table
 CRose::BinaryAnalysis::TaintedFlowVarious tools for performing tainted flow analysis
 CSawyer::TemporaryCallback< Callback >
 CSawyer::FileSystem::TemporaryDirectoryCreate a temporary directory
 CSawyer::FileSystem::TemporaryFileCreates a temporary file
 CTerminalNamesType
 CRose::BinaryAnalysis::InstructionSemantics2::TestSemantics< SValuePtr, RegisterStatePtr, MemoryStatePtr, StatePtr, RiscOperatorsPtr >Provides functions for testing binary instruction semantics
 Cstd::threadSTL class
 CSawyer::ThreadWorkers< DependencyGraph, Functor >Work list with dependencies
 CRose::BinaryAnalysis::Partitioner2::Partitioner::ThunkRepresents information about a thunk
 CRose::BinaryAnalysis::SymbolicExprParser::TokenTokens generated by the lexical analysis
 CSawyer::Lexer::Token< T >Represents one token of input
 Ctoken_element
 CSgToken::token_element
 CSawyer::Lexer::TokenStream< T >An ordered list of tokens scanned from input
 CRose::BinaryAnalysis::SymbolicExprParser::TokenStreamA stream of tokens
 CSawyer::Lexer::TokenStream< Token >
 CSawyer::Container::BitVectorSupport::ToString< Word, bitsPerDigit >
 CSawyer::Container::Trace< T, IndexTag >Records and replays traces
 CSawyer::Container::TraceIndexTraits< Label, Value, IndexTypeTag >Traits for a Trace label index
 CSawyer::Container::TraceIndexTraits< Label, Successors, IndexTag >
 CSawyer::Container::TraceIndexTraits< Label, Value, TraceVectorIndexTag >
 CSawyer::Container::TraceMapIndexTagTag for a map-based Trace label index
 CSawyer::Container::TraceVectorIndexTagTag for a vector-based Trace label index
 CRose::BinaryAnalysis::InstructionSemantics2::LlvmSemantics::TranscoderTranslates machine instructions to LLVM
 CRose::BinaryAnalysis::Partitioner2::DataFlow::TransferFunctionData-Flow transfer functor
 CRose::BinaryAnalysis::TaintedFlow::TransferFunction
 CSageInterface::Transformation_Record
 CTransformationSupportThis class simplifies the development of queries on the AST resulting in a list of AST nodes.This class holds functions that are generally useful for a broad cross-section of transformations. Functionality specific to any specific transformation should be represented in a similar transformation support class that is a part of the preprocessor source code representing that specific transformation
 CTranslator
 CTraverseCallGraph
 CTraverseToRoot< InheritedAttributeType, SynthesizedAttributeType >
 CRose::BinaryAnalysis::Partitioner2::TriggerTrigger based on number of times called
 CSqlDatabase::Table< T00, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15 >::TupleOne row of a table
 CAstDOTGenerationExtended_Defaults::TypeExtraNodeInfo
 Csg::TypeRecoveryHandler< SageNode >
 CAbstractHandle::u_specifier_value
 Cunary_function
 Cstd::unique_ptr< T >STL class
 Cstd::unordered_map< K, T >STL class
 Cstd::unordered_multimap< K, T >STL class
 Cunordered_multimap< SgName, SgSymbol *, hash_Name, eqstr >
 Cstd::unordered_multiset< K >STL class
 Cstd::unordered_set< K >STL class
 CRose::BinaryAnalysis::AsmUnparser::UnparserCallback
 CUtf8
 Cstd::valarray< T >STL class
 CSawyer::CommandLine::Boost::value< T >Replacement for basic use of boost::program_options::value
 CIntegerOpsPrivate::value)>
 CSawyer::Container::Map< K, T, Cmp, Alloc >::ValueIteratorBidirectional iterator over values
 CSawyer::Container::IndexedList< T, Alloc >::ValueIteratorList value bidirectional iterator
 CRose::BinaryAnalysis::FeasiblePath::VarDetailInformation about a variable seen on a path
 Cvariable
 Cssa_private::VariableReferenceSetAttribute that describes the variables modified by a given expression
 CSawyer::CommandLine::Boost::variables_mapWrapper around ParserResult
 Csg::VarRefBuilderFunctor building a variable reference from an initialized name
 Cstd::vector< T >STL class
 Cstd::vector< AstData * >
 Cstd::vector< AtomExpansion::Ptr >
 Cstd::vector< BaseSemantics::RiscOperatorsPtr >
 Cstd::vector< BaseSemantics::SValuePtr >
 Cstd::vector< bool >
 Cstd::vector< boost::graph_traits< ControlFlowGraph >::vertex_descriptor >
 Cstd::vector< BoostEdgeType >
 Cstd::vector< CartesianPoint >
 Cstd::vector< Category >
 Cstd::vector< CFG * >
 Cstd::vector< CFGforT * >
 Cstd::vector< CharacteristicValues >
 Cstd::vector< CodePoint >
 Cstd::vector< ControlFlowGraph::ConstEdgeIterator >
 Cstd::vector< Definition::Ptr >
 Cstd::vector< DispatchEntry >
 Cstd::vector< double >
 Cstd::vector< FormalArg >
 Cstd::vector< Frame >
 Cstd::vector< FunctionCallInfo >
 Cstd::vector< FunctionPaddingMatcher::Ptr >
 Cstd::vector< FunctionPrologueMatcher::Ptr >
 Cstd::vector< IdisList >
 Cstd::vector< InheritedAttributeType >
 Cstd::vector< InsnProcessor * >
 Cstd::vector< int >
 Cstd::vector< Label >
 Cstd::vector< Lattice * >
 Cstd::vector< MyLoop * >
 Cstd::vector< newGraph * >
 Cstd::vector< Node * >
 Cstd::vector< NodeFact * >
 Cstd::vector< NodeState * >
 Cstd::vector< NodeType >
 Cstd::vector< omp_construct_enum >
 Cstd::vector< OmpSupport::OmpAttribute * >
 Cstd::vector< OperandDefn >
 Cstd::vector< OperatorExpansion::Ptr >
 Cstd::vector< OrderedList >
 Cstd::vector< Organization >
 Cstd::vector< ParsedValue >
 Cstd::vector< ParserSep >
 Cstd::vector< Partitioner2::Function::Ptr >
 Cstd::vector< PreprocessingInfo * >
 Cstd::vector< Ptr >
 Cstd::vector< RegisterDescriptor >
 Cstd::vector< Rose::BinaryAnalysis::BinaryLoader * >
 Cstd::vector< Rose::BinaryAnalysis::BinaryLoaderElf::VersionedSymbol >
 Cstd::vector< Rose::BinaryAnalysis::CallingConvention::ParameterLocation >
 Cstd::vector< Rose::BinaryAnalysis::Disassembler * >
 Cstd::vector< Rose::BinaryAnalysis::DisassemblerMips::Mips32 * >
 Cstd::vector< Rose::BinaryAnalysis::Partitioner2::AddressUser >
 Cstd::vector< Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr >
 Cstd::vector< Rose::BinaryAnalysis::Partitioner2::DataBlock::Sawyer::SharedPointer >
 Cstd::vector< Rose::BinaryAnalysis::Partitioner2::DataBlock::SharedPointer< BasicBlock > >
 Cstd::vector< Rose::BinaryAnalysis::Partitioner2::Function::Ptr >
 Cstd::vector< Rose::BinaryAnalysis::Partitioner2::GraphViz::Coordinate >
 Cstd::vector< Rose::BinaryAnalysis::SmtSolver::SExpr::Ptr >
 Cstd::vector< Rose::BinaryAnalysis::Strings::EncodedString >
 Cstd::vector< Rose::BinaryAnalysis::Strings::StringEncodingScheme::Ptr >
 Cstd::vector< Rose::BinaryAnalysis::SymbolicExprParser::Token >
 Cstd::vector< Rose::Progress::Report >
 Cstd::vector< rose_addr_t >
 Cstd::vector< Sawyer::CommandLine::Switch >
 Cstd::vector< Sawyer::CommandLine::SwitchArgument >
 Cstd::vector< Sawyer::CommandLine::SwitchGroup >
 Cstd::vector< Sawyer::Container::DenseIntegerSet::Member >
 Cstd::vector< Sawyer::Message::SProxy >
 Cstd::vector< Sawyer::SharedPointer >
 Cstd::vector< SgAsmFunction * >
 Cstd::vector< SgAsmInstruction * >
 Cstd::vector< SgAsmStaticData * >
 Cstd::vector< SgDirectory * >
 Cstd::vector< SgExpression * >
 Cstd::vector< SgFile * >
 Cstd::vector< SgFileId >
 Cstd::vector< SgGraphNode * >
 Cstd::vector< SgInitializedName * >
 Cstd::vector< SgInitializedName::asm_register_name_enum >
 Cstd::vector< SgModifierType * >
 Cstd::vector< SgNode * >
 Cstd::vector< SgScopeStatement * >
 Cstd::vector< SgStatement * >
 Cstd::vector< SgVariableDeclaration * >
 Cstd::vector< SharedPointer< class SValue > >
 Cstd::vector< SideEffect >
 Cstd::vector< size_t * >
 Cstd::vector< size_t >
 Cstd::vector< StackVariable >
 Cstd::vector< State >
 Cstd::vector< StatePtr >
 Cstd::vector< std::list< token_type > >
 Cstd::vector< std::map< Vertex, Vertex > >
 Cstd::vector< std::pair< omp_construct_enum, SgExpression * > >
 Cstd::vector< std::pair< SgExpression *, SgExpression * > >
 Cstd::vector< std::pair< SgGraphNode *, int > >
 Cstd::vector< std::pair< SgOmpClause::omp_map_dist_data_enum, SgExpression * > >
 Cstd::vector< std::pair< std::string, SgNode * > >
 Cstd::vector< std::pair< std::vector< size_t >, std::vector< size_t > > >
 Cstd::vector< std::pair< unsigned char, unsigned char > >
 Cstd::vector< std::set< int > >
 Cstd::vector< std::set< SgGraphNode * > >
 Cstd::vector< std::string >
 Cstd::vector< std::vector< int > >
 Cstd::vector< std::vector< SgGraphNode * > >
 Cstd::vector< std::vector< SymbolicExpr::Ptr > >
 Cstd::vector< StructLayoutEntry >
 Cstd::vector< SValuePtr >
 Cstd::vector< SymbolicExpr::Ptr >
 Cstd::vector< Tag::Sawyer::SharedPointer >
 Cstd::vector< Token >
 Cstd::vector< token_type >
 Cstd::vector< TraversalPtr >
 Cstd::vector< Tuple >
 Cstd::vector< typename boost::graph_traits< CFG >::edge_descriptor >
 Cstd::vector< typename boost::graph_traits< CFG >::vertex_descriptor >
 Cstd::vector< uint16_t >
 Cstd::vector< uint8_t >
 Cstd::vector< unsigned >
 Cstd::vector< Value >
 Cstd::vector< Vertex >
 Cstd::vector< VirtualCFG::CFGEdge >
 Cstd::vector< VirtualCFG::CFGPath >
 Cstd::vector< Word >
 Cstd::vector< Words >
 CSawyer::Container::TraceDetail::VectorIndex< K, V >
 CRose::BinaryAnalysis::BinaryLoaderElf::VersionedSymbolSymbol from .dynsym combined with additional information
 CSawyer::Container::Graph< V, E, VKey, EKey, Alloc >::VertexVertex node
 CVertex
 CVertex2
 CSawyer::Boost::vertex_id_t
 CSawyer::Boost::vertex_value_t
 Cssa_private::CFG< CFGNodeT, CFGEdgeT >::VertexCopierThis class is used to copy vertices when calling copy_graph()
 CBackstroke::CFG< CFGNodeFilter >::VertexCopierThis class is used to copy vertices when calling copy_graph()
 CRose::BinaryAnalysis::ControlFlow::VertexFilterFilter for vertices
 CRose::BinaryAnalysis::FunctionCall::VertexFilterFilter for vertices
 CRose::BinaryAnalysis::Partitioner2::GraphViz::VertexPositionPosition of a vertex
 CSawyer::Boost::VertexPropertyMap< Graph >
 CSawyer::Container::Graph< V, E, VKey, EKey, Alloc >::VirtualList< Edge >
 CSawyer::Container::Graph< V, E, VKey, EKey, Alloc >::VirtualList< Sawyer::Container::Graph::Edge >
 CSawyer::Container::AddressMap< A, T >::VisitorBase class for traversals
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::MemoryCell::VisitorVisitor for traversing a cells
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterStateGeneric::VisitorFunctors for traversing register values in a register state
 CRose::BinaryAnalysis::SymbolicExpr::VisitorBase class for visiting nodes during expression traversal
 Cstd::weak_ptr< T >STL class
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterState::WithFormatterRegisterState with formatter
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::MemoryState::WithFormatterMemoryState with formatter
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::MemoryCell::WithFormatterState with formatter
 CRose::BinaryAnalysis::SymbolicExpr::Node::WithFormatterA node with formatter
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators::WithFormatterRiscOperators with formatter
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::State::WithFormatterState with formatter
 CRose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::SValue::WithFormatterSValue with formatter
 CRose::ParallelSort::Private::Work< RandomAccessIterator >
 CSawyer::Container::Algorithm::GraphTraversal< G, Order, Direction >::Work
 CRose::ParallelSort::Private::Worker< RandomAccessIterator, Compare >
 CWorkList< T, Compare >List of things to work on
 Cwrap_data_used_by_AttachPreprocessingInfoTreeTrav_t
 CXOMP_accelerator_thread
 CXOMP_mapped_variable
 CSawyer::Container::BitVectorSupport::XorBits< Word >
 CYYLTYPE
 CYYSTYPE
 CA
 CAlloc
 CBaseIter
 CBaseIterator
 Ccerr
 Ccout
 CDEBUG
 CDEBUG
 Cendl
 CERROR
 CERROR
 CFacilities
 CFacility
 CFATAL
 CFATAL
 CG
 Chash
 CINFO
 CINFO
 CK
 Cmake_pair
 CMARCH
 CMARCH
 Cmfacilities
 Cpair
 CPolicy
 CStream
 CT
 CTRACE
 CTRACE
 Cunordered_map
 Cunordered_multimap
 Cunordered_set
 CVList
 CWARN
 CWARN
 CWHERE
 CWHERE