ROSE  0.11.98.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/Disassembler/BasicTypes.h>
8 #include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/Types.h>
9 #include <Rose/BinaryAnalysis/ModelChecker/Types.h>
10 #include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
11 
12 #include <Sawyer/SharedPointer.h>
13 #include <memory>
14 
15 namespace Rose {
16 namespace BinaryAnalysis {
17 
18 // Document definitions, but not forwared declarations.
19 
20 class AbstractLocation;
21 class AsmFunctionIndex;
22 class AstHash;
23 class BestMapAddress;
24 class BinaryLoader;
25 using BinaryLoaderPtr = Sawyer::SharedPointer<BinaryLoader>;
26 class BinaryLoaderElf;
27 using BinaryLoaderElfPtr = Sawyer::SharedPointer<BinaryLoaderElf>;
28 class BinaryLoaderElfObj;
29 using BinaryLoaderElfObjPtr = Sawyer::SharedPointer<BinaryLoaderElfObj>;
30 class BinaryLoaderPe;
31 using BinaryLoaderPePtr = Sawyer::SharedPointer<BinaryLoaderPe>;
32 class BinaryToSource;
33 class CodeInserter;
34 class ConcreteLocation;
35 class DataFlow;
36 class Debugger;
37 using DebuggerPtr = Sawyer::SharedPointer<Debugger>;
38 class Demangler;
39 class FeasiblePath;
40 class FunctionCall;
41 class FunctionSimilarity;
42 class HotPatch;
43 class InstructionCache;
44 class InstructionPtr;
45 class LibraryIdentification;
46 class LockedInstruction;
47 class MagicNumber;
48 class ManagedInstruction;
49 class MemoryMap;
50 using MemoryMapPtr = Sawyer::SharedPointer<MemoryMap>;
51 class NoOperation;
52 class Reachability;
53 class RegisterDictionary;
54 using RegisterDictionaryPtr = Sawyer::SharedPointer<RegisterDictionary>;
55 class RegisterNames;
56 class RegisterParts;
57 class SerialInput;
58 using SerialInputPtr = Sawyer::SharedPointer<SerialInput>;
59 class SerialIo;
60 using SerialIoPtr = Sawyer::SharedPointer<SerialIo>;
61 class SerialOutput;
62 using SerialOutputPtr = Sawyer::SharedPointer<SerialOutput>;
63 class SmtlibSolver;
64 class SmtSolver;
65 using SmtSolverPtr = std::shared_ptr<SmtSolver>;
66 class SourceLocations;
67 class SRecord;
68 class SymbolicExprParser;
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 SymbolicExpr {
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
Operator-specific simplification methods.
Definition: SymbolicExpr.h:881
Settings to control the pointer analysis.
Leaf node of an expression tree for instruction semantics.
Description of a global variable.
Definition: Variables.h:280
Interior node of an expression tree for instruction semantics.
Defines the mapping between code values and octets.
Definition: String.h:334
Mapping from expression to expression.
Definition: SymbolicExpr.h:918
Analysis to find variable locations.
Definition: Variables.h:406
Describes a local or global variable.
Definition: Variables.h:66
Terminated string encoding scheme.
Definition: String.h:694
Analysis to find encoded strings.
Definition: String.h:806
Type of symbolic expression.
Definition: SymbolicExpr.h:223
Main namespace for the ROSE library.
Controls formatting of expression trees when printing.
Definition: SymbolicExpr.h:163
Reference-counting intrusive smart pointer.
Definition: SharedPointer.h:68
An encoder plus interval.
Definition: String.h:757
Encoding for the length of a string.
Definition: String.h:409
Information about calling conventions.
Defines mapping between code points and code values.
Definition: String.h:221
Information about a stack frame.
Definition: Variables.h:387
Binary analysis.
Exceptions for symbolic expressions.
Definition: SymbolicExpr.h:70
Base class for symbolic expression nodes.
Definition: SymbolicExpr.h:456
Errors for string analysis.
Definition: String.h:180
Length-prefixed string encoding scheme.
Definition: String.h:629
Base class for visiting nodes during expression traversal.
Definition: SymbolicExpr.h:207
Description of a local stack variable within a function.
Definition: Variables.h:146