Add Function parameter to unresolved_cf callback
[dyninst.git] / dyninstAPI / src / Parsing.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #ifndef _PARSING_H_
32 #define _PARSING_H_
33
34 #include "parseAPI/h/CFGFactory.h"
35 #include "parseAPI/h/CodeObject.h"
36 #include "parseAPI/h/CodeSource.h"
37 #include "parseAPI/h/InstructionSource.h"
38 #include "parseAPI/h/CFG.h"
39 #include "parseAPI/h/ParseCallback.h"
40
41 using namespace Dyninst;
42
43 // some useful types
44 using ParseAPI::EdgeTypeEnum;
45 using ParseAPI::FuncReturnStatus;
46 using ParseAPI::FuncSource;
47
48 /*** The image_* object factory ***/
49 class image;
50
51 class DynCFGFactory : public ParseAPI::CFGFactory {
52   public:
53     DynCFGFactory(image * im);
54     ~DynCFGFactory();
55     
56     ParseAPI::Function * mkfunc(Address addr, FuncSource src, std::string name,
57             ParseAPI::CodeObject * obj, ParseAPI::CodeRegion * reg,
58             InstructionSource * isrc);
59     ParseAPI::Block * mkblock(ParseAPI::Function * f, ParseAPI::CodeRegion * r,
60             Address addr);
61     ParseAPI::Edge * mkedge(ParseAPI::Block * src, ParseAPI::Block * trg, 
62             EdgeTypeEnum type);
63
64     ParseAPI::Block * mksink(ParseAPI::CodeObject *obj, ParseAPI::CodeRegion*r);
65
66     // leaving default atm    
67     //void free_func(ParseAPI::Function * f);
68     //void free_block(ParseAPI::Block * b);
69     //void free_edge(ParseAPI::Edge * e);
70
71     //void free_all();
72   private:
73     image * _img;     
74 #if defined(VERBOSE_CFG_FACTORY)
75 #warning "VERBOSE_CFG_FACTORY enabled ; may impact performance"
76     vector<int> __func_allocs(__funcsource_end__);
77     vector<int> __edge_allocs(__edgetype_end__);
78     int __block_allocs;
79     int __sink_block_allocs;
80     //int __sink_edge_allocs; FIXME can't determine
81
82     void __record_func_alloc(FuncSource fs)
83     {
84         assert(fs < __funsource_end__);
85         ++__func_allocs[fs];
86     }
87     void __record_edge_alloc(EdgeTypeEnum et,bool sink)
88     {
89         assert(et < __edgetype_end__);
90         ++__edge_allocs[et];
91
92         //if(sink)
93             //++__sink_block_allocs;
94     }
95     void __record_block_alloc(bool sink)
96     {
97         ++__block_allocs;
98         if(sink)
99             ++__sink_block_allocs;
100     }
101     void dump_stats();
102 #endif
103 };
104
105 class image;
106 class DynParseCallback : public ParseAPI::ParseCallback {
107  public:
108   DynParseCallback(image * img) : _img(img) { }
109   ~DynParseCallback() { }
110
111   // defensive and exploratory mode callbacks
112   void unresolved_cf(Function*,Address,default_details*);
113   void abruptEnd_cf(Address,default_details*);
114   void newfunction_retstatus(ParseAPI::Function*);
115   void block_split(ParseAPI::Block *first, ParseAPI::Block *second);
116   void patch_jump_neg1(Address);
117   // other callbacks
118   void interproc_cf(ParseAPI::Function*,Address,interproc_details*);
119   void overlapping_blocks(ParseAPI::Block*,ParseAPI::Block*);
120
121 #if defined(arch_power) || defined(arch_sparc)
122   void instruction_cb(ParseAPI::Function*,Address,insn_details*);
123 #endif
124  private:
125     image * _img;
126 };
127
128
129 #endif