ROSE  0.11.109.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 <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
7 #include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>
8 #include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
9 #include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/Types.h>
10 #include <Rose/BinaryAnalysis/ModelChecker/Types.h>
11 #include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
12 
13 #include <Sawyer/SharedPointer.h>
14 #include <memory>
15 
16 namespace Rose {
17 namespace BinaryAnalysis {
18 
19 // Document definitions, but not forwared declarations.
20 
21 class AbstractLocation;
22 class AsmFunctionIndex;
23 class AstHash;
24 class BestMapAddress;
25 class BinaryLoader;
27 class BinaryLoaderElf;
29 class BinaryLoaderElfObj;
31 class BinaryLoaderPe;
33 class BinaryToSource;
34 class CodeInserter;
35 class ConcreteLocation;
36 class DataFlow;
37 class Demangler;
38 class FeasiblePath;
39 class FunctionCall;
40 class FunctionSimilarity;
41 class HotPatch;
42 class InstructionCache;
43 class InstructionPtr;
44 class LibraryIdentification;
45 class LockedInstruction;
46 class MagicNumber;
47 class ManagedInstruction;
48 class MemoryMap;
50 class NoOperation;
51 class Reachability;
52 using RegisterDescriptors = std::vector<RegisterDescriptor>;
53 class RegisterDictionary;
55 class RegisterNames;
56 class RegisterParts;
57 class SerialInput;
59 class SerialIo;
61 class SerialOutput;
63 class SmtlibSolver;
64 class SmtSolver;
65 using SmtSolverPtr = std::shared_ptr<SmtSolver>;
66 class SourceLocations;
67 class SRecord;
68 class SymbolicExpresssionParser;
69 class SystemCall;
70 class TaintedFlow;
71 class Z3Solver;
72 
73 namespace CallingConvention {
74 class Analysis;
75 class Definition;
77 } // namespace
78 
79 namespace PointerDetection {
80 class Analysis;
81 class PointerDescriptor;
82 class Settings;
83 } // namespace
84 
85 namespace ReturnValueUsed {
86 class Analysis;
87 class CallSiteResults;
88 } // namespace
89 
90 namespace StackDelta {
91 class Analysis;
92 } // namespace
93 
94 namespace Strings {
95 class AnyCodePoint;
100 class CodePointPredicate;
101 class EncodedString;
102 class Exception;
103 class LengthEncodedString;
106 class PrintableAscii;
108 class StringFinder;
109 class TerminatedString;
112 } // namespace
113 
114 namespace SymbolicExpression {
115 class Exception;
116 class ExprExprHashMap;
117 class Formatter;
118 class Interior;
120 class Leaf;
122 class Node;
124 class Simplifier;
125 class Type;
126 class Visitor;
127 } // namespace
128 
129 namespace Variables {
130 class BaseVariable;
131 class GlobalVariable;
132 class StackFrame;
133 class StackVariable;
134 class VariableFinder;
136 } // namespace
137 
138 } // namespace
139 } // namespace
140 
141 #endif
142 #endif
Information about a stack frame.
Definition: Variables.h:387
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:280
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
Bidirectional mapping between addresses and source locations.
Analysis to find variable locations.
Definition: Variables.h:407
Describes a local or global variable.
Definition: Variables.h:66
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:272
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:116
Reference-counting intrusive smart pointer.
Definition: SharedPointer.h:68
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:17
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.
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:441
Description of a local stack variable within a function.
Definition: Variables.h:146