GDB (xrefs)

compile-object-load.c
Go to the documentation of this file.
1 /* Load module for 'compile' command.
2
3 Copyright (C) 2014-2018 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 "compile-object-load.h"
22 #include "compile-internal.h"
23 #include "command.h"
24 #include "objfiles.h"
25 #include "gdbcore.h"
26 #include "readline/tilde.h"
27 #include "bfdlink.h"
28 #include "gdbcmd.h"
29 #include "regcache.h"
30 #include "inferior.h"
31 #include "compile.h"
32 #include "block.h"
33 #include "arch-utils.h"
34 #include <algorithm>
35
36 /* Track inferior memory reserved by inferior mmap. */
37
38 struct munmap_list
39 {
40 struct munmap_list *next;
41 CORE_ADDR addr, size;
42 };
43
44 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list
45 HEADP. *HEADP needs to be initialized to NULL. */
46
47 static void
48 munmap_list_add (struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size)
49 {
50 struct munmap_list *head_new = XNEW (struct munmap_list);
51
52 head_new->next = *headp;
53 *headp = head_new;
54 head_new->addr = addr;
55 head_new->size = size;
56 }
57
58 /* Free list of inferior mmap memory ranges HEAD. HEAD is the first
59 element of the list, it can be NULL. After calling this function
60 HEAD pointer is invalid and the possible list needs to be
61 reinitialized by caller to NULL. */
62
63 void
64 munmap_list_free (struct munmap_list *head)
65 {
66 while (head)
67 {
68 struct munmap_list *todo = head;
69
70 head = todo->next;
71 gdbarch_infcall_munmap (target_gdbarch (), todo->addr, todo->size);
72 xfree (todo);
73 }
74 }
75
76 /* Stub for munmap_list_free suitable for make_cleanup. Contrary to
77 munmap_list_free this function's parameter is a pointer to the first
78 list element pointer. */
79
80 static void
81 munmap_listp_free_cleanup (void *headp_voidp)
82 {
83 struct munmap_list **headp = (struct munmap_list **) headp_voidp;
84
85 munmap_list_free (*headp);
86 }
87
88 /* Helper data for setup_sections. */
89
90 struct setup_sections_data
91 {
92 /* Size of all recent sections with matching LAST_PROT. */
93 CORE_ADDR last_size;
94
95 /* First section matching LAST_PROT. */
96 asection *last_section_first;
97
98 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
99 unsigned last_prot;
100
101 /* Maximum of alignments of all sections matching LAST_PROT.
102 This value is always at least 1. This value is always a power of 2. */
103 CORE_ADDR last_max_alignment;
104
105 /* List of inferior mmap ranges where setup_sections should add its
106 next range. */
107 struct munmap_list **munmap_list_headp;
108 };
109
110 /* Place all ABFD sections next to each other obeying all constraints. */
111
112 static void
113 setup_sections (bfd *abfd, asection *sect, void *data_voidp)
114 {
115 struct setup_sections_data *data = (struct setup_sections_data *) data_voidp;
116 CORE_ADDR alignment;
117 unsigned prot;
118
119 if (sect != NULL)
120 {
121 /* It is required by later bfd_get_relocated_section_contents. */
122 if (sect->output_section == NULL)
123 sect->output_section = sect;
124
125 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
126 return;
127
128 /* Make the memory always readable. */
129 prot = GDB_MMAP_PROT_READ;
130 if ((bfd_get_section_flags (abfd, sect) & SEC_READONLY) == 0)
131 prot |= GDB_MMAP_PROT_WRITE;
132 if ((bfd_get_section_flags (abfd, sect) & SEC_CODE) != 0)
133 prot |= GDB_MMAP_PROT_EXEC;
134
135 if (compile_debug)
136 fprintf_unfiltered (gdb_stdlog,
137 "module \"%s\" section \"%s\" size %s prot %u\n",
138 bfd_get_filename (abfd),
139 bfd_get_section_name (abfd, sect),
140 paddress (target_gdbarch (),
141 bfd_get_section_size (sect)),
142 prot);
143 }
144 else
145 prot = -1;
146
147 if (sect == NULL
148 || (data->last_prot != prot && bfd_get_section_size (sect) != 0))
149 {
150 CORE_ADDR addr;
151 asection *sect_iter;
152
153 if (data->last_size != 0)
154 {
155 addr = gdbarch_infcall_mmap (target_gdbarch (), data->last_size,
156 data->last_prot);
157 munmap_list_add (data->munmap_list_headp, addr, data->last_size);
158 if (compile_debug)
159 fprintf_unfiltered (gdb_stdlog,
160 "allocated %s bytes at %s prot %u\n",
161 paddress (target_gdbarch (), data->last_size),
162 paddress (target_gdbarch (), addr),
163 data->last_prot);
164 }
165 else
166 addr = 0;
167
168 if ((addr & (data->last_max_alignment - 1)) != 0)
169 error (_("Inferior compiled module address %s "
170 "is not aligned to BFD required %s."),
171 paddress (target_gdbarch (), addr),
172 paddress (target_gdbarch (), data->last_max_alignment));
173
174 for (sect_iter = data->last_section_first; sect_iter != sect;
175 sect_iter = sect_iter->next)
176 if ((bfd_get_section_flags (abfd, sect_iter) & SEC_ALLOC) != 0)
177 bfd_set_section_vma (abfd, sect_iter,
178 addr + bfd_get_section_vma (abfd, sect_iter));
179
180 data->last_size = 0;
181 data->last_section_first = sect;
182 data->last_prot = prot;
183 data->last_max_alignment = 1;
184 }
185
186 if (sect == NULL)
187 return;
188
189 alignment = ((CORE_ADDR) 1) << bfd_get_section_alignment (abfd, sect);
190 data->last_max_alignment = std::max (data->last_max_alignment, alignment);
191
192 data->last_size = (data->last_size + alignment - 1) & -alignment;
193
194 bfd_set_section_vma (abfd, sect, data->last_size);
195
196 data->last_size += bfd_get_section_size (sect);
197 data->last_size = (data->last_size + alignment - 1) & -alignment;
198 }
199
200 /* Helper for link_callbacks callbacks vector. */
201
202 static void
203 link_callbacks_multiple_definition (struct bfd_link_info *link_info,
204 struct bfd_link_hash_entry *h, bfd *nbfd,
205 asection *nsec, bfd_vma nval)
206 {
207 bfd *abfd = link_info->input_bfds;
208
209 if (link_info->allow_multiple_definition)
210 return;
211 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
212 bfd_get_filename (abfd), h->root.string);
213 }
214
215 /* Helper for link_callbacks callbacks vector. */
216
217 static void
218 link_callbacks_warning (struct bfd_link_info *link_info, const char *xwarning,
219 const char *symbol, bfd *abfd, asection *section,
220 bfd_vma address)
221 {
222 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
223 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
224 xwarning);
225 }
226
227 /* Helper for link_callbacks callbacks vector. */
228
229 static void
230 link_callbacks_undefined_symbol (struct bfd_link_info *link_info,
231 const char *name, bfd *abfd, asection *section,
232 bfd_vma address, bfd_boolean is_fatal)
233 {
234 warning (_("Cannot resolve relocation to \"%s\" "
235 "from compiled module \"%s\" section \"%s\"."),
236 name, bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
237 }
238
239 /* Helper for link_callbacks callbacks vector. */
240
241 static void
242 link_callbacks_reloc_overflow (struct bfd_link_info *link_info,
243 struct bfd_link_hash_entry *entry,
244 const char *name, const char *reloc_name,
245 bfd_vma addend, bfd *abfd, asection *section,
246 bfd_vma address)
247 {
248 }
249
250 /* Helper for link_callbacks callbacks vector. */
251
252 static void
253 link_callbacks_reloc_dangerous (struct bfd_link_info *link_info,
254 const char *message, bfd *abfd,
255 asection *section, bfd_vma address)
256 {
257 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
258 "relocation: %s\n"),
259 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
260 message);
261 }
262
263 /* Helper for link_callbacks callbacks vector. */
264
265 static void
266 link_callbacks_unattached_reloc (struct bfd_link_info *link_info,
267 const char *name, bfd *abfd, asection *section,
268 bfd_vma address)
269 {
270 warning (_("Compiled module \"%s\" section \"%s\": unattached "
271 "relocation: %s\n"),
272 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
273 name);
274 }
275
276 /* Helper for link_callbacks callbacks vector. */
277
278 static void link_callbacks_einfo (const char *fmt, ...)
279 ATTRIBUTE_PRINTF (1, 2);
280
281 static void
282 link_callbacks_einfo (const char *fmt, ...)
283 {
284 va_list ap;
285
286 va_start (ap, fmt);
287 std::string str = string_vprintf (fmt, ap);
288 va_end (ap);
289
290 warning (_("Compile module: warning: %s"), str.c_str ());
291 }
292
293 /* Helper for bfd_get_relocated_section_contents.
294 Only these symbols are set by bfd_simple_get_relocated_section_contents
295 but bfd/ seems to use even the NULL ones without checking them first. */
296
297 static const struct bfd_link_callbacks link_callbacks =
298 {
299 NULL, /* add_archive_element */
300 link_callbacks_multiple_definition, /* multiple_definition */
301 NULL, /* multiple_common */
302 NULL, /* add_to_set */
303 NULL, /* constructor */
304 link_callbacks_warning, /* warning */
305 link_callbacks_undefined_symbol, /* undefined_symbol */
306 link_callbacks_reloc_overflow, /* reloc_overflow */
307 link_callbacks_reloc_dangerous, /* reloc_dangerous */
308 link_callbacks_unattached_reloc, /* unattached_reloc */
309 NULL, /* notice */
310 link_callbacks_einfo, /* einfo */
311 NULL, /* info */
312 NULL, /* minfo */
313 NULL, /* override_segment_assignment */
314 };
315
316 struct link_hash_table_cleanup_data
317 {
318 bfd *abfd;
319 bfd *link_next;
320 };
321
322 /* Cleanup callback for struct bfd_link_info. */
323
324 static void
325 link_hash_table_free (void *d)
326 {
327 struct link_hash_table_cleanup_data *data
328 = (struct link_hash_table_cleanup_data *) d;
329
330 if (data->abfd->is_linker_output)
331 (*data->abfd->link.hash->hash_table_free) (data->abfd);
332 data->abfd->link.next = data->link_next;
333 }
334
335 /* Relocate and store into inferior memory each section SECT of ABFD. */
336
337 static void
338 copy_sections (bfd *abfd, asection *sect, void *data)
339 {
340 asymbol **symbol_table = (asymbol **) data;
341 bfd_byte *sect_data, *sect_data_got;
342 struct cleanup *cleanups;
343 struct bfd_link_info link_info;
344 struct bfd_link_order link_order;
345 CORE_ADDR inferior_addr;
346 struct link_hash_table_cleanup_data cleanup_data;
347
348 if ((bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD))
349 != (SEC_ALLOC | SEC_LOAD))
350 return;
351
352 if (bfd_get_section_size (sect) == 0)
353 return;
354
355 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
356 cannot use as it does not report relocations to undefined symbols. */
357 memset (&link_info, 0, sizeof (link_info));
358 link_info.output_bfd = abfd;
359 link_info.input_bfds = abfd;
360 link_info.input_bfds_tail = &abfd->link.next;
361
362 cleanup_data.abfd = abfd;
363 cleanup_data.link_next = abfd->link.next;
364
365 abfd->link.next = NULL;
366 link_info.hash = bfd_link_hash_table_create (abfd);
367
368 cleanups = make_cleanup (link_hash_table_free, &cleanup_data);
369 link_info.callbacks = &link_callbacks;
370
371 memset (&link_order, 0, sizeof (link_order));
372 link_order.next = NULL;
373 link_order.type = bfd_indirect_link_order;
374 link_order.offset = 0;
375 link_order.size = bfd_get_section_size (sect);
376 link_order.u.indirect.section = sect;
377
378 sect_data = (bfd_byte *) xmalloc (bfd_get_section_size (sect));
379 make_cleanup (xfree, sect_data);
380
381 sect_data_got = bfd_get_relocated_section_contents (abfd, &link_info,
382 &link_order, sect_data,
383 FALSE, symbol_table);
384
385 if (sect_data_got == NULL)
386 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
387 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
388 bfd_errmsg (bfd_get_error ()));
389 gdb_assert (sect_data_got == sect_data);
390
391 inferior_addr = bfd_get_section_vma (abfd, sect);
392 if (0 != target_write_memory (inferior_addr, sect_data,
393 bfd_get_section_size (sect)))
394 error (_("Cannot write compiled module \"%s\" section \"%s\" "
395 "to inferior memory range %s-%s."),
396 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
397 paddress (target_gdbarch (), inferior_addr),
398 paddress (target_gdbarch (),
399 inferior_addr + bfd_get_section_size (sect)));
400
401 do_cleanups (cleanups);
402 }
403
404 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
405 symbols in OBJFILE so we can calculate how much memory to allocate
406 for the out parameter. This avoids needing a malloc in the generated
407 code. Throw an error if anything fails.
408 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
409 If it finds user tries to print an array type this function returns
410 NULL. Caller will then regenerate the code with
411 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
412 This is because __auto_type array-to-pointer type conversion of
413 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
414 preserving the array type. */
415
416 static struct type *
417 get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
418 enum compile_i_scope_types scope)
419 {
420 struct symbol *gdb_ptr_type_sym;
421 /* Initialize it just to avoid a GCC false warning. */
422 struct symbol *gdb_val_sym = NULL;
423 struct type *gdb_ptr_type, *gdb_type_from_ptr, *gdb_type, *retval;
424 /* Initialize it just to avoid a GCC false warning. */
425 const struct block *block = NULL;
426 const struct blockvector *bv;
427 int nblocks = 0;
428 int block_loop = 0;
429
430 bv = SYMTAB_BLOCKVECTOR (func_sym->owner.symtab);
431 nblocks = BLOCKVECTOR_NBLOCKS (bv);
432
433 gdb_ptr_type_sym = NULL;
434 for (block_loop = 0; block_loop < nblocks; block_loop++)
435 {
436 struct symbol *function = NULL;
437 const struct block *function_block;
438
439 block = BLOCKVECTOR_BLOCK (bv, block_loop);
440 if (BLOCK_FUNCTION (block) != NULL)
441 continue;
442 gdb_val_sym = block_lookup_symbol (block,
443 COMPILE_I_EXPR_VAL,
444 symbol_name_match_type::SEARCH_NAME,
445 VAR_DOMAIN);
446 if (gdb_val_sym == NULL)
447 continue;
448
449 function_block = block;
450 while (function_block != BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)
451 && function_block != BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
452 {
453 function_block = BLOCK_SUPERBLOCK (function_block);
454 function = BLOCK_FUNCTION (function_block);
455 if (function != NULL)
456 break;
457 }
458 if (function != NULL
459 && (BLOCK_SUPERBLOCK (function_block)
460 == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
461 && (strcmp (SYMBOL_LINKAGE_NAME (function), GCC_FE_WRAPPER_FUNCTION)
462 == 0))
463 break;
464 }
465 if (block_loop == nblocks)
466 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
467
468 gdb_type = SYMBOL_TYPE (gdb_val_sym);
469 gdb_type = check_typedef (gdb_type);
470
471 gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
472 symbol_name_match_type::SEARCH_NAME,
473 VAR_DOMAIN);
474 if (gdb_ptr_type_sym == NULL)
475 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
476 gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym);
477 gdb_ptr_type = check_typedef (gdb_ptr_type);
478 if (TYPE_CODE (gdb_ptr_type) != TYPE_CODE_PTR)
479 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
480 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_ptr_type);
481
482 if (types_deeply_equal (gdb_type, gdb_type_from_ptr))
483 {
484 if (scope != COMPILE_I_PRINT_ADDRESS_SCOPE)
485 error (_("Expected address scope in compiled module \"%s\"."),
486 objfile_name (objfile));
487 return gdb_type;
488 }
489
490 if (TYPE_CODE (gdb_type) != TYPE_CODE_PTR)
491 error (_("Invalid type code %d of symbol \"%s\" "
492 "in compiled module \"%s\"."),
493 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_VAL,
494 objfile_name (objfile));
495
496 retval = gdb_type_from_ptr;
497 switch (TYPE_CODE (gdb_type_from_ptr))
498 {
499 case TYPE_CODE_ARRAY:
500 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr);
501 break;
502 case TYPE_CODE_FUNC:
503 break;
504 default:
505 error (_("Invalid type code %d of symbol \"%s\" "
506 "in compiled module \"%s\"."),
507 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_PTR_TYPE,
508 objfile_name (objfile));
509 }
510 if (!types_deeply_equal (gdb_type_from_ptr,
511 TYPE_TARGET_TYPE (gdb_type)))
512 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
513 "in compiled module \"%s\"."),
514 COMPILE_I_EXPR_PTR_TYPE, COMPILE_I_EXPR_VAL,
515 objfile_name (objfile));
516 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE)
517 return NULL;
518 return retval;
519 }
520
521 /* Fetch the type of first parameter of FUNC_SYM.
522 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
523
524 static struct type *
525 get_regs_type (struct symbol *func_sym, struct objfile *objfile)
526 {
527 struct type *func_type = SYMBOL_TYPE (func_sym);
528 struct type *regsp_type, *regs_type;
529
530 /* No register parameter present. */
531 if (TYPE_NFIELDS (func_type) == 0)
532 return NULL;
533
534 regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
535 if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
536 error (_("Invalid type code %d of first parameter of function \"%s\" "
537 "in compiled module \"%s\"."),
538 TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
539 objfile_name (objfile));
540
541 regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
542 if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
543 error (_("Invalid type code %d of dereferenced first parameter "
544 "of function \"%s\" in compiled module \"%s\"."),
545 TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
546 objfile_name (objfile));
547
548 return regs_type;
549 }
550
551 /* Store all inferior registers required by REGS_TYPE to inferior memory
552 starting at inferior address REGS_BASE. */
553
554 static void
555 store_regs (struct type *regs_type, CORE_ADDR regs_base)
556 {
557 struct gdbarch *gdbarch = target_gdbarch ();
558 struct regcache *regcache = get_thread_regcache (inferior_ptid);
559 int fieldno;
560
561 for (fieldno = 0; fieldno < TYPE_NFIELDS (regs_type); fieldno++)
562 {
563 const char *reg_name = TYPE_FIELD_NAME (regs_type, fieldno);
564 ULONGEST reg_bitpos = TYPE_FIELD_BITPOS (regs_type, fieldno);
565 ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno);
566 ULONGEST reg_offset;
567 struct type *reg_type = check_typedef (TYPE_FIELD_TYPE (regs_type,
568 fieldno));
569 ULONGEST reg_size = TYPE_LENGTH (reg_type);
570 int regnum;
571 struct value *regval;
572 CORE_ADDR inferior_addr;
573
574 if (strcmp (reg_name, COMPILE_I_SIMPLE_REGISTER_DUMMY) == 0)
575 continue;
576
577 if ((reg_bitpos % 8) != 0 || reg_bitsize != 0)
578 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
579 reg_name, pulongest (reg_bitpos), pulongest (reg_bitsize));
580 reg_offset = reg_bitpos / 8;
581
582 if (TYPE_CODE (reg_type) != TYPE_CODE_INT
583 && TYPE_CODE (reg_type) != TYPE_CODE_PTR)
584 error (_("Invalid register \"%s\" type code %d"), reg_name,
585 TYPE_CODE (reg_type));
586
587 regnum = compile_register_name_demangle (gdbarch, reg_name);
588
589 regval = value_from_register (reg_type, regnum, get_current_frame ());
590 if (value_optimized_out (regval))
591 error (_("Register \"%s\" is optimized out."), reg_name);
592 if (!value_entirely_available (regval))
593 error (_("Register \"%s\" is not available."), reg_name);
594
595 inferior_addr = regs_base + reg_offset;
596 if (0 != target_write_memory (inferior_addr, value_contents (regval),
597 reg_size))
598 error (_("Cannot write register \"%s\" to inferior memory at %s."),
599 reg_name, paddress (gdbarch, inferior_addr));
600 }
601 }
602
603 /* Load the object file specified in FILE_NAMES into inferior memory.
604 Throw an error otherwise. Caller must fully dispose the return
605 value by calling compile_object_run. Returns NULL only for
606 COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
607 should have been used instead. */
608
609 struct compile_module *
610 compile_object_load (const compile_file_names &file_names,
611 enum compile_i_scope_types scope, void *scope_data)
612 {
613 struct cleanup *cleanups;
614 struct setup_sections_data setup_sections_data;
615 CORE_ADDR regs_addr, out_value_addr = 0;
616 struct symbol *func_sym;
617 struct type *func_type;
618 struct bound_minimal_symbol bmsym;
619 long storage_needed;
620 asymbol **symbol_table, **symp;
621 long number_of_symbols, missing_symbols;
622 struct compile_module *retval;
623 struct type *regs_type, *out_value_type = NULL;
624 char **matching;
625 struct objfile *objfile;
626 int expect_parameters;
627 struct type *expect_return_type;
628 struct munmap_list *munmap_list_head = NULL;
629
630 gdb::unique_xmalloc_ptr<char> filename
631 (tilde_expand (file_names.object_file ()));
632
633 gdb_bfd_ref_ptr abfd (gdb_bfd_open (filename.get (), gnutarget, -1));
634 if (abfd == NULL)
635 error (_("\"%s\": could not open as compiled module: %s"),
636 filename.get (), bfd_errmsg (bfd_get_error ()));
637
638 if (!bfd_check_format_matches (abfd.get (), bfd_object, &matching))
639 error (_("\"%s\": not in loadable format: %s"),
640 filename.get (), gdb_bfd_errmsg (bfd_get_error (), matching));
641
642 if ((bfd_get_file_flags (abfd.get ()) & (EXEC_P | DYNAMIC)) != 0)
643 error (_("\"%s\": not in object format."), filename.get ());
644
645 setup_sections_data.last_size = 0;
646 setup_sections_data.last_section_first = abfd->sections;
647 setup_sections_data.last_prot = -1;
648 setup_sections_data.last_max_alignment = 1;
649 setup_sections_data.munmap_list_headp = &munmap_list_head;
650 cleanups = make_cleanup (munmap_listp_free_cleanup, &munmap_list_head);
651 bfd_map_over_sections (abfd.get (), setup_sections, &setup_sections_data);
652 setup_sections (abfd.get (), NULL, &setup_sections_data);
653
654 storage_needed = bfd_get_symtab_upper_bound (abfd.get ());
655 if (storage_needed < 0)
656 error (_("Cannot read symbols of compiled module \"%s\": %s"),
657 filename.get (), bfd_errmsg (bfd_get_error ()));
658
659 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
660 "Reading symbols from ..." message for automatically generated file. */
661 std::unique_ptr<struct objfile> objfile_holder
662 (symbol_file_add_from_bfd (abfd.get (), filename.get (),
663 0, NULL, 0, NULL));
664 objfile = objfile_holder.get ();
665
666 func_sym = lookup_global_symbol_from_objfile (objfile,
667 GCC_FE_WRAPPER_FUNCTION,
668 VAR_DOMAIN).symbol;
669 if (func_sym == NULL)
670 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
671 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
672 func_type = SYMBOL_TYPE (func_sym);
673 if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
674 error (_("Invalid type code %d of function \"%s\" in compiled "
675 "module \"%s\"."),
676 TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
677 objfile_name (objfile));
678
679 switch (scope)
680 {
681 case COMPILE_I_SIMPLE_SCOPE:
682 expect_parameters = 1;
683 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
684 break;
685 case COMPILE_I_RAW_SCOPE:
686 expect_parameters = 0;
687 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
688 break;
689 case COMPILE_I_PRINT_ADDRESS_SCOPE:
690 case COMPILE_I_PRINT_VALUE_SCOPE:
691 expect_parameters = 2;
692 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
693 break;
694 default:
695 internal_error (__FILE__, __LINE__, _("invalid scope %d"), scope);
696 }
697 if (TYPE_NFIELDS (func_type) != expect_parameters)
698 error (_("Invalid %d parameters of function \"%s\" in compiled "
699 "module \"%s\"."),
700 TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
701 objfile_name (objfile));
702 if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type)))
703 error (_("Invalid return type of function \"%s\" in compiled "
704 "module \"%s\"."),
705 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
706
707 /* The memory may be later needed
708 by bfd_generic_get_relocated_section_contents
709 called from default_symfile_relocate. */
710 symbol_table = (asymbol **) obstack_alloc (&objfile->objfile_obstack,
711 storage_needed);
712 number_of_symbols = bfd_canonicalize_symtab (abfd.get (), symbol_table);
713 if (number_of_symbols < 0)
714 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
715 filename.get (), bfd_errmsg (bfd_get_error ()));
716
717 missing_symbols = 0;
718 for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
719 {
720 asymbol *sym = *symp;
721
722 if (sym->flags != 0)
723 continue;
724 sym->flags = BSF_GLOBAL;
725 sym->section = bfd_abs_section_ptr;
726 if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
727 {
728 if (compile_debug)
729 fprintf_unfiltered (gdb_stdlog,
730 "ELF symbol \"%s\" relocated to zero\n",
731 sym->name);
732
733 /* It seems to be a GCC bug, with -mcmodel=large there should be no
734 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
735 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
736 sym->value = 0;
737 continue;
738 }
739 bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
740 switch (bmsym.minsym == NULL
741 ? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
742 {
743 case mst_text:
744 sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
745 if (compile_debug)
746 fprintf_unfiltered (gdb_stdlog,
747 "ELF mst_text symbol \"%s\" relocated to %s\n",
748 sym->name,
749 paddress (target_gdbarch (), sym->value));
750 break;
751 case mst_text_gnu_ifunc:
752 sym->value = gnu_ifunc_resolve_addr (target_gdbarch (),
753 BMSYMBOL_VALUE_ADDRESS (bmsym));
754 if (compile_debug)
755 fprintf_unfiltered (gdb_stdlog,
756 "ELF mst_text_gnu_ifunc symbol \"%s\" "
757 "relocated to %s\n",
758 sym->name,
759 paddress (target_gdbarch (), sym->value));
760 break;
761 default:
762 warning (_("Could not find symbol \"%s\" "
763 "for compiled module \"%s\"."),
764 sym->name, filename.get ());
765 missing_symbols++;
766 }
767 }
768 if (missing_symbols)
769 error (_("%ld symbols were missing, cannot continue."), missing_symbols);
770
771 bfd_map_over_sections (abfd.get (), copy_sections, symbol_table);
772
773 regs_type = get_regs_type (func_sym, objfile);
774 if (regs_type == NULL)
775 regs_addr = 0;
776 else
777 {
778 /* Use read-only non-executable memory protection. */
779 regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
780 TYPE_LENGTH (regs_type),
781 GDB_MMAP_PROT_READ);
782 gdb_assert (regs_addr != 0);
783 munmap_list_add (&munmap_list_head, regs_addr, TYPE_LENGTH (regs_type));
784 if (compile_debug)
785 fprintf_unfiltered (gdb_stdlog,
786 "allocated %s bytes at %s for registers\n",
787 paddress (target_gdbarch (),
788 TYPE_LENGTH (regs_type)),
789 paddress (target_gdbarch (), regs_addr));
790 store_regs (regs_type, regs_addr);
791 }
792
793 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE
794 || scope == COMPILE_I_PRINT_VALUE_SCOPE)
795 {
796 out_value_type = get_out_value_type (func_sym, objfile, scope);
797 if (out_value_type == NULL)
798 {
799 do_cleanups (cleanups);
800 return NULL;
801 }
802 check_typedef (out_value_type);
803 out_value_addr = gdbarch_infcall_mmap (target_gdbarch (),
804 TYPE_LENGTH (out_value_type),
805 (GDB_MMAP_PROT_READ
806 | GDB_MMAP_PROT_WRITE));
807 gdb_assert (out_value_addr != 0);
808 munmap_list_add (&munmap_list_head, out_value_addr,
809 TYPE_LENGTH (out_value_type));
810 if (compile_debug)
811 fprintf_unfiltered (gdb_stdlog,
812 "allocated %s bytes at %s for printed value\n",
813 paddress (target_gdbarch (),
814 TYPE_LENGTH (out_value_type)),
815 paddress (target_gdbarch (), out_value_addr));
816 }
817
818 retval = XNEW (struct compile_module);
819 retval->objfile = objfile_holder.release ();
820 retval->source_file = xstrdup (file_names.source_file ());
821 retval->func_sym = func_sym;
822 retval->regs_addr = regs_addr;
823 retval->scope = scope;
824 retval->scope_data = scope_data;
825 retval->out_value_type = out_value_type;
826 retval->out_value_addr = out_value_addr;
827
828 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
829 retval->munmap_list_head = munmap_list_head;
830 munmap_list_head = NULL;
831
832 do_cleanups (cleanups);
833
834 return retval;
835 }
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
COMPILE_I_EXPR_PTR_TYPE
#define COMPILE_I_EXPR_PTR_TYPE
Definition: compile-internal.h:94
string
const char * string
Definition: signals.c:50
gdbarch_infcall_munmap
void gdbarch_infcall_munmap(struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR size)
Definition: gdbarch.c:4979
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
symbol::owner
union symbol::@173 owner
reg_offset
static int reg_offset[]
Definition: i386-gnu-nat.c:46
copy_sections
static void copy_sections(bfd *abfd, asection *sect, void *data)
Definition: compile-object-load.c:338
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
link_callbacks_unattached_reloc
static void link_callbacks_unattached_reloc(struct bfd_link_info *link_info, const char *name, bfd *abfd, asection *section, bfd_vma address)
Definition: compile-object-load.c:266
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
target_write_memory
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1451
munmap_list
Definition: compile-object-load.c:38
link_callbacks_multiple_definition
static void link_callbacks_multiple_definition(struct bfd_link_info *link_info, struct bfd_link_hash_entry *h, bfd *nbfd, asection *nsec, bfd_vma nval)
Definition: compile-object-load.c:203
munmap_list::size
CORE_ADDR size
Definition: compile-object-load.c:41
command.h
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
link_callbacks_reloc_dangerous
static void link_callbacks_reloc_dangerous(struct bfd_link_info *link_info, const char *message, bfd *abfd, asection *section, bfd_vma address)
Definition: compile-object-load.c:253
xfree
void xfree(void *)
symbol::symtab
struct symtab * symtab
Definition: symtab.h:1068
compile_file_names::source_file
const char * source_file() const
Definition: compile-internal.h:166
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
func_type
Definition: gdbtypes.h:1059
warning
void warning(const char *fmt,...)
Definition: errors.c:26
compile_module::munmap_list_head
struct munmap_list * munmap_list_head
Definition: compile-object-load.h:54
setup_sections_data::last_size
CORE_ADDR last_size
Definition: compile-object-load.c:93
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
TYPE_CODE_INT
Definition: gdbtypes.h:111
memset
void * memset(T *s, int c, size_t n)=delete
compile_debug
int compile_debug
Definition: compile.c:57
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
compile_module::out_value_addr
CORE_ADDR out_value_addr
Definition: compile-object-load.h:51
compile_i_scope_types
compile_i_scope_types
Definition: defs.h:61
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
mst_text_gnu_ifunc
Definition: symtab.h:583
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
arch-utils.h
XNEW
#define XNEW(T)
Definition: poison.h:109
BLOCK_FUNCTION
#define BLOCK_FUNCTION(bl)
Definition: block.h:107
compile-object-load.h
GLOBAL_BLOCK
Definition: defs.h:686
types_deeply_equal
int types_deeply_equal(struct type *type1, struct type *type2)
Definition: gdbtypes.c:3666
link_hash_table_cleanup_data
Definition: compile-object-load.c:316
setup_sections_data::munmap_list_headp
struct munmap_list ** munmap_list_headp
Definition: compile-object-load.c:107
name
const char *const name
Definition: aarch64-tdep.c:76
value_from_register
struct value * value_from_register(struct type *type, int regnum, struct frame_info *frame)
Definition: findvar.c:902
link_callbacks_reloc_overflow
static void link_callbacks_reloc_overflow(struct bfd_link_info *link_info, struct bfd_link_hash_entry *entry, const char *name, const char *reloc_name, bfd_vma addend, bfd *abfd, asection *section, bfd_vma address)
Definition: compile-object-load.c:242
SYMTAB_BLOCKVECTOR
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:1334
symbol_file_add_from_bfd
struct objfile * symbol_file_add_from_bfd(bfd *abfd, const char *name, symfile_add_flags add_flags, struct section_addr_info *addrs, objfile_flags flags, struct objfile *parent)
Definition: symfile.c:1257
gdb::ref_ptr
Definition: gdb_ref_ptr.h:49
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
gdb_bfd_open
gdb_bfd_ref_ptr gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:383
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
COMPILE_I_PRINT_ADDRESS_SCOPE
Definition: defs.h:81
gnutarget
char * gnutarget
Definition: corefile.c:442
string_vprintf
std::string string_vprintf(const char *fmt, va_list args)
Definition: common-utils.c:173
link_callbacks
static const struct bfd_link_callbacks link_callbacks
Definition: compile-object-load.c:297
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
regcache.h
bound_minimal_symbol
Definition: minsyms.h:29
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
COMPILE_I_SIMPLE_REGISTER_DUMMY
#define COMPILE_I_SIMPLE_REGISTER_DUMMY
Definition: compile-internal.h:90
link_hash_table_cleanup_data::abfd
bfd * abfd
Definition: compile-object-load.c:318
inferior.h
blockvector::nblocks
int nblocks
Definition: block.h:115
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
pulongest
char * pulongest(ULONGEST u)
Definition: print-utils.c:129
COMPILE_I_EXPR_VAL
#define COMPILE_I_EXPR_VAL
Definition: compile-internal.h:93
type
Definition: gdbtypes.h:749
ATTRIBUTE_PRINTF
#define ATTRIBUTE_PRINTF
Definition: common-defs.h:70
gdbarch_infcall_mmap
CORE_ADDR gdbarch_infcall_mmap(struct gdbarch *gdbarch, CORE_ADDR size, unsigned prot)
Definition: gdbarch.c:4962
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
link_callbacks_einfo
static void link_callbacks_einfo(const char *fmt,...) ATTRIBUTE_PRINTF(1
Definition: compile-object-load.c:282
GDB_MMAP_PROT_READ
#define GDB_MMAP_PROT_READ
Definition: arch-utils.h:243
GDB_MMAP_PROT_WRITE
#define GDB_MMAP_PROT_WRITE
Definition: arch-utils.h:244
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
GDB_MMAP_PROT_EXEC
#define GDB_MMAP_PROT_EXEC
Definition: arch-utils.h:245
gdb_bfd_errmsg
const char * gdb_bfd_errmsg(bfd_error_type error_tag, char **matching)
Definition: utils.c:3100
regnum
int regnum
Definition: aarch64-tdep.c:77
compile_file_names
Definition: compile-internal.h:155
objfile_name
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1557
xmalloc
void * xmalloc(YYSIZE_T)
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
TYPE_FIELD_BITSIZE
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1380
compile_module
Definition: compile-object-load.h:24
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
link_callbacks_undefined_symbol
static void link_callbacks_undefined_symbol(struct bfd_link_info *link_info, const char *name, bfd *abfd, asection *section, bfd_vma address, bfd_boolean is_fatal)
Definition: compile-object-load.c:230
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
compile_module::source_file
char * source_file
Definition: compile-object-load.h:30
value
Definition: value.c:169
link_hash_table_cleanup_data::link_next
bfd * link_next
Definition: compile-object-load.c:319
blockvector
Definition: block.h:112
objfile
Definition: objfiles.h:286
TYPE_CODE_PTR
Definition: gdbtypes.h:84
compile_object_load
struct compile_module * compile_object_load(const compile_file_names &file_names, enum compile_i_scope_types scope, void *scope_data)
Definition: compile-object-load.c:610
compile.h
compile_module::scope
enum compile_i_scope_types scope
Definition: compile-object-load.h:40
setup_sections_data::last_section_first
asection * last_section_first
Definition: compile-object-load.c:96
value_entirely_available
int value_entirely_available(struct value *value)
Definition: value.c:374
store_regs
static void store_regs(struct type *regs_type, CORE_ADDR regs_base)
Definition: compile-object-load.c:555
MSYMBOL_TYPE
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:680
COMPILE_I_PRINT_VALUE_SCOPE
Definition: defs.h:82
value_optimized_out
int value_optimized_out(struct value *value)
Definition: value.c:1424
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
compile_module::func_sym
struct symbol * func_sym
Definition: compile-object-load.h:33
lookup_global_symbol_from_objfile
struct block_symbol lookup_global_symbol_from_objfile(struct objfile *main_objfile, const char *name, const domain_enum domain)
Definition: symtab.c:2226
setup_sections_data::last_prot
unsigned last_prot
Definition: compile-object-load.c:99
gdbcore.h
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
symbol_name_match_type::SEARCH_NAME
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
compile-internal.h
munmap_list_free
void munmap_list_free(struct munmap_list *head)
Definition: compile-object-load.c:64
munmap_list::addr
CORE_ADDR addr
Definition: compile-object-load.c:41
mst_unknown
Definition: symtab.h:581
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
mst_text
Definition: symtab.h:582
setup_sections_data
Definition: compile-object-load.c:90
gdb::ref_ptr::get
T * get() const
Definition: gdb_ref_ptr.h:130
BLOCKVECTOR_NBLOCKS
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:124
VAR_DOMAIN
Definition: symtab.h:739
setup_sections
static void setup_sections(bfd *abfd, asection *sect, void *data_voidp)
Definition: compile-object-load.c:113
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
STATIC_BLOCK
Definition: defs.h:687
munmap_list::next
struct munmap_list * next
Definition: compile-object-load.c:40
regcache
Definition: regcache.h:232
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
symbol
Definition: symtab.h:1049
compile_module::regs_addr
CORE_ADDR regs_addr
Definition: compile-object-load.h:37
compile_module::scope_data
void * scope_data
Definition: compile-object-load.h:43
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
munmap_list_add
static void munmap_list_add(struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size)
Definition: compile-object-load.c:48
setup_sections_data::last_max_alignment
CORE_ADDR last_max_alignment
Definition: compile-object-load.c:103
get_regs_type
static struct type * get_regs_type(struct symbol *func_sym, struct objfile *objfile)
Definition: compile-object-load.c:525
objfile::objfile_obstack
Definition: objfiles.h:357
COMPILE_I_SIMPLE_SCOPE
Definition: defs.h:69
COMPILE_I_RAW_SCOPE
Definition: defs.h:73
block_lookup_symbol
struct symbol * block_lookup_symbol(const struct block *block, const char *name, symbol_name_match_type match_type, const domain_enum domain)
Definition: block.c:675
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
compile_module::objfile
struct objfile * objfile
Definition: compile-object-load.h:27
munmap_listp_free_cleanup
static void munmap_listp_free_cleanup(void *headp_voidp)
Definition: compile-object-load.c:81
link_hash_table_free
static void link_hash_table_free(void *d)
Definition: compile-object-load.c:325
gdbcmd.h
builtin_type::builtin_void
struct type * builtin_void
Definition: gdbtypes.h:1500
compile_file_names::object_file
const char * object_file() const
Definition: compile-internal.h:169
error
void error(const char *fmt,...)
Definition: errors.c:38
link_callbacks_warning
static void link_callbacks_warning(struct bfd_link_info *link_info, const char *xwarning, const char *symbol, bfd *abfd, asection *section, bfd_vma address)
Definition: compile-object-load.c:218
size
size_t size
Definition: go32-nat.c:242
compile_register_name_demangle
int compile_register_name_demangle(struct gdbarch *gdbarch, const char *reg_name)
Definition: compile.c:661
compile_module::out_value_type
struct type * out_value_type
Definition: compile-object-load.h:47
block.h
gnu_ifunc_resolve_addr
#define gnu_ifunc_resolve_addr
Definition: symtab.h:1736
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
get_out_value_type
static struct type * get_out_value_type(struct symbol *func_sym, struct objfile *objfile, enum compile_i_scope_types scope)
Definition: compile-object-load.c:417