OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [i386-darwin-tdep.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Darwin support for GDB, the GNU debugger.
2
   Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2005, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
 
5
   Contributed by Apple Computer, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "frame.h"
24
#include "inferior.h"
25
#include "gdbcore.h"
26
#include "target.h"
27
#include "floatformat.h"
28
#include "symtab.h"
29
#include "regcache.h"
30
#include "libbfd.h"
31
#include "objfiles.h"
32
 
33
#include "i387-tdep.h"
34
#include "i386-tdep.h"
35
#include "osabi.h"
36
#include "ui-out.h"
37
#include "symtab.h"
38
#include "frame.h"
39
#include "gdb_assert.h"
40
#include "i386-darwin-tdep.h"
41
#include "solib.h"
42
#include "solib-darwin.h"
43
#include "dwarf2-frame.h"
44
 
45
/* Offsets into the struct i386_thread_state where we'll find the saved regs.
46
   From <mach/i386/thread_status.h> and i386-tdep.h.  */
47
int i386_darwin_thread_state_reg_offset[] =
48
{
49
 
50
   2 * 4,   /* ECX */
51
   3 * 4,   /* EDX */
52
   1 * 4,   /* EBX */
53
   7 * 4,   /* ESP */
54
   6 * 4,   /* EBP */
55
   5 * 4,   /* ESI */
56
   4 * 4,   /* EDI */
57
  10 * 4,   /* EIP */
58
   9 * 4,   /* EFLAGS */
59
  11 * 4,   /* CS */
60
   8,       /* SS */
61
  12 * 4,   /* DS */
62
  13 * 4,   /* ES */
63
  14 * 4,   /* FS */
64
  15 * 4    /* GS */
65
};
66
 
67
const int i386_darwin_thread_state_num_regs =
68
  ARRAY_SIZE (i386_darwin_thread_state_reg_offset);
69
 
70
/* Assuming THIS_FRAME is a Darwin sigtramp routine, return the
71
   address of the associated sigcontext structure.  */
72
 
73
static CORE_ADDR
74
i386_darwin_sigcontext_addr (struct frame_info *this_frame)
75
{
76
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
77
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
78
  CORE_ADDR bp;
79
  CORE_ADDR si;
80
  gdb_byte buf[4];
81
 
82
  get_frame_register (this_frame, I386_EBP_REGNUM, buf);
83
  bp = extract_unsigned_integer (buf, 4, byte_order);
84
 
85
  /* A pointer to the ucontext is passed as the fourth argument
86
     to the signal handler.  */
87
  read_memory (bp + 24, buf, 4);
88
  si = extract_unsigned_integer (buf, 4, byte_order);
89
 
90
  /* The pointer to mcontext is at offset 28.  */
91
  read_memory (si + 28, buf, 4);
92
 
93
  /* First register (eax) is at offset 12.  */
94
  return extract_unsigned_integer (buf, 4, byte_order) + 12;
95
}
96
 
97
/* Return true if the PC of THIS_FRAME is in a signal trampoline which
98
   may have DWARF-2 CFI.
99
 
100
   On Darwin, signal trampolines have DWARF-2 CFI but it has only one FDE
101
   that covers only the indirect call to the user handler.
102
   Without this function, the frame is recognized as a normal frame which is
103
   not expected.  */
104
 
105
int
106
darwin_dwarf_signal_frame_p (struct gdbarch *gdbarch,
107
                             struct frame_info *this_frame)
108
{
109
  return i386_sigtramp_p (this_frame);
110
}
111
 
112
/* Check wether TYPE is a 128-bit vector (__m128, __m128d or __m128i).  */
113
 
114
static int
115
i386_m128_p (struct type *type)
116
{
117
  return (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
118
          && TYPE_LENGTH (type) == 16);
119
}
120
 
121
/* Return the alignment for TYPE when passed as an argument.  */
122
 
123
static int
124
i386_darwin_arg_type_alignment (struct type *type)
125
{
126
  type = check_typedef (type);
127
  /* According to Mac OS X ABI document (passing arguments):
128
     6.  The caller places 64-bit vectors (__m64) on the parameter area,
129
         aligned to 8-byte boundaries.
130
     7.  [...]  The caller aligns 128-bit vectors in the parameter area to
131
         16-byte boundaries.  */
132
  if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
133
    return TYPE_LENGTH (type);
134
  /* 4.  The caller places all the fields of structures (or unions) with no
135
         vector elements in the parameter area.  These structures are 4-byte
136
         aligned.
137
     5.  The caller places structures with vector elements on the stack,
138
         16-byte aligned.  */
139
  if (TYPE_CODE (type) == TYPE_CODE_STRUCT
140
      || TYPE_CODE (type) == TYPE_CODE_UNION)
141
    {
142
      int i;
143
      int res = 4;
144
      for (i = 0; i < TYPE_NFIELDS (type); i++)
145
        res = max (res,
146
                   i386_darwin_arg_type_alignment (TYPE_FIELD_TYPE (type, i)));
147
      return res;
148
    }
149
  /* 2.  The caller aligns nonvector arguments to 4-byte boundaries.  */
150
  return 4;
151
}
152
 
153
static CORE_ADDR
154
i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
155
                             struct regcache *regcache, CORE_ADDR bp_addr,
156
                             int nargs, struct value **args, CORE_ADDR sp,
157
                             int struct_return, CORE_ADDR struct_addr)
158
{
159
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
160
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
161
  gdb_byte buf[4];
162
  int i;
163
  int write_pass;
164
 
165
  /* Determine the total space required for arguments and struct
166
     return address in a first pass, then push arguments in a second pass.  */
167
 
168
  for (write_pass = 0; write_pass < 2; write_pass++)
169
    {
170
      int args_space = 0;
171
      int num_m128 = 0;
172
 
173
      if (struct_return)
174
        {
175
          if (write_pass)
176
            {
177
              /* Push value address.  */
178
              store_unsigned_integer (buf, 4, byte_order, struct_addr);
179
              write_memory (sp, buf, 4);
180
            }
181
          args_space += 4;
182
        }
183
 
184
      for (i = 0; i < nargs; i++)
185
        {
186
          struct type *arg_type = value_enclosing_type (args[i]);
187
 
188
          if (i386_m128_p (arg_type) && num_m128 < 4)
189
            {
190
              if (write_pass)
191
                {
192
                  const gdb_byte *val = value_contents_all (args[i]);
193
                  regcache_raw_write
194
                    (regcache, I387_MM0_REGNUM(tdep) + num_m128, val);
195
                }
196
              num_m128++;
197
            }
198
          else
199
            {
200
              int len = TYPE_LENGTH (arg_type);
201
              int align = i386_darwin_arg_type_alignment (arg_type);
202
 
203
              args_space = align_up (args_space, align);
204
              if (write_pass)
205
                write_memory (sp + args_space,
206
                              value_contents_all (args[i]), len);
207
 
208
              /* The System V ABI says that:
209
 
210
                 "An argument's size is increased, if necessary, to make it a
211
                 multiple of [32-bit] words.  This may require tail padding,
212
                 depending on the size of the argument."
213
 
214
                 This makes sure the stack stays word-aligned.  */
215
              args_space += align_up (len, 4);
216
            }
217
        }
218
 
219
      /* Darwin i386 ABI:
220
         1.  The caller ensures that the stack is 16-byte aligned at the point
221
             of the function call.  */
222
      if (!write_pass)
223
        sp = align_down (sp - args_space, 16);
224
    }
225
 
226
  /* Store return address.  */
227
  sp -= 4;
228
  store_unsigned_integer (buf, 4, byte_order, bp_addr);
229
  write_memory (sp, buf, 4);
230
 
231
  /* Finally, update the stack pointer...  */
232
  store_unsigned_integer (buf, 4, byte_order, sp);
233
  regcache_cooked_write (regcache, I386_ESP_REGNUM, buf);
234
 
235
  /* ...and fake a frame pointer.  */
236
  regcache_cooked_write (regcache, I386_EBP_REGNUM, buf);
237
 
238
  /* MarkK wrote: This "+ 8" is all over the place:
239
     (i386_frame_this_id, i386_sigtramp_frame_this_id,
240
     i386_dummy_id).  It's there, since all frame unwinders for
241
     a given target have to agree (within a certain margin) on the
242
     definition of the stack address of a frame.  Otherwise frame id
243
     comparison might not work correctly.  Since DWARF2/GCC uses the
244
     stack address *before* the function call as a frame's CFA.  On
245
     the i386, when %ebp is used as a frame pointer, the offset
246
     between the contents %ebp and the CFA as defined by GCC.  */
247
  return sp + 8;
248
}
249
 
250
static void
251
i386_darwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
252
{
253
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
254
 
255
  /* We support the SSE registers.  */
256
  tdep->num_xmm_regs = I386_NUM_XREGS - 1;
257
  set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS);
258
 
259
  dwarf2_frame_set_signal_frame_p (gdbarch, darwin_dwarf_signal_frame_p);
260
  set_gdbarch_push_dummy_call (gdbarch, i386_darwin_push_dummy_call);
261
 
262
  tdep->struct_return = reg_struct_return;
263
 
264
  tdep->sigtramp_p = i386_sigtramp_p;
265
  tdep->sigcontext_addr = i386_darwin_sigcontext_addr;
266
  tdep->sc_reg_offset = i386_darwin_thread_state_reg_offset;
267
  tdep->sc_num_regs = i386_darwin_thread_state_num_regs;
268
 
269
  tdep->jb_pc_offset = 48;
270
 
271
  /* Although the i387 extended floating-point has only 80 significant
272
     bits, a `long double' actually takes up 128, probably to enforce
273
     alignment.  */
274
  set_gdbarch_long_double_bit (gdbarch, 128);
275
 
276
  set_solib_ops (gdbarch, &darwin_so_ops);
277
}
278
 
279
static enum gdb_osabi
280
i386_mach_o_osabi_sniffer (bfd *abfd)
281
{
282
  if (!bfd_check_format (abfd, bfd_object))
283
    return GDB_OSABI_UNKNOWN;
284
 
285
  if (bfd_get_arch (abfd) == bfd_arch_i386)
286
    return GDB_OSABI_DARWIN;
287
 
288
  return GDB_OSABI_UNKNOWN;
289
}
290
 
291
void
292
_initialize_i386_darwin_tdep (void)
293
{
294
  gdbarch_register_osabi_sniffer (bfd_arch_unknown, bfd_target_mach_o_flavour,
295
                                  i386_mach_o_osabi_sniffer);
296
 
297
  gdbarch_register_osabi (bfd_arch_i386, bfd_mach_i386_i386,
298
                          GDB_OSABI_DARWIN, i386_darwin_init_abi);
299
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.