ROSE  0.11.145.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 <Rose/BinaryAnalysis/RegisterDescriptor.h>
8 #include <Sawyer/SharedPointer.h>
9 #include <memory>
10 
11 namespace Rose {
12 namespace BinaryAnalysis {
13 
14 // Document definitions, but not forwared declarations.
15 
16 class AbstractLocation;
17 class AsmFunctionIndex;
18 class AstHash;
19 class BestMapAddress;
20 class BinaryLoader;
22 class BinaryLoaderElf;
24 class BinaryLoaderElfObj;
26 class BinaryLoaderPe;
28 class BinaryToSource;
29 class CodeInserter;
30 class ConcreteLocation;
31 class DataFlow;
32 class Demangler;
33 class FeasiblePath;
34 class FunctionCall;
35 class FunctionSimilarity;
36 class HotPatch;
37 class InstructionCache;
38 class InstructionPtr;
39 class LibraryIdentification;
40 class LockedInstruction;
41 class MagicNumber;
42 class ManagedInstruction;
43 class MemoryMap;
45 class NoOperation;
46 class Reachability;
47 using RegisterDescriptors = std::vector<RegisterDescriptor>;
48 class RegisterDictionary;
50 class RegisterNames;
51 class RegisterParts;
52 class SerialInput;
54 class SerialIo;
56 class SerialOutput;
58 class SmtlibSolver;
59 class SmtSolver;
60 using SmtSolverPtr = std::shared_ptr<SmtSolver>;
61 class SourceLocations;
62 class SRecord;
63 class SymbolicExpresssionParser;
64 class SystemCall;
65 class TaintedFlow;
66 class Z3Solver;
67 
68 namespace CallingConvention {
69 class Analysis;
70 class Definition;
72 } // namespace
73 
74 namespace PointerDetection {
75 class Analysis;
76 class PointerDescriptor;
77 class Settings;
78 } // namespace
79 
80 namespace ReturnValueUsed {
81 class Analysis;
82 class CallSiteResults;
83 } // namespace
84 
85 namespace StackDelta {
86 class Analysis;
87 } // namespace
88 
89 namespace Strings {
90 class AnyCodePoint;
95 class CodePointPredicate;
96 class EncodedString;
97 class Exception;
101 class PrintableAscii;
103 class StringFinder;
104 class TerminatedString;
107 } // namespace
108 
109 namespace SymbolicExpression {
110 class Exception;
111 class ExprExprHashMap;
112 class Formatter;
113 class Interior;
115 class Leaf;
117 class Node;
119 class Simplifier;
120 class Type;
121 class Visitor;
122 } // namespace
124 
125 namespace Variables {
126 class BaseVariable;
127 class GlobalVariable;
128 class StackFrame;
129 class StackVariable;
130 class VariableFinder;
132 } // namespace
133 
134 } // namespace
135 } // namespace
136 
137 #endif
138 
139 // #include's for sub-namespaces and sub-directories
140 #include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
141 #include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>
142 #include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
143 #include <Rose/BinaryAnalysis/Dwarf/BasicTypes.h>
144 #include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
145 #include <Rose/BinaryAnalysis/ModelChecker/Types.h>
146 #include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
147 
148 #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