ROSE  0.11.131.0
BinaryAnalysis/BasicTypes.h
1 #ifndef ROSE_BinaryAnalysis_BasicTypes_H
2 #define ROSE_BinaryAnalysis_BasicTypes_H
3 #include <featureTests.h>
4 #ifdef ROSE_ENABLE_BINARY_ANALYSIS
5 
6 // #include's for subdirectories and sub-namespaces are at the end of this header.
7 #include <Sawyer/SharedPointer.h>
8 #include <memory>
9 
10 namespace Rose {
11 namespace BinaryAnalysis {
12 
13 // Document definitions, but not forwared declarations.
14 
15 class AbstractLocation;
16 class AsmFunctionIndex;
17 class AstHash;
18 class BestMapAddress;
19 class BinaryLoader;
21 class BinaryLoaderElf;
23 class BinaryLoaderElfObj;
25 class BinaryLoaderPe;
27 class BinaryToSource;
28 class CodeInserter;
29 class ConcreteLocation;
30 class DataFlow;
31 class Demangler;
32 class FeasiblePath;
33 class FunctionCall;
34 class FunctionSimilarity;
35 class HotPatch;
36 class InstructionCache;
37 class InstructionPtr;
38 class LibraryIdentification;
39 class LockedInstruction;
40 class MagicNumber;
41 class ManagedInstruction;
42 class MemoryMap;
44 class NoOperation;
45 class Reachability;
46 using RegisterDescriptors = std::vector<RegisterDescriptor>;
47 class RegisterDictionary;
49 class RegisterNames;
50 class RegisterParts;
51 class SerialInput;
53 class SerialIo;
55 class SerialOutput;
57 class SmtlibSolver;
58 class SmtSolver;
59 using SmtSolverPtr = std::shared_ptr<SmtSolver>;
60 class SourceLocations;
61 class SRecord;
62 class SymbolicExpresssionParser;
63 class SystemCall;
64 class TaintedFlow;
65 class Z3Solver;
66 
67 namespace CallingConvention {
68 class Analysis;
69 class Definition;
71 } // namespace
72 
73 namespace PointerDetection {
74 class Analysis;
75 class PointerDescriptor;
76 class Settings;
77 } // namespace
78 
79 namespace ReturnValueUsed {
80 class Analysis;
81 class CallSiteResults;
82 } // namespace
83 
84 namespace StackDelta {
85 class Analysis;
86 } // namespace
87 
88 namespace Strings {
89 class AnyCodePoint;
94 class CodePointPredicate;
95 class EncodedString;
96 class Exception;
100 class PrintableAscii;
102 class StringFinder;
103 class TerminatedString;
106 } // namespace
107 
108 namespace SymbolicExpression {
109 class Exception;
110 class ExprExprHashMap;
111 class Formatter;
112 class Interior;
114 class Leaf;
116 class Node;
118 class Simplifier;
119 class Type;
120 class Visitor;
121 } // namespace
123 
124 namespace Variables {
125 class BaseVariable;
126 class GlobalVariable;
127 class StackFrame;
128 class StackVariable;
129 class VariableFinder;
131 } // namespace
132 
133 } // namespace
134 } // namespace
135 
136 #endif
137 
138 // #include's for sub-namespaces and sub-directories
139 #include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
140 #include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>
141 #include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
142 #include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
143 #include <Rose/BinaryAnalysis/ModelChecker/Types.h>
144 #include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
145 
146 #endif
Information about a stack frame.
Definition: Variables.h:441
Interface to the Z3 SMT solver.
Definition: Z3Solver.h:33
A loader suitable for ELF object files.
Description of a global variable.
Definition: Variables.h:302
Base class for visiting nodes during expression traversal.
Defines the mapping between code values and octets.
Definition: String.h:334
Describes how to modify machine state after each instruction.
Definition: HotPatch.h:22
Demangle mangled names.
Definition: Demangler.h:10
Bidirectional mapping between addresses and source locations.
Analysis to find variable locations.
Definition: Variables.h:461
Describes a local or global variable.
Definition: Variables.h:73
Convert binary to low-level C source code.
Definition: ToSource.h:22
Loader for Windows PE files.
Various tools for performing tainted flow analysis.
Definition: TaintedFlow.h:18
Base class for symbolic expression nodes.
Output binary analysis state.
Definition: SerialIo.h:268
Terminated string encoding scheme.
Definition: String.h:694
Analysis to find encoded strings.
Definition: String.h:806
Settings to control the pointer analysis.
Main namespace for the ROSE library.
Binary function call analysis.
Definition: FunctionCall.h:21
Holds a set of registers without regard for register boundaries.
Definition: RegisterParts.h:28
Base class for binary state input and output.
Definition: SerialIo.h:112
Feasible path analysis.
Definition: FeasiblePath.h:23
S-Record hexadecimal data formats.
Definition: SRecord.h:27
Analyzes basic blocks to get system call names.
Definition: SystemCall.h:22
Operator-specific simplification methods.
std::vector< RegisterDescriptor > RegisterDescriptors
List of register descriptors in dictionary.
An encoder plus interval.
Definition: String.h:757
Insert new code in place of existing instructions.
Definition: CodeInserter.h:21
Encoding for the length of a string.
Definition: String.h:409
Information about calling conventions.
Convert a register descriptor to a name.
Definition: RegisterNames.h:19
An efficient mapping from an address space to stored data.
Definition: MemoryMap.h:112
Defines mapping between code points and code values.
Definition: String.h:221
Wrapper around solvers that speak SMT-LIB.
Definition: SmtlibSolver.h:14
Analysis that computes reachability of CFG vertices.
Definition: Reachability.h:22
Analysis to test the similarity of two functions.
Various tools for data-flow analysis.
Definition: DataFlow.h:69
Controls formatting of expression trees when printing.
Sawyer::SharedPointer< Node > Ptr
Reference counting pointer.
std::shared_ptr< SmtSolver > SmtSolverPtr
Reference counting pointer.
Leaf node of an expression tree for instruction semantics.
Errors for string analysis.
Definition: String.h:180
Interior node of an expression tree for instruction semantics.
Interface to Satisfiability Modulo Theory (SMT) solvers.
Definition: SmtSolver.h:39
Defines registers available for a particular architecture.
Length-prefixed string encoding scheme.
Definition: String.h:629
Analysis that looks for no-op equivalents.
Definition: NoOperation.h:14
Input binary analysis state.
Definition: SerialIo.h:437
Description of a local stack variable within a function.
Definition: Variables.h:153