Fixes for StackwalkerAPI on BlueGene
[dyninst.git] / common / src / addrtranslate.C
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 #include "common/h/addrtranslate.h"
33
34 #include <cstdio>
35
36 using namespace Dyninst;
37 using namespace std;
38
39 AddressTranslate::AddressTranslate(PID pid_, PROC_HANDLE phand, std::string exename) :
40    pid(pid_),
41    phandle(phand),
42    creation_error(false),
43    exec_name(exename),
44    exec(NULL),
45    symfactory(NULL),
46    read_abort(false)
47 {
48 }
49
50 bool AddressTranslate::getLibAtAddress(Address addr, LoadedLib* &lib)
51 {
52    for (unsigned i=0; i<libs.size(); i++)
53    {
54       LoadedLib *l = libs[i];
55       if (!l)
56          continue;
57       vector<pair<Address, unsigned long> > *addresses = l->getMappedRegions();
58       if (!addresses)
59          continue;
60       for (unsigned j = 0; j<addresses->size(); j++) {
61          if (addr >= (*addresses)[j].first && 
62              addr < (*addresses)[j].first + (*addresses)[j].second)
63          {
64             lib = l;
65             return true;
66          }
67       }
68    }
69    return false;
70 }
71
72 bool AddressTranslate::getLibs(vector<LoadedLib *> &libs_)
73 {
74    libs_.clear();
75    for (unsigned i=0; i<libs.size(); i++)
76       libs_.push_back(libs[i]);
77    return true;
78 }
79
80 PID AddressTranslate::getPid()
81 {
82    return pid;
83 }
84
85 LoadedLib *AddressTranslate::getLoadedLib(std::string name)
86 {
87    for (unsigned i=0; i<libs.size(); i++)
88    {
89       if (libs[i]->getName() == name)
90       {
91          return libs[i];
92       }
93    }
94    return NULL;
95 }
96
97 void AddressTranslate::setReadAbort(bool b)
98 {
99    read_abort = b;
100 }
101
102 AddressTranslate::~AddressTranslate()
103 {
104    for (vector<LoadedLib *>::iterator i = libs.begin(); i != libs.end(); i++)
105    {
106       if (*i == exec)
107          exec = NULL;
108       delete *i;
109    }
110    if (exec) {
111       delete exec;
112       exec = NULL;
113    }
114 }
115
116 LoadedLib *AddressTranslate::getExecutable()
117 {
118    return exec;
119 }
120
121 bool AddressTranslate::getArchLibs(std::vector<LoadedLib *> &)
122 {
123    return true;
124 }
125
126 string LoadedLib::getName() const {
127    return name;
128 }
129
130 void LoadedLib::add_mapped_region(Address addr, unsigned long size)
131 {
132    mapped_regions.push_back(pair<Address, unsigned long>(addr, size));   
133 }
134
135 void LoadedLib::setShouldClean(bool b)
136 {
137    should_clean = b;
138 }
139
140 bool LoadedLib::shouldClean()
141 {
142    return should_clean;
143 }
144
145 LoadedLib::LoadedLib(string n, Address la) :
146    name(n),
147    load_addr(la),
148    data_load_addr(0),
149    should_clean(false),
150    symreader(NULL),
151    symreader_factory(NULL),
152    up_ptr(NULL)
153 {
154 }
155
156 LoadedLib::~LoadedLib()
157 {
158 }
159
160 void LoadedLib::setDataLoadAddr(Address a)
161 {
162    data_load_addr = a;
163 }
164
165 Address LoadedLib::offToAddress(Offset off)
166 {
167    return off + getCodeLoadAddr();
168 }
169
170 Offset LoadedLib::addrToOffset(Address addr)
171 {
172    return addr - getCodeLoadAddr();
173 }
174
175 Address LoadedLib::getCodeLoadAddr() const
176 {
177    return load_addr;
178 }
179
180 Address LoadedLib::getDataLoadAddr() const
181 {
182    return data_load_addr;
183 }
184
185 void LoadedLib::setFactory(SymbolReaderFactory *factory)
186 {
187    symreader_factory = factory;
188 }
189
190 void LoadedLib::getOutputs(string &filename, Address &code, Address &data)
191 {
192    filename = name;
193    code = load_addr;
194    data = 0;
195 }
196
197 void* LoadedLib::getUpPtr()
198 {
199    return up_ptr;
200 }
201
202 void LoadedLib::setUpPtr(void *v)
203 {
204    up_ptr = v;
205 }
206
207 #include <stdarg.h>
208
209 int translate_printf(const char *format, ...)
210 {
211   static int dyn_debug_translate = 0;
212
213   if (dyn_debug_translate == -1) {
214     return 0;
215   }
216   if (!dyn_debug_translate) {
217     char *p = getenv("DYNINST_DEBUG_TRANSLATE");
218     if (p) {
219       fprintf(stderr, "Enabling address translation debug prints\n");
220       dyn_debug_translate = 1;
221     }
222     else {
223       dyn_debug_translate = -1;
224       return 0;
225     }
226   }
227
228   if (!format)
229     return -1;
230
231   va_list va;
232   va_start(va, format);
233   int ret = vfprintf(stderr, format, va);
234   va_end(va);
235
236   return ret;
237 }
238
239 //#if !defined(os_linux) && !defined(os_solaris)
240 //This definition is for all the non-System V systems
241 Address AddressTranslate::getLibraryTrapAddrSysV()
242 {
243    return 0x0;
244 }
245