1 /* Signal trampoline unwinder, for GDB the GNU Debugger. 2 3 Copyright (C) 2004-2023 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "tramp-frame.h" 22 #include "frame-unwind.h" 23 #include "gdbcore.h" 24 #include "symtab.h" 25 #include "objfiles.h" 26 #include "target.h" 27 #include "trad-frame.h" 28 #include "frame-base.h" 29 30 struct frame_data 31 { 32 const struct tramp_frame *tramp_frame; 33 }; 34 35 struct tramp_frame_cache 36 { 37 CORE_ADDR func; 38 const struct tramp_frame *tramp_frame; 39 struct trad_frame_cache *trad_cache; 40 }; 41 42 static struct trad_frame_cache * 43 tramp_frame_cache (frame_info_ptr this_frame, 44 void **this_cache) 45 { 46 struct tramp_frame_cache *tramp_cache 47 = (struct tramp_frame_cache *) *this_cache; 48 49 if (tramp_cache->trad_cache == NULL) 50 { 51 tramp_cache->trad_cache = trad_frame_cache_zalloc (this_frame); 52 tramp_cache->tramp_frame->init (tramp_cache->tramp_frame, 53 this_frame, 54 tramp_cache->trad_cache, 55 tramp_cache->func); 56 } 57 return tramp_cache->trad_cache; 58 } 59 60 static void 61 tramp_frame_this_id (frame_info_ptr this_frame, 62 void **this_cache, 63 struct frame_id *this_id) 64 { 65 struct trad_frame_cache *trad_cache 66 = tramp_frame_cache (this_frame, this_cache); 67 68 trad_frame_get_id (trad_cache, this_id); 69 } 70 71 static struct value * 72 tramp_frame_prev_register (frame_info_ptr this_frame, 73 void **this_cache, 74 int prev_regnum) 75 { 76 struct trad_frame_cache *trad_cache 77 = tramp_frame_cache (this_frame, this_cache); 78 79 return trad_frame_get_register (trad_cache, this_frame, prev_regnum); 80 } 81 82 static CORE_ADDR 83 tramp_frame_start (const struct tramp_frame *tramp, 84 frame_info_ptr this_frame, CORE_ADDR pc) 85 { 86 struct gdbarch *gdbarch = get_frame_arch (this_frame); 87 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 88 int ti; 89 90 /* Check if we can use this trampoline. */ 91 if (tramp->validate && !tramp->validate (tramp, this_frame, &pc)) 92 return 0; 93 94 /* Search through the trampoline for one that matches the 95 instruction sequence around PC. */ 96 for (ti = 0; tramp->insn[ti].bytes != TRAMP_SENTINEL_INSN; ti++) 97 { 98 CORE_ADDR func = pc - tramp->insn_size * ti; 99 int i; 100 101 for (i = 0; 1; i++) 102 { 103 gdb_byte buf[sizeof (tramp->insn[0])]; 104 ULONGEST insn; 105 size_t insn_size = tramp->insn_size; 106 107 if (tramp->insn[i].bytes == TRAMP_SENTINEL_INSN) 108 return func; 109 if (!safe_frame_unwind_memory (this_frame, 110 func + i * insn_size, 111 {buf, insn_size})) 112 break; 113 insn = extract_unsigned_integer (buf, insn_size, byte_order); 114 if (tramp->insn[i].bytes != (insn & tramp->insn[i].mask)) 115 break; 116 } 117 } 118 /* Trampoline doesn't match. */ 119 return 0; 120 } 121 122 static int 123 tramp_frame_sniffer (const struct frame_unwind *self, 124 frame_info_ptr this_frame, 125 void **this_cache) 126 { 127 const struct tramp_frame *tramp = self->unwind_data->tramp_frame; 128 CORE_ADDR pc = get_frame_pc (this_frame); 129 CORE_ADDR func; 130 struct tramp_frame_cache *tramp_cache; 131 132 /* tausq/2004-12-12: We used to assume if pc has a name or is in a valid 133 section, then this is not a trampoline. However, this assumption is 134 false on HPUX which has a signal trampoline that has a name; it can 135 also be false when using an alternative signal stack. */ 136 func = tramp_frame_start (tramp, this_frame, pc); 137 if (func == 0) 138 return 0; 139 tramp_cache = FRAME_OBSTACK_ZALLOC (struct tramp_frame_cache); 140 tramp_cache->func = func; 141 tramp_cache->tramp_frame = tramp; 142 (*this_cache) = tramp_cache; 143 return 1; 144 } 145 146 void 147 tramp_frame_prepend_unwinder (struct gdbarch *gdbarch, 148 const struct tramp_frame *tramp_frame) 149 { 150 struct frame_data *data; 151 struct frame_unwind *unwinder; 152 int i; 153 154 /* Check that the instruction sequence contains a sentinel. */ 155 for (i = 0; i < ARRAY_SIZE (tramp_frame->insn); i++) 156 { 157 if (tramp_frame->insn[i].bytes == TRAMP_SENTINEL_INSN) 158 break; 159 } 160 gdb_assert (i < ARRAY_SIZE (tramp_frame->insn)); 161 gdb_assert (tramp_frame->insn_size <= sizeof (tramp_frame->insn[0].bytes)); 162 163 data = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_data); 164 unwinder = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind); 165 166 data->tramp_frame = tramp_frame; 167 unwinder->type = tramp_frame->frame_type; 168 unwinder->unwind_data = data; 169 unwinder->sniffer = tramp_frame_sniffer; 170 unwinder->stop_reason = default_frame_unwind_stop_reason; 171 unwinder->this_id = tramp_frame_this_id; 172 unwinder->prev_register = tramp_frame_prev_register; 173 frame_unwind_prepend_unwinder (gdbarch, unwinder); 174 } 175