Identify shared code regions
[dyninst.git] / parseAPI / h / CodeObject.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
32 #ifndef CODE_OBJECT_H
33 #define CODE_OBJECT_H
34
35 #include <map>
36
37 #include <Symtab.h>
38 #include "IBSTree.h"
39
40 #include "CodeSource.h"
41 #include "CFGFactory.h"
42 #include "CFG.h"
43 #include "ParseContainers.h"
44
45 namespace Dyninst {
46 namespace ParseAPI {
47
48 /** A CodeObject defines a collection of binary code, for example a binary,
49     dynamic library, archive, memory snapshot, etc. In the context of
50     Dyninst, it maps to an image object.
51 **/
52
53 class Parser;   // internals
54 class ParseCallback;
55
56 class CodeObject {
57  public:
58     PARSER_EXPORT static void version(int& major, int& minor, int& maintenance);
59     typedef ContainerWrapper<
60         std::set<Function*,Function::less>,
61         Function*,
62         Function*
63     > funclist;
64
65     PARSER_EXPORT CodeObject(CodeSource * cs, 
66                CFGFactory * fact = NULL, 
67                ParseCallback * cb = NULL,
68                bool defensiveMode = false);
69     PARSER_EXPORT ~CodeObject();
70
71     /** Parsing interface **/
72     
73     // `hint-based' parsing
74     PARSER_EXPORT void parse();
75     
76     // `exact-target' parsing; optinally recursive
77     PARSER_EXPORT void parse(Address target, bool recursive);
78
79     // adds new edges to parsed functions
80     PARSER_EXPORT bool parseNewEdges( vector<Block*> & sources, 
81                                       vector<Address> & targets, 
82                                       vector<EdgeTypeEnum> & edge_types);
83
84     // `speculative' parsing
85     PARSER_EXPORT void parseGaps(CodeRegion *cr);
86
87     /** Lookup routines **/
88
89     // functions
90     PARSER_EXPORT Function * findFuncByEntry(CodeRegion * cr, Address entry);
91     PARSER_EXPORT int findFuncs(CodeRegion * cr, 
92             Address addr, 
93             std::set<Function*> & funcs);
94       // Find functions overlapping the range [start,end)
95     PARSER_EXPORT int findFuncs(CodeRegion * cr,
96             Address start, Address end,
97             std::set<Function*> & funcs);
98     PARSER_EXPORT funclist & funcs() { return flist; }
99
100     // blocks
101     PARSER_EXPORT Block * findBlockByEntry(CodeRegion * cr, Address entry);
102     PARSER_EXPORT int findBlocks(CodeRegion * cr, 
103         Address addr, std::set<Block*> & blocks);
104
105     /* Misc */
106     PARSER_EXPORT CodeSource * cs() const { return _cs; }
107     PARSER_EXPORT CFGFactory * fact() const { return _fact; }
108     PARSER_EXPORT bool defensiveMode() { return defensive; }
109     PARSER_EXPORT void deleteFunc(Function *);
110
111     /*
112      * Calling finalize() forces completion of all on-demand
113      * parsing operations for this object, if any remain.
114      */
115     PARSER_EXPORT void finalize();
116
117  private:
118     void process_hints();
119     void add_edge(Block *src, Block *trg, EdgeTypeEnum et);
120     // allows Function to (re-)finalize
121     friend void Function::deleteBlocks(vector<Block*> &, Block *);
122     // allows Functions to link up return edges after-the-fact
123     friend void Function::delayed_link_return(CodeObject *,Block*);
124     // allows Functions to finalize (need Parser access)
125     friend void Function::finalize();
126
127  private:
128     CodeSource * _cs;
129     CFGFactory * _fact;
130     ParseCallback * _pcb;
131
132     Parser * parser; // parser implementation
133
134     bool owns_factory;
135     bool owns_pcb;
136     bool defensive;
137     funclist flist;
138
139 };
140
141 }//namespace ParseAPI
142 }//namespace Dyninst
143
144 #endif