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