1. Replace springboards prioriy "OffLimits" and "Required" with "FuncEntry" and ...
[dyninst.git] / dyninstAPI / src / Relocation / Transformers / Movement-analysis.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #if !defined(_R_T_MOVEMENT_ANALYSIS_H_)
32 #define _R_T_MOVEMENT_ANALYSIS_H_
33
34 #include "Transformer.h"
35 #include "dyninstAPI/src/LinearVariable.h"
36
37 #include "dataflowAPI/h/Absloc.h" // MemEmulator analysis
38 #include "dataflowAPI/h/AbslocInterface.h" // And more of the same
39
40 #include "common/h/Graph.h" // PC-sensitive transformer
41 #include "dataflowAPI/h/SymEval.h" // Variable class
42 #include "Movement-adhoc.h"
43 #include "../CodeMover.h"
44
45 class parse_block;
46 class parse_func;
47
48 namespace Dyninst {
49
50 // ROSE symeval AST types
51  namespace DataflowAPI {
52  class BottomAST;
53  class ConstantAST;
54  class AbsRegionAST;
55  class RoseAST;
56  };
57
58  class StackAST;
59
60 namespace Relocation {
61
62 class ExtPCSensVisitor : public ASTVisitor {
63  public:
64   ExtPCSensVisitor(const AbsRegion &a);
65   
66   virtual AST::Ptr visit(AST *);
67   virtual AST::Ptr visit(DataflowAPI::BottomAST *);
68   virtual AST::Ptr visit(DataflowAPI::ConstantAST *);
69   virtual AST::Ptr visit(DataflowAPI::VariableAST *);
70   virtual AST::Ptr visit(DataflowAPI::RoseAST *);
71   virtual AST::Ptr visit(StackAST *);
72   virtual ASTVisitor::ASTPtr visit(InputVariableAST *x) { return ASTVisitor::visit(x); }
73   virtual ASTVisitor::ASTPtr visit(ReferenceAST *x) { return ASTVisitor::visit(x); }
74   virtual ASTVisitor::ASTPtr visit(StpAST *x) { return ASTVisitor::visit(x); }
75   virtual ASTVisitor::ASTPtr visit(YicesAST *x) { return ASTVisitor::visit(x); }
76   virtual ASTVisitor::ASTPtr visit(SemanticsAST *x) { return ASTVisitor::visit(x); }
77
78
79   virtual ~ExtPCSensVisitor() {};
80   
81   bool isExtSens(AST::Ptr a);
82
83  private:
84   bool assignPC_;
85   bool isExtSens_;
86
87   typedef linVar<Dyninst::DataflowAPI::Variable> DiffVar;
88
89   std::stack<DiffVar > diffs_;
90 };
91  
92 class PCSensitiveTransformer : public Transformer {
93   typedef boost::shared_ptr<RelocInsn> RelocInsnPtr;
94   typedef std::list<Assignment::Ptr> AssignList;
95
96  public:
97   virtual bool process(RelocBlock *, RelocGraph *);
98
99   PCSensitiveTransformer(AddressSpace *as, PriorityMap &p) 
100         : aConverter(false, false), addrSpace(as), priMap(p),
101      Sens_(0), extSens_(0), intSens_(0), thunk_(0), overApprox_(0), adhoc(as) {};
102   virtual ~PCSensitiveTransformer() {};
103
104   static void invalidateCache(func_instance *);
105   static void invalidateCache(const block_instance *);
106
107  private:
108   bool analysisRequired(RelocBlock *);
109
110   bool isPCSensitive(InstructionAPI::Instruction insn,
111                                          Address addr,
112                                          const func_instance *func,
113                                          const block_instance *block,
114                                          AssignList &sensitiveAssignment);
115   Graph::Ptr forwardSlice(Assignment::Ptr ptr,
116                           parse_block *block,
117                           parse_func *func);
118   bool determineSensitivity(Graph::Ptr slice,
119                             bool &intSens,
120                             bool &extSens);
121
122   bool insnIsThunkCall(InstructionAPI::Instruction insn,
123                                            Address addr,
124                                            Absloc &destination);
125   void handleThunkCall(RelocBlock *b_iter,
126                        RelocGraph *cfg,
127                        WidgetList::iterator &iter,
128                        Absloc &destination);
129   void emulateInsn(RelocBlock *b_iter,
130                                    RelocGraph *cfg,
131                                    WidgetList::iterator &iter,
132                                    InstructionAPI::Instruction insn,
133                                    Address addr);
134   
135   bool exceptionSensitive(Address addr, const block_instance *bbl);
136
137   bool isSyscall(InstructionAPI::Instruction insn, Address addr);
138
139   static void cacheAnalysis(const block_instance *bbl, Address addr, bool intSens, bool extSens);
140   static bool queryCache(const block_instance *bbl, Address addr, bool &intSens, bool &extSens);
141
142
143   AssignmentConverter aConverter;
144
145   AddressSpace *addrSpace;
146
147   PriorityMap &priMap;  
148   
149   long Sens_;
150   long extSens_;
151   long intSens_;
152   long thunk_;
153   long overApprox_;
154
155   // And for times we don't want the overhead - if non-defensive or
156   // system libraries
157   adhocMovementTransformer adhoc;
158   typedef std::pair<bool, bool> CacheData;
159   typedef std::map<Address, CacheData> CacheEntry;
160   typedef std::map<const block_instance *, CacheEntry > AnalysisCache;
161   static AnalysisCache analysisCache_;
162   
163 };
164
165 };
166 };
167
168 #endif