Initialize thrd in a new FrameNode ctor
[dyninst.git] / stackwalk / src / sw_c.C
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 extern "C" {
32 #include "stackwalk/h/sw_c.h"
33 }
34
35 #include "stackwalk/h/walker.h"
36 #include "stackwalk/h/frame.h"
37
38 using namespace Dyninst;
39 using namespace Stackwalker;
40 using namespace std;
41
42 walker_t newWalkerLocal()
43 {
44    walker_t ret;
45    ret.walker = (void *) Walker::newWalker();
46    return ret;
47 }
48
49 walker_t newWalkerAttach(int pid)
50 {
51    walker_t ret;
52    ret.walker = (void *) Walker::newWalker(pid);
53    return ret;
54 }
55
56 walker_t newWalkerCreate(char *executable, char **args)
57 {
58    vector<string> cpp_args;
59    while (*args) {
60       cpp_args.push_back(*args);
61       args++;
62    }
63    string cpp_executable(executable);
64
65    walker_t ret;
66    ret.walker = (void *) Walker::newWalker(cpp_executable, cpp_args);
67    return ret;
68 }
69
70 int walkStack(walker_t walker, frame_t **out_frames, unsigned int *out_frames_size)
71 {
72    Walker *w = (Walker *) walker.walker;
73    
74    vector<Frame> frames;
75    bool result = w->walkStack(frames);
76    if (!frames.size())
77       return -1;
78    
79    *out_frames = (frame_t *) malloc(sizeof(frame_t) * frames.size());
80    if (!*out_frames)
81       return -1;
82    
83    unsigned j=0;
84    for (vector<Frame>::iterator i = frames.begin(); i != frames.end(); i++, j++) {
85       (*out_frames)[j].frame = (void *) new Frame(*i);
86    }
87    *out_frames_size = frames.size();
88
89    return result ? 0 : -1;
90 }
91
92 int walkStackFromFrame(walker_t walker, frame_t frame, frame_t **out_frames,
93                        unsigned int *out_frames_size)
94 {
95    Walker *w = (Walker *) walker.walker;
96    Frame *f = (Frame *) frame.frame;
97    
98    vector<Frame> frames;
99    bool result = w->walkStackFromFrame(frames, *f);
100    if (!frames.size())
101       return -1;
102    
103    *out_frames = (frame_t *) malloc(sizeof(frame_t) * frames.size());
104    if (!*out_frames)
105       return -1;
106    
107    unsigned j=0;
108    for (vector<Frame>::iterator i = frames.begin(); i != frames.end(); i++, j++) {
109       (*out_frames)[j].frame = (void *) new Frame(*i);
110    }
111    *out_frames_size = frames.size();
112
113    return result ? 0 : -1;
114 }
115
116
117 int walkSingleFrame(walker_t walker, frame_t frame, frame_t *out_frame)
118 {
119    Walker *w = (Walker *) walker.walker;
120    Frame *f = (Frame *) frame.frame;
121
122    Frame oframe(w);
123    bool result = w->walkSingleFrame(*f, oframe);
124    if (!result) 
125       return -1;
126
127    out_frame->frame = (void *) new Frame(oframe);
128    return 0;
129 }
130
131 int getInitialFrame(walker_t walker, frame_t *out_frame)
132 {   
133    Walker *w = (Walker *) walker.walker;
134
135    Frame oframe(w);
136    bool result = w->getInitialFrame(oframe);
137    if (!result) 
138       return -1;
139    
140    out_frame->frame = (void *) new Frame(oframe);
141    return 0;
142 }
143
144 unsigned long frameGetReturnAddress(frame_t frame)
145 {
146    Frame *f = (Frame *) frame.frame;
147    return f->getRA();
148 }
149
150 unsigned long frameGetFramePointer(frame_t frame)
151 {
152    Frame *f = (Frame *) frame.frame;
153    return f->getFP();
154 }
155
156 unsigned long frameGetStackPointer(frame_t frame)
157 {
158    Frame *f = (Frame *) frame.frame;
159    return f->getSP();
160 }
161
162 int frameGetName(frame_t frame, char **buffer)
163 {
164    Frame *f = (Frame *) frame.frame;
165    std::string name;
166    bool result = f->getName(name);
167    if (!result)
168       return -1;
169
170    unsigned int name_length = (unsigned int) name.length();
171    *buffer = (char *) malloc(name_length+1);
172    strncpy(*buffer, name.c_str(), name_length);
173    (*buffer)[name_length] = '\0';
174
175    return 0;
176 }
177
178 int frameGetLibOffset(frame_t frame, char **libname, unsigned long *offset)
179 {
180    Frame *f = (Frame *) frame.frame;
181
182    Dyninst::Offset dyn_offset;
183    std::string name;
184    void *extra_handle = NULL;
185    bool result = f->getLibOffset(name, dyn_offset, extra_handle);
186    if (!result)
187       return -1;
188
189    if (*libname) {
190       unsigned int name_length = (unsigned int) name.length();
191       *libname = (char *) malloc(name_length+1);
192       strncpy(*libname, name.c_str(), name_length);
193       (*libname)[name_length] = '\0';
194    }
195
196    if (*offset) {
197       *offset = (unsigned long) dyn_offset;
198    }
199
200    return 0;
201 }
202
203 int frameIsTopFrame(frame_t frame)
204 {
205    Frame *f = (Frame *) frame.frame;
206    return f->isTopFrame() ? 1 : 0;
207 }
208
209 int frameIsBottomFrame(frame_t frame)
210 {
211    Frame *f = (Frame *) frame.frame;
212    return f->isBottomFrame() ? 1 : 0;
213 }
214
215 int freeStackwalk(frame_t *frames, unsigned int frames_size)
216 {
217    for (unsigned i=0; i<frames_size; i++) {
218       freeFrame(frames+i);
219    }
220    free(frames);
221    return 0;
222 }
223
224 int freeFrame(frame_t *frame)
225 {
226    Frame *f = (Frame *) frame->frame;
227    if (!f)
228       return -1;
229    delete f;
230    frame->frame = NULL;
231    return 0;
232 }
233
234 int freeName(char *name)
235 {
236    free(name);
237    return 0;
238 }