← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/stacktrace.cc

  • Committer: Brian Aker
  • Date: 2010-01-27 18:58:12 UTC
  • Revision ID: brian@gaz-20100127185812-n62n0vwetnx8jrjy
Remove dead code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/stacktrace.cc
1
 
/* Copyright (C) 2000 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
/* Workaround for Bug#32082: VOID redefinition on Win results in compile errors*/
17
 
#define DONT_DEFINE_VOID 1
18
 
 
19
 
#include "stacktrace.h"
 
1
/* - mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#include "config.h"
 
21
#include "drizzled/stacktrace.h"
 
22
#include <cstddef>
20
23
 
21
24
#include <signal.h>
22
 
#include <mysys/my_pthread.h>
23
 
#include <mystrings/m_string.h>
 
25
#include "drizzled/internal/my_pthread.h"
 
26
#include "drizzled/internal/m_string.h"
24
27
#ifdef HAVE_STACKTRACE
25
28
#include <unistd.h>
26
29
#include <strings.h>
29
32
#include <execinfo.h>
30
33
#endif
31
34
 
 
35
#include <cstring>
 
36
#include <cstdio>
 
37
#include <algorithm>
 
38
 
 
39
#include "drizzled/definitions.h"
 
40
 
 
41
using namespace std;
 
42
 
32
43
#define PTR_SANE(p) ((p) && (char*)(p) >= heap_start && (char*)(p) <= heap_end)
33
44
 
34
45
char *heap_start;
60
71
#define SIGRETURN_FRAME_OFFSET 23
61
72
#endif
62
73
 
63
 
#if defined(__alpha__) && defined(__GNUC__)
64
 
/*
65
 
  The only way to backtrace without a symbol table on alpha
66
 
  is to find stq fp,N(sp), and the first byte
67
 
  of the instruction opcode will give us the value of N. From this
68
 
  we can find where the old value of fp is stored
69
 
*/
70
 
 
71
 
#define MAX_INSTR_IN_FUNC  10000
72
 
 
73
 
inline uchar** find_prev_fp(uint32* pc, uchar** fp)
74
 
{
75
 
  int i;
76
 
  for (i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)
77
 
  {
78
 
    uchar* p = (uchar*)pc;
79
 
    if (p[2] == 222 &&  p[3] == 35)
80
 
    {
81
 
      return (uchar**)((uchar*)fp - *(short int*)p);
82
 
    }
83
 
  }
84
 
  return 0;
85
 
}
86
 
 
87
 
inline uint32* find_prev_pc(uint32* pc, uchar** fp)
88
 
{
89
 
  int i;
90
 
  for (i = 0; i < MAX_INSTR_IN_FUNC; ++i,--pc)
91
 
  {
92
 
    char* p = (char*)pc;
93
 
    if (p[1] == 0 && p[2] == 94 &&  p[3] == -73)
94
 
    {
95
 
      uint32* prev_pc = (uint32*)*((fp+p[0]/sizeof(fp)));
96
 
      return prev_pc;
97
 
    }
98
 
  }
99
 
  return 0;
100
 
}
101
 
#endif /* defined(__alpha__) && defined(__GNUC__) */
102
74
 
103
75
#if BACKTRACE_DEMANGLE
104
76
static void my_demangle_symbols(char **addrs, int n)
156
128
#endif
157
129
 
158
130
 
159
 
void  print_stacktrace(uchar* stack_bottom, ulong thread_stack)
 
131
void  print_stacktrace(unsigned char* stack_bottom, size_t thread_stack)
160
132
{
161
133
#if HAVE_BACKTRACE
162
134
  backtrace_current_thread();
163
135
  return;
164
136
#endif
165
 
  uchar** fp;
166
 
  uint frame_count = 0, sigreturn_frame_count;
167
 
#if defined(__alpha__) && defined(__GNUC__)
168
 
  uint32* pc;
169
 
#endif
170
 
 
 
137
  unsigned char** fp;
 
138
  uint32_t frame_count = 0, sigreturn_frame_count;
171
139
 
172
140
#ifdef __i386__
173
141
  __asm __volatile__ ("movl %%ebp,%0"
174
 
                      :"=r"(fp)
175
 
                      :"r"(fp));
 
142
                      :"=r"(fp)
 
143
                      :"r"(fp));
176
144
#endif
177
145
#ifdef __x86_64__
178
146
  __asm __volatile__ ("movq %%rbp,%0"
179
 
                      :"=r"(fp)
180
 
                      :"r"(fp));
181
 
#endif
182
 
#if defined(__alpha__) && defined(__GNUC__) 
183
 
  __asm __volatile__ ("mov $30,%0"
184
 
                      :"=r"(fp)
185
 
                      :"r"(fp));
 
147
                      :"=r"(fp)
 
148
                      :"r"(fp));
186
149
#endif
187
150
  if (!fp)
188
151
  {
191
154
    return;
192
155
  }
193
156
 
194
 
  if (!stack_bottom || (uchar*) stack_bottom > (uchar*) &fp)
 
157
  if (!stack_bottom || (unsigned char*) stack_bottom > (unsigned char*) &fp)
195
158
  {
196
 
    ulong tmp= min(0x10000,thread_stack);
 
159
    ulong tmp= min((size_t)0x10000,thread_stack);
197
160
    /* Assume that the stack starts at the previous even 65K */
198
 
    stack_bottom= (uchar*) (((ulong) &fp + tmp) &
 
161
    stack_bottom= (unsigned char*) (((ulong) &fp + tmp) &
199
162
                          ~(ulong) 0xFFFF);
200
163
    fprintf(stderr, "Cannot determine thread, fp=%p, backtrace may not be correct.\n", (void *)fp);
201
164
  }
202
 
  if (fp > (uchar**) stack_bottom ||
203
 
      fp < (uchar**) stack_bottom - thread_stack)
 
165
  if (fp > (unsigned char**) stack_bottom ||
 
166
      fp < (unsigned char**) stack_bottom - thread_stack)
204
167
  {
205
168
    fprintf(stderr, "Bogus stack limit or frame pointer,\
206
 
 fp=%p, stack_bottom=%p, thread_stack=%ld, aborting backtrace.\n",
207
 
            (void *)fp, (void *)stack_bottom, thread_stack);
 
169
 fp=%p, stack_bottom=%p, thread_stack=%"PRIu64", aborting backtrace.\n",
 
170
            (void *)fp, (void *)stack_bottom, (uint64_t)thread_stack);
208
171
    return;
209
172
  }
210
173
 
211
174
  fprintf(stderr, "Stack range sanity check OK, backtrace follows:\n");
212
 
#if defined(__alpha__) && defined(__GNUC__)
213
 
  fprintf(stderr, "Warning: Alpha stacks are difficult -\
214
 
 will be taking some wild guesses, stack trace may be incorrect or \
215
 
 terminate abruptly\n");
216
 
  /* On Alpha, we need to get pc */
217
 
  __asm __volatile__ ("bsr %0, do_next; do_next: "
218
 
                      :"=r"(pc)
219
 
                      :"r"(pc));
220
 
#endif  /* __alpha__ */
221
175
 
222
176
  /* We are 1 frame above signal frame with NPTL and 2 frames above with LT */
223
177
  sigreturn_frame_count = thd_lib_detected == THD_LIB_LT ? 2 : 1;
224
178
 
225
 
  while (fp < (uchar**) stack_bottom)
 
179
  while (fp < (unsigned char**) stack_bottom)
226
180
  {
227
181
#if defined(__i386__) || defined(__x86_64__)
228
 
    uchar** new_fp = (uchar**)*fp;
 
182
    unsigned char** new_fp = (unsigned char**)*fp;
229
183
    fprintf(stderr, "%p\n", frame_count == sigreturn_frame_count ?
230
 
            *(fp + SIGRETURN_FRAME_OFFSET) : *(fp + 1));
 
184
            *(fp + SIGRETURN_FRAME_OFFSET) : *(fp + 1));
231
185
#endif /* defined(__386__)  || defined(__x86_64__) */
232
186
 
233
 
#if defined(__alpha__) && defined(__GNUC__)
234
 
    uchar** new_fp = find_prev_fp(pc, fp);
235
 
    if (frame_count == sigreturn_frame_count - 1)
236
 
    {
237
 
      new_fp += 90;
238
 
    }
239
 
 
240
 
    if (fp && pc)
241
 
    {
242
 
      pc = find_prev_pc(pc, fp);
243
 
      if (pc)
244
 
        fprintf(stderr, "%p\n", pc);
245
 
      else
246
 
      {
247
 
        fprintf(stderr, "Not smart enough to deal with the rest\
248
 
 of this stack\n");
249
 
        goto end;
250
 
      }
251
 
    }
252
 
    else
253
 
    {
254
 
      fprintf(stderr, "Not smart enough to deal with the rest of this stack\n");
255
 
      goto end;
256
 
    }
257
 
#endif /* defined(__alpha__) && defined(__GNUC__) */
258
187
    if (new_fp <= fp )
259
188
    {
260
189
      fprintf(stderr, "New value of fp=%p failed sanity check,\