Top ¶

2.2.1.1 bfd_get_error ¶

Function: bfd_error_type bfd_get_error (void); ¶

Return the current BFD error condition.

2.2.1.2 bfd_set_error ¶

Function: void bfd_set_error (bfd_error_type error_tag); ¶

Set the BFD error condition to be error_tag.

error_tag must not be bfd_error_on_input. Use bfd_set_input_error for input errors instead.

2.2.1.3 bfd_set_input_error ¶

Function: void bfd_set_input_error (bfd *input, bfd_error_type error_tag); ¶

Set the BFD error condition to be bfd_error_on_input. input is the input bfd where the error occurred, and error_tag the bfd_error_type error.

2.2.1.4 bfd_errmsg ¶

Function: const char *bfd_errmsg (bfd_error_type error_tag); ¶

Return a string describing the error error_tag, or the system error if error_tag is bfd_error_system_call.

2.2.1.5 bfd_perror ¶

Function: void bfd_perror (const char *message); ¶

Print to the standard error stream a string describing the last BFD error that occurred, or the last system error if the last BFD error was a system call failure. If message is non-NULL and non-empty, the error string printed is preceded by message, a colon, and a space. It is followed by a newline.

2.2.1.6 _bfd_clear_error_data ¶

Function: void _bfd_clear_error_data (void); ¶

Free any data associated with the BFD error.

2.2.1.7 bfd_asprintf ¶

Function: char *bfd_asprintf (const char *fmt, ...); ¶

Primarily for error reporting, this function is like libiberty’s xasprintf except that it can return NULL on no memory and the returned string should not be freed. Uses a thread-local malloc’d buffer managed by libbfd, _bfd_error_buf. Be aware that a call to this function frees the result of any previous call. bfd_errmsg (bfd_error_on_input) also calls this function.

2.2.2.1 bfd_print_error ¶

Function: void bfd_print_error (bfd_print_callback print_func, void *stream, const char *fmt, va_list ap); ¶

This formats FMT and AP according to BFD "printf" rules, sending the output to STREAM by repeated calls to PRINT_FUNC. PRINT_FUNC is a printf-like function; it does not need to implement the BFD printf format extensions. This can be used in a callback that is set via bfd_set_error_handler to turn the error into ordinary output.

2.2.2.2 _bfd_error_handler ¶

Function: void _bfd_error_handler (const char *fmt, ...) ATTRIBUTE_PRINTF_1; ¶

This is the default routine to handle BFD error messages. Like fprintf (stderr, ...), but also handles some extra format specifiers.

%pA section name from section. For group components, prints group name too. %pB file name from bfd. For archive components, prints archive too.

Beware: Only supports a maximum of 9 format arguments.

2.2.2.3 bfd_set_error_handler ¶

Function: bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); ¶

Set the BFD error handler function. Returns the previous function.

2.2.2.4 _bfd_set_error_handler_caching ¶

Function: struct per_xvec_messages *_bfd_set_error_handler_caching (struct per_xvec_messages *); ¶

Set the BFD error handler function to one that stores messages to the per_xvec_messages object. Returns the previous object to which messages are stored. Note that two sequential calls to this with a non-NULL argument will cause output to be dropped, rather than gathered.

2.2.2.5 _bfd_restore_error_handler_caching ¶

Function: void _bfd_restore_error_handler_caching (struct per_xvec_messages *); ¶

Reset the BFD error handler object to an earlier value.

2.2.2.6 bfd_set_error_program_name ¶

Function: void bfd_set_error_program_name (const char *); ¶

Set the program name to use when printing a BFD error. This is printed before the error message followed by a colon and space. The string must not be changed after it is passed to this function.

2.2.2.7 _bfd_get_error_program_name ¶

Function: const char *_bfd_get_error_program_name (void); ¶

Get the program name used when printing a BFD error.

2.2.3.1 bfd_set_assert_handler ¶

Function: bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type); ¶

Set the BFD assert handler function. Returns the previous function.

2.2.3.2 bfd_init ¶

Function: unsigned int bfd_init (void); ¶

This routine must be called before any other BFD function to initialize magical internal data structures. Returns a magic number, which may be used to check that the bfd library is configured as expected by users.

/* Value returned by bfd_init.  */
#define BFD_INIT_MAGIC (sizeof (struct bfd_section))

2.3.1.1 bfd_thread_init ¶

Function: bool bfd_thread_init (bfd_lock_unlock_fn_type lock, bfd_lock_unlock_fn_type unlock, void *data); ¶

Initialize BFD threading. The functions passed in will be used to lock and unlock global data structures. This may only be called a single time in a given process. Returns true on success and false on error. DATA is passed verbatim to the lock and unlock functions. The lock and unlock functions should return true on success, or set the BFD error and return false on failure.

2.3.1.2 bfd_thread_cleanup ¶

Function: void bfd_thread_cleanup (void); ¶

Clean up any thread-local state. This should be called by a thread that uses any BFD functions, before the thread exits. It is fine to call this multiple times, or to call it and then later call BFD functions on the same thread again.

2.3.1.3 bfd_lock ¶

Function: bool bfd_lock (void); ¶

Acquire the global BFD lock, if needed. Returns true on success, false on error.

2.3.1.4 bfd_unlock ¶

Function: bool bfd_unlock (void); ¶

Release the global BFD lock, if needed. Returns true on success, false on error.

2.4.1.1 bfd_get_reloc_upper_bound ¶

Function: long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); ¶

Return the number of bytes required to store the relocation information associated with section sect attached to bfd abfd. If an error occurs, return -1.

2.4.1.2 bfd_canonicalize_reloc ¶

Function: long bfd_canonicalize_reloc (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); ¶

Call the back end associated with the open BFD abfd and translate the external form of the relocation information attached to sec into the internal canonical form. Place the table into memory at loc, which has been preallocated, usually by a call to bfd_get_reloc_upper_bound. Returns the number of relocs, or -1 on error.

The syms table is also needed for horrible internal magic reasons.

2.4.1.3 bfd_set_reloc ¶

Function: void bfd_set_reloc (bfd *abfd, asection *sec, arelent **rel, unsigned int count); ¶

Set the relocation pointer and count within section sec to the values rel and count. The argument abfd is ignored.

#define bfd_set_reloc(abfd, asect, location, count) \
       BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count))

2.4.1.4 bfd_set_file_flags ¶

Function: bool bfd_set_file_flags (bfd *abfd, flagword flags); ¶

Set the flag word in the BFD abfd to the value flags.

Possible errors are:

• bfd_error_wrong_format - The target bfd was not of object format.
• bfd_error_invalid_operation - The target bfd was open for reading.
• bfd_error_invalid_operation - The flag word contained a bit which was not applicable to the type of file. E.g., an attempt was made to set the D_PAGED bit on a BFD format which does not support demand paging.

2.4.1.5 bfd_get_arch_size ¶

Function: int bfd_get_arch_size (bfd *abfd); ¶

Returns the normalized architecture address size, in bits, as determined by the object file’s format. By normalized, we mean either 32 or 64. For ELF, this information is included in the header. Use bfd_arch_bits_per_address for number of bits in the architecture address.

Returns the arch size in bits if known, -1 otherwise.

2.4.1.6 bfd_get_sign_extend_vma ¶

Function: int bfd_get_sign_extend_vma (bfd *abfd); ¶

Indicates if the target architecture "naturally" sign extends an address. Some architectures implicitly sign extend address values when they are converted to types larger than the size of an address. For instance, bfd_get_start_address() will return an address sign extended to fill a bfd_vma when this is the case.

Returns 1 if the target architecture is known to sign extend addresses, 0 if the target architecture is known to not sign extend addresses, and -1 otherwise.

2.4.1.7 bfd_set_start_address ¶

Function: bool bfd_set_start_address (bfd *abfd, bfd_vma vma); ¶

Make vma the entry point of output BFD abfd.

Returns TRUE on success, FALSE otherwise.

2.4.1.8 bfd_get_gp_size ¶

Function: unsigned int bfd_get_gp_size (bfd *abfd); ¶

Return the maximum size of objects to be optimized using the GP register under MIPS ECOFF. This is typically set by the -G argument to the compiler, assembler or linker.

2.4.1.9 bfd_set_gp_size ¶

Function: void bfd_set_gp_size (bfd *abfd, unsigned int i); ¶

Set the maximum size of objects to be optimized using the GP register under ECOFF or MIPS ELF. This is typically set by the -G argument to the compiler, assembler or linker.

2.4.1.10 bfd_set_gp_value ¶

Function: void bfd_set_gp_value (bfd *abfd, bfd_vma v); ¶

Allow external access to the fucntion to set the GP value. This is specifically added for gdb-compile support.

2.4.1.11 bfd_scan_vma ¶

Function: bfd_vma bfd_scan_vma (const char *string, const char **end, int base); ¶

Convert, like strtoul or stdtoulldepending on the size of a bfd_vma, a numerical expression string into a bfd_vma integer, and return that integer.

2.4.1.12 bfd_copy_private_header_data ¶

Function: bool bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); ¶

Copy private BFD header information from the BFD ibfd to the the BFD obfd. This copies information that may require sections to exist, but does not require symbol tables. Return true on success, false on error. Possible error returns are:

• bfd_error_no_memory - Not enough memory exists to create private data for obfd.

#define bfd_copy_private_header_data(ibfd, obfd) \
       BFD_SEND (obfd, _bfd_copy_private_header_data, \
                 (ibfd, obfd))

2.4.1.13 bfd_copy_private_bfd_data ¶

Function: bool bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); ¶

Copy private BFD information from the BFD ibfd to the the BFD obfd. Return TRUE on success, FALSE on error. Possible error returns are:

• bfd_error_no_memory - Not enough memory exists to create private data for obfd.

#define bfd_copy_private_bfd_data(ibfd, obfd) \
       BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
                 (ibfd, obfd))

2.4.1.14 bfd_set_private_flags ¶

Function: bool bfd_set_private_flags (bfd *abfd, flagword flags); ¶

Set private BFD flag information in the BFD abfd. Return TRUE on success, FALSE on error. Possible error returns are:

• bfd_error_no_memory - Not enough memory exists to create private data for obfd.

#define bfd_set_private_flags(abfd, flags) \
       BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))

2.4.1.15 Other functions ¶

The following functions exist but have not yet been documented.

#define bfd_sizeof_headers(abfd, info) \
       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))

#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
       BFD_SEND (abfd, _bfd_find_nearest_line, \
                 (abfd, syms, sec, off, file, func, line, NULL))

#define bfd_find_nearest_line_with_alt(abfd, alt_filename, sec, syms, off, \
                                       file, func, line, disc) \
       BFD_SEND (abfd, _bfd_find_nearest_line_with_alt, \
                 (abfd, alt_filename, syms, sec, off, file, func, line, disc))

#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
                                           line, disc) \
       BFD_SEND (abfd, _bfd_find_nearest_line, \
                 (abfd, syms, sec, off, file, func, line, disc))

#define bfd_find_line(abfd, syms, sym, file, line) \
       BFD_SEND (abfd, _bfd_find_line, \
                 (abfd, syms, sym, file, line))

#define bfd_find_inliner_info(abfd, file, func, line) \
       BFD_SEND (abfd, _bfd_find_inliner_info, \
                 (abfd, file, func, line))

#define bfd_debug_info_start(abfd) \
       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))

#define bfd_debug_info_end(abfd) \
       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))

#define bfd_debug_info_accumulate(abfd, section) \
       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))

#define bfd_stat_arch_elt(abfd, stat) \
       BFD_SEND (abfd->my_archive ? abfd->my_archive : abfd, \
                 _bfd_stat_arch_elt, (abfd, stat))

#define bfd_update_armap_timestamp(abfd) \
       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))

#define bfd_set_arch_mach(abfd, arch, mach)\
       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))

#define bfd_relax_section(abfd, section, link_info, again) \
       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))

#define bfd_gc_sections(abfd, link_info) \
       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))

#define bfd_lookup_section_flags(link_info, flag_info, section) \
       BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section))

#define bfd_merge_sections(abfd, link_info) \
       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))

#define bfd_is_group_section(abfd, sec) \
       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))

#define bfd_group_name(abfd, sec) \
       BFD_SEND (abfd, _bfd_group_name, (abfd, sec))

#define bfd_discard_group(abfd, sec) \
       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))

#define bfd_link_hash_table_create(abfd) \
       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))

#define bfd_link_add_symbols(abfd, info) \
       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))

#define bfd_link_just_syms(abfd, sec, info) \
       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))

#define bfd_final_link(abfd, info) \
       BFD_SEND (abfd, _bfd_final_link, (abfd, info))

#define bfd_free_cached_info(abfd) \
       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))

#define bfd_get_dynamic_symtab_upper_bound(abfd) \
       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))

#define bfd_print_private_bfd_data(abfd, file)\
       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))

#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))

#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
                                                   dyncount, dynsyms, ret))

#define bfd_get_dynamic_reloc_upper_bound(abfd) \
       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))

#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))

2.4.1.16 bfd_get_relocated_section_contents ¶

Function: bfd_byte *bfd_get_relocated_section_contents (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, bool, asymbol **); ¶

Read and relocate the indirect link_order section, into DATA (if non-NULL) or to a malloc’d buffer. Return the buffer, or NULL on errors.

2.4.1.17 bfd_record_phdr ¶

Function: bool bfd_record_phdr (bfd *, unsigned long, bool, flagword, bool, bfd_vma, bool, bool, unsigned int, struct bfd_section **); ¶

Record information about an ELF program header.

2.4.1.18 bfd_sprintf_vma ¶

Function: void bfd_sprintf_vma (bfd *, char *, bfd_vma); void bfd_fprintf_vma (bfd *, void *, bfd_vma); ¶

bfd_sprintf_vma and bfd_fprintf_vma display an address in the target’s address size.

2.4.1.19 bfd_alt_mach_code ¶

Function: bool bfd_alt_mach_code (bfd *abfd, int alternative); ¶

When more than one machine code number is available for the same machine type, this function can be used to switch between the preferred one (alternative == 0) and any others. Currently, only ELF supports this feature, with up to two alternate machine codes.

2.4.1.20 bfd_emul_get_maxpagesize ¶

Function: bfd_vma bfd_emul_get_maxpagesize (const char *); ¶

Returns the maximum page size, in bytes, as determined by emulation.

2.4.1.21 bfd_emul_get_commonpagesize ¶

Function: bfd_vma bfd_emul_get_commonpagesize (const char *); ¶

Returns the common page size, in bytes, as determined by emulation.

2.4.1.22 bfd_demangle ¶

Function: char *bfd_demangle (bfd *, const char *, int); ¶

Wrapper around cplus_demangle. Strips leading underscores and other such chars that would otherwise confuse the demangler. If passed a g++ v3 ABI mangled name, returns a buffer allocated with malloc holding the demangled name. Returns NULL otherwise and on memory alloc failure.

2.4.1.23 struct bfd_iovec ¶

The struct bfd_iovec contains the internal file I/O class. Each BFD has an instance of this class and all file I/O is routed through it (it is assumed that the instance implements all methods listed below).

struct bfd_iovec
{
  /* To avoid problems with macros, a "b" rather than "f"
     prefix is prepended to each method name.  */
  /* Attempt to read/write NBYTES on ABFD's IOSTREAM storing/fetching
     bytes starting at PTR.  Return the number of bytes actually
     transfered (a read past end-of-file returns less than NBYTES),
     or -1 (setting bfd_error) if an error occurs.  */
  file_ptr (*bread) (struct bfd *abfd, void *ptr, file_ptr nbytes);
  file_ptr (*bwrite) (struct bfd *abfd, const void *ptr,
                      file_ptr nbytes);
  /* Return the current IOSTREAM file offset, or -1 (setting bfd_error
     if an error occurs.  */
  file_ptr (*btell) (struct bfd *abfd);
  /* For the following, on successful completion a value of 0 is returned.
     Otherwise, a value of -1 is returned (and bfd_error is set).  */
  int (*bseek) (struct bfd *abfd, file_ptr offset, int whence);
  int (*bclose) (struct bfd *abfd);
  int (*bflush) (struct bfd *abfd);
  int (*bstat) (struct bfd *abfd, struct stat *sb);
  /* Mmap a part of the files. ADDR, LEN, PROT, FLAGS and OFFSET are the usual
     mmap parameter, except that LEN and OFFSET do not need to be page
     aligned.  Returns (void *)-1 on failure, mmapped address on success.
     Also write in MAP_ADDR the address of the page aligned buffer and in
     MAP_LEN the size mapped (a page multiple).  Use unmap with MAP_ADDR and
     MAP_LEN to unmap.  */
  void *(*bmmap) (struct bfd *abfd, void *addr, size_t len,
                  int prot, int flags, file_ptr offset,
                  void **map_addr, size_t *map_len);
};
extern const struct bfd_iovec _bfd_memory_iovec;

2.4.1.24 bfd_read ¶

Function: bfd_size_type bfd_read (void *, bfd_size_type, bfd *) ATTRIBUTE_WARN_UNUSED_RESULT; ¶

Attempt to read SIZE bytes from ABFD’s iostream to PTR. Return the amount read.

2.4.1.25 bfd_write ¶

Function: bfd_size_type bfd_write (const void *, bfd_size_type, bfd *) ATTRIBUTE_WARN_UNUSED_RESULT; ¶

Attempt to write SIZE bytes to ABFD’s iostream from PTR. Return the amount written.

2.4.1.26 bfd_tell ¶

Function: file_ptr bfd_tell (bfd *) ATTRIBUTE_WARN_UNUSED_RESULT; ¶

Return ABFD’s iostream file position.

2.4.1.27 bfd_flush ¶

Function: int bfd_flush (bfd *); ¶

Flush ABFD’s iostream pending IO.

2.4.1.28 bfd_stat ¶

Function: int bfd_stat (bfd *, struct stat *) ATTRIBUTE_WARN_UNUSED_RESULT; ¶

Call fstat on ABFD’s iostream. Return 0 on success, and a negative value on failure.

2.4.1.29 bfd_seek ¶

Function: int bfd_seek (bfd *, file_ptr, int) ATTRIBUTE_WARN_UNUSED_RESULT; ¶

Call fseek on ABFD’s iostream. Return 0 on success, and a negative value on failure.

2.4.1.30 bfd_get_mtime ¶

Function: long bfd_get_mtime (bfd *abfd); ¶

Return the file modification time (as read from the file system, or from the archive header for archive members).

2.4.1.31 bfd_get_size ¶

Function: ufile_ptr bfd_get_size (bfd *abfd); ¶

Return the file size (as read from file system) for the file associated with BFD abfd.

The initial motivation for, and use of, this routine is not so we can get the exact size of the object the BFD applies to, since that might not be generally possible (archive members for example). It would be ideal if someone could eventually modify it so that such results were guaranteed.

Instead, we want to ask questions like "is this NNN byte sized object I’m about to try read from file offset YYY reasonable?" As as example of where we might do this, some object formats use string tables for which the first sizeof (long) bytes of the table contain the size of the table itself, including the size bytes. If an application tries to read what it thinks is one of these string tables, without some way to validate the size, and for some reason the size is wrong (byte swapping error, wrong location for the string table, etc.), the only clue is likely to be a read error when it tries to read the table, or a "virtual memory exhausted" error when it tries to allocate 15 bazillon bytes of space for the 15 bazillon byte table it is about to read. This function at least allows us to answer the question, "is the size reasonable?".

A return value of zero indicates the file size is unknown.

2.4.1.32 bfd_get_file_size ¶

Function: ufile_ptr bfd_get_file_size (bfd *abfd); ¶

Return the file size (as read from file system) for the file associated with BFD abfd. It supports both normal files and archive elements.

2.4.1.33 bfd_mmap ¶

Function: void *bfd_mmap (bfd *abfd, void *addr, size_t len, int prot, int flags, file_ptr offset, void **map_addr, size_t *map_len) ATTRIBUTE_WARN_UNUSED_RESULT; ¶

Return mmap()ed region of the file, if possible and implemented. LEN and OFFSET do not need to be page aligned. The page aligned address and length are written to MAP_ADDR and MAP_LEN.

2.4.1.34 bfd_get_current_time ¶

Function: time_t bfd_get_current_time (time_t now); ¶

Returns the current time.

If the environment variable SOURCE_DATE_EPOCH is defined then this is parsed and its value is returned. Otherwise if the paramter NOW is non-zero, then that is returned. Otherwise the result of the system call "time(NULL)" is returned.

2.6.5.1 bfd_section_list_clear ¶

Function: void bfd_section_list_clear (bfd *); ¶

Clears the section list, and also resets the section count and hash table entries.

2.6.5.2 bfd_get_section_by_name ¶

Function: asection *bfd_get_section_by_name (bfd *abfd, const char *name); ¶

Return the most recently created section attached to abfd named name. Return NULL if no such section exists.

2.6.5.3 bfd_get_next_section_by_name ¶

Function: asection *bfd_get_next_section_by_name (bfd *ibfd, asection *sec); ¶

Given sec is a section returned by bfd_get_section_by_name, return the next most recently created section attached to the same BFD with the same name, or if no such section exists in the same BFD and IBFD is non-NULL, the next section with the same name in any input BFD following IBFD. Return NULL on finding no section.

2.6.5.4 bfd_get_linker_section ¶

Function: asection *bfd_get_linker_section (bfd *abfd, const char *name); ¶

Return the linker created section attached to abfd named name. Return NULL if no such section exists.

2.6.5.5 bfd_get_section_by_name_if ¶

Function: asection *bfd_get_section_by_name_if (bfd *abfd, const char *name, bool (*func) (bfd *abfd, asection *sect, void *obj), void *obj); ¶

Call the provided function func for each section attached to the BFD abfd whose name matches name, passing obj as an argument. The function will be called as if by

       func (abfd, the_section, obj);

It returns the first section for which func returns true, otherwise NULL.

2.6.5.6 bfd_get_unique_section_name ¶

Function: char *bfd_get_unique_section_name (bfd *abfd, const char *templat, int *count); ¶

Invent a section name that is unique in abfd by tacking a dot and a digit suffix onto the original templat. If count is non-NULL, then it specifies the first number tried as a suffix to generate a unique name. The value pointed to by count will be incremented in this case.

2.6.5.7 bfd_make_section_old_way ¶

Function: asection *bfd_make_section_old_way (bfd *abfd, const char *name); ¶

Create a new empty section called name and attach it to the end of the chain of sections for the BFD abfd. An attempt to create a section with a name which is already in use returns its pointer without changing the section chain.

It has the funny name since this is the way it used to be before it was rewritten....

Possible errors are:

• bfd_error_invalid_operation - If output has already started for this BFD.
• bfd_error_no_memory - If memory allocation fails.

2.6.5.8 bfd_make_section_anyway_with_flags ¶

Function: asection *bfd_make_section_anyway_with_flags (bfd *abfd, const char *name, flagword flags); ¶

Create a new empty section called name and attach it to the end of the chain of sections for abfd. Create a new section even if there is already a section with that name. Also set the attributes of the new section to the value flags.

Return NULL and set bfd_error on error; possible errors are:

• bfd_error_invalid_operation - If output has already started for abfd.
• bfd_error_no_memory - If memory allocation fails.

2.6.5.9 bfd_make_section_anyway ¶

Function: asection *bfd_make_section_anyway (bfd *abfd, const char *name); ¶

Create a new empty section called name and attach it to the end of the chain of sections for abfd. Create a new section even if there is already a section with that name.

Return NULL and set bfd_error on error; possible errors are:

• bfd_error_invalid_operation - If output has already started for abfd.
• bfd_error_no_memory - If memory allocation fails.

2.6.5.10 bfd_make_section_with_flags ¶

Function: asection *bfd_make_section_with_flags (bfd *, const char *name, flagword flags); ¶

Like bfd_make_section_anyway, but return NULL (without calling bfd_set_error ()) without changing the section chain if there is already a section named name. Also set the attributes of the new section to the value flags. If there is an error, return NULL and set bfd_error.

2.6.5.11 bfd_make_section ¶

Function: asection *bfd_make_section (bfd *, const char *name); ¶

Like bfd_make_section_anyway, but return NULL (without calling bfd_set_error ()) without changing the section chain if there is already a section named name. If there is an error, return NULL and set bfd_error.

2.6.5.12 bfd_set_section_flags ¶

Function: bool bfd_set_section_flags (asection *sec, flagword flags); ¶

Set the attributes of the section sec to the value flags. Return TRUE on success, FALSE on error. Possible error returns are:

• bfd_error_invalid_operation - The section cannot have one or more of the attributes requested. For example, a .bss section in a.out may not have the SEC_HAS_CONTENTS field set.

2.6.5.13 bfd_rename_section ¶

Function: void bfd_rename_section (asection *sec, const char *newname); ¶

Rename section sec to newname.

2.6.5.14 bfd_map_over_sections ¶

Function: void bfd_map_over_sections (bfd *abfd, void (*func) (bfd *abfd, asection *sect, void *obj), void *obj); ¶

Call the provided function func for each section attached to the BFD abfd, passing obj as an argument. The function will be called as if by

       func (abfd, the_section, obj);

This is the preferred method for iterating over sections; an alternative would be to use a loop:

          asection *p;
          for (p = abfd->sections; p != NULL; p = p->next)
             func (abfd, p, ...)

2.6.5.15 bfd_sections_find_if ¶

Function: asection *bfd_sections_find_if (bfd *abfd, bool (*operation) (bfd *abfd, asection *sect, void *obj), void *obj); ¶

Call the provided function operation for each section attached to the BFD abfd, passing obj as an argument. The function will be called as if by

       operation (abfd, the_section, obj);

It returns the first section for which operation returns true.

2.6.5.16 bfd_set_section_size ¶

Function: bool bfd_set_section_size (asection *sec, bfd_size_type val); ¶

Set sec to the size val. If the operation is ok, then TRUE is returned, else FALSE.

Possible error returns:

• bfd_error_invalid_operation - Writing has started to the BFD, so setting the size is invalid.

2.6.5.17 bfd_set_section_contents ¶

Function: bool bfd_set_section_contents (bfd *abfd, asection *section, const void *data, file_ptr offset, bfd_size_type count); ¶

Sets the contents of the section section in BFD abfd to the data starting in memory at location. The data is written to the output section starting at offset offset for count octets.

Normally TRUE is returned, but FALSE is returned if there was an error. Possible error returns are:

• bfd_error_no_contents - The output section does not have the SEC_HAS_CONTENTS attribute, so nothing can be written to it.
• bfd_error_bad_value - The section is unable to contain all of the data.
• bfd_error_invalid_operation - The BFD is not writeable.
• and some more too.

This routine is front end to the back end function _bfd_set_section_contents.

2.6.5.18 bfd_get_section_contents ¶

Function: bool bfd_get_section_contents (bfd *abfd, asection *section, void *location, file_ptr offset, bfd_size_type count); ¶

Read data from section in BFD abfd into memory starting at location. The data is read at an offset of offset from the start of the input section, and is read for count bytes.

If the contents of a constructor with the SEC_CONSTRUCTOR flag set are requested or if the section does not have the SEC_HAS_CONTENTS flag set, then the location is filled with zeroes. If no errors occur, TRUE is returned, else FALSE.

2.6.5.19 bfd_malloc_and_get_section ¶

Function: bool bfd_malloc_and_get_section (bfd *abfd, asection *section, bfd_byte **buf); ¶

Read all data from section in BFD abfd into a buffer, *buf, malloc’d by this function. Return true on success, false on failure in which case *buf will be NULL.

2.6.5.20 bfd_copy_private_section_data ¶

Function: bool bfd_copy_private_section_data (bfd *ibfd, asection *isec, bfd *obfd, asection *osec); ¶

Copy private section information from isec in the BFD ibfd to the section osec in the BFD obfd. Return TRUE on success, FALSE on error. Possible error returns are:

• bfd_error_no_memory - Not enough memory exists to create private data for osec.

#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
       BFD_SEND (obfd, _bfd_copy_private_section_data, \
                 (ibfd, isection, obfd, osection))

2.6.5.21 bfd_generic_is_group_section ¶

Function: bool bfd_generic_is_group_section (bfd *, const asection *sec); ¶

Returns TRUE if sec is a member of a group.

2.6.5.22 bfd_generic_group_name ¶

Function: const char *bfd_generic_group_name (bfd *, const asection *sec); ¶

Returns group name if sec is a member of a group.

2.6.5.23 bfd_generic_discard_group ¶

Function: bool bfd_generic_discard_group (bfd *abfd, asection *group); ¶

Remove all members of group from the output.

2.6.5.24 bfd_section_size_insane ¶

Function: bool bfd_section_size_insane (bfd *abfd, asection *sec); ¶

Returns true if the given section has a size that indicates it cannot be read from file. Return false if the size is OK or* this function can’t say one way or the other.

2.7.5.1 bfd_get_symtab_upper_bound ¶

Return the number of bytes required to store a vector of pointers to asymbols for all the symbols in the BFD abfd, including a terminal NULL pointer. If there are no symbols in the BFD, then return 0. If an error occurs, return -1.

#define bfd_get_symtab_upper_bound(abfd) \
       BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))

2.7.5.2 bfd_is_local_label ¶

Function: bool bfd_is_local_label (bfd *abfd, asymbol *sym); ¶

Return TRUE if the given symbol sym in the BFD abfd is a compiler generated local label, else return FALSE.

2.7.5.3 bfd_is_local_label_name ¶

Function: bool bfd_is_local_label_name (bfd *abfd, const char *name); ¶

Return TRUE if a symbol with the name name in the BFD abfd is a compiler generated local label, else return FALSE. This just checks whether the name has the form of a local label.

#define bfd_is_local_label_name(abfd, name) \
       BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))

2.7.5.4 bfd_is_target_special_symbol ¶

Function: bool bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); ¶

Return TRUE iff a symbol sym in the BFD abfd is something special to the particular target represented by the BFD. Such symbols should normally not be mentioned to the user.

#define bfd_is_target_special_symbol(abfd, sym) \
       BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))

2.7.5.5 bfd_canonicalize_symtab ¶

Read the symbols from the BFD abfd, and fills in the vector location with pointers to the symbols and a trailing NULL. Return the actual number of symbol pointers, not including the NULL.

#define bfd_canonicalize_symtab(abfd, location) \
       BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))

2.7.5.6 bfd_set_symtab ¶

Function: bool bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count); ¶

Arrange that when the output BFD abfd is closed, the table location of count pointers to symbols will be written.

2.7.5.7 bfd_print_symbol_vandf ¶

Function: void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); ¶

Print the value and flags of the symbol supplied to the stream file.

2.7.5.8 bfd_make_empty_symbol ¶

Create a new asymbol structure for the BFD abfd and return a pointer to it.

This routine is necessary because each back end has private information surrounding the asymbol. Building your own asymbol and pointing to it will not create the private information, and will cause problems later on.

#define bfd_make_empty_symbol(abfd) \
       BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))

2.7.5.9 _bfd_generic_make_empty_symbol ¶

Function: asymbol *_bfd_generic_make_empty_symbol (bfd *); ¶

Create a new asymbol structure for the BFD abfd and return a pointer to it. Used by core file routines, binary back-end and anywhere else where no private info is needed.

2.7.5.10 bfd_make_debug_symbol ¶

Create a new asymbol structure for the BFD abfd, to be used as a debugging symbol.

#define bfd_make_debug_symbol(abfd) \
       BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd))

2.7.5.11 bfd_decode_symclass ¶

Function: int bfd_decode_symclass (asymbol *symbol); ¶

Return a character corresponding to the symbol class of symbol, or ’?’ for an unknown class.

2.7.5.12 bfd_is_undefined_symclass ¶

Function: bool bfd_is_undefined_symclass (int symclass); ¶

Returns non-zero if the class symbol returned by bfd_decode_symclass represents an undefined symbol. Returns zero otherwise.

2.7.5.13 bfd_symbol_info ¶

Function: void bfd_symbol_info (asymbol *symbol, symbol_info *ret); ¶

Fill in the basic info about symbol that nm needs. Additional info may be added by the back-ends after calling this function.

2.7.5.14 bfd_copy_private_symbol_data ¶

Function: bool bfd_copy_private_symbol_data (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); ¶

Copy private symbol information from isym in the BFD ibfd to the symbol osym in the BFD obfd. Return TRUE on success, FALSE on error. Possible error returns are:

• bfd_error_no_memory - Not enough memory exists to create private data for osec.

#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
       BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
                 (ibfd, isymbol, obfd, osymbol))

2.8.1.1 bfd_get_next_mapent ¶

Function: symindex bfd_get_next_mapent (bfd *abfd, symindex previous, carsym **sym); ¶

Step through archive abfd’s symbol table (if it has one). Successively update sym with the next symbol’s information, returning that symbol’s (internal) index into the symbol table.

Supply BFD_NO_MORE_SYMBOLS as the previous entry to get the first one; returns BFD_NO_MORE_SYMBOLS when you’ve already got the last one.

A carsym is a canonical archive symbol. The only user-visible element is its name, a null-terminated string.

2.8.1.2 bfd_set_archive_head ¶

Function: bool bfd_set_archive_head (bfd *output, bfd *new_head); ¶

Set the head of the chain of BFDs contained in the archive output to new_head.

2.8.1.3 bfd_openr_next_archived_file ¶

Function: bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous); ¶

Provided a BFD, archive, containing an archive and NULL, open an input BFD on the first contained element and returns that. Subsequent calls should pass the archive and the previous return value to return a created BFD to the next contained element. NULL is returned when there are no more. Note - if you want to process the bfd returned by this call be sure to call bfd_check_format() on it first.

2.9.1.1 bfd_check_format ¶

Function: bool bfd_check_format (bfd *abfd, bfd_format format); ¶

Verify if the file attached to the BFD abfd is compatible with the format format (i.e., one of bfd_object, bfd_archive or bfd_core).

If the BFD has been set to a specific target before the call, only the named target and format combination is checked. If the target has not been set, or has been set to default, then all the known target backends is interrogated to determine a match. If the default target matches, it is used. If not, exactly one target must recognize the file, or an error results.

The function returns TRUE on success, otherwise FALSE with one of the following error codes:

• bfd_error_invalid_operation - if format is not one of bfd_object, bfd_archive or bfd_core.
• bfd_error_system_call - if an error occured during a read - even some file mismatches can cause bfd_error_system_calls.
• file_not_recognised - none of the backends recognised the file format.
• bfd_error_file_ambiguously_recognized - more than one backend recognised the file format.

When calling bfd_check_format (or bfd_check_format_matches), any underlying file descriptor will be kept open for the duration of the call. This is done to avoid races when another thread calls bfd_cache_close_all. In this scenario, the thread calling bfd_check_format must call bfd_cache_close itself.

2.9.1.2 bfd_check_format_matches ¶

Function: bool bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching); ¶

Like bfd_check_format, except when it returns FALSE with bfd_errno set to bfd_error_file_ambiguously_recognized. In that case, if matching is not NULL, it will be filled in with a NULL-terminated list of the names of the formats that matched, allocated with malloc. Then the user may choose a format and try again.

When done with the list that matching points to, the caller should free it.

2.9.1.3 bfd_set_format ¶

Function: bool bfd_set_format (bfd *abfd, bfd_format format); ¶

This function sets the file format of the BFD abfd to the format format. If the target set in the BFD does not support the format requested, the format is invalid, or the BFD is not open for writing, then an error occurs.

2.9.1.4 bfd_format_string ¶

Function: const char *bfd_format_string (bfd_format format); ¶

Return a pointer to a const string invalid, object, archive, core, or unknown, depending upon the value of format.

2.10.1.1 enum complain_overflow ¶

Indicates what sort of overflow checking should be done when performing a relocation.

enum complain_overflow
{
  /* Do not complain on overflow.  */
  complain_overflow_dont,

  /* Complain if the value overflows when considered as a signed
     number one bit larger than the field.  ie. A bitfield of N bits
     is allowed to represent -2**n to 2**n-1.  */
  complain_overflow_bitfield,

  /* Complain if the value overflows when considered as a signed
     number.  */
  complain_overflow_signed,

  /* Complain if the value overflows when considered as an
     unsigned number.  */
  complain_overflow_unsigned
};

2.10.1.2 reloc_howto_type ¶

The reloc_howto_type is a structure which contains all the information that libbfd needs to know to tie up a back end’s data.

struct reloc_howto_struct
{
  /* The type field has mainly a documentary use - the back end can
     do what it wants with it, though normally the back end's idea of
     an external reloc number is stored in this field.  */
  unsigned int type;

  /* The size of the item to be relocated in bytes.  */
  unsigned int size:4;

  /* The number of bits in the field to be relocated.  This is used
     when doing overflow checking.  */
  unsigned int bitsize:7;

  /* The value the final relocation is shifted right by.  This drops
     unwanted data from the relocation.  */
  unsigned int rightshift:6;

  /* The bit position of the reloc value in the destination.
     The relocated value is left shifted by this amount.  */
  unsigned int bitpos:6;

  /* What type of overflow error should be checked for when
     relocating.  */
  ENUM_BITFIELD (complain_overflow) complain_on_overflow:2;

  /* The relocation value should be negated before applying.  */
  unsigned int negate:1;

  /* The relocation is relative to the item being relocated.  */
  unsigned int pc_relative:1;

  /* Some formats record a relocation addend in the section contents
     rather than with the relocation.  For ELF formats this is the
     distinction between USE_REL and USE_RELA (though the code checks
     for USE_REL == 1/0).  The value of this field is TRUE if the
     addend is recorded with the section contents; when performing a
     partial link (ld -r) the section contents (the data) will be
     modified.  The value of this field is FALSE if addends are
     recorded with the relocation (in arelent.addend); when performing
     a partial link the relocation will be modified.
     All relocations for all ELF USE_RELA targets should set this field
     to FALSE (values of TRUE should be looked on with suspicion).
     However, the converse is not true: not all relocations of all ELF
     USE_REL targets set this field to TRUE.  Why this is so is peculiar
     to each particular target.  For relocs that aren't used in partial
     links (e.g. GOT stuff) it doesn't matter what this is set to.  */
  unsigned int partial_inplace:1;

  /* When some formats create PC relative instructions, they leave
     the value of the pc of the place being relocated in the offset
     slot of the instruction, so that a PC relative relocation can
     be made just by adding in an ordinary offset (e.g., sun3 a.out).
     Some formats leave the displacement part of an instruction
     empty (e.g., ELF); this flag signals the fact.  */
  unsigned int pcrel_offset:1;

  /* Whether bfd_install_relocation should just install the addend,
     or should follow the practice of some older object formats and
     install a value including the symbol.  */
  unsigned int install_addend:1;

  /* src_mask selects the part of the instruction (or data) to be used
     in the relocation sum.  If the target relocations don't have an
     addend in the reloc, eg. ELF USE_REL, src_mask will normally equal
     dst_mask to extract the addend from the section contents.  If
     relocations do have an addend in the reloc, eg. ELF USE_RELA, this
     field should normally be zero.  Non-zero values for ELF USE_RELA
     targets should be viewed with suspicion as normally the value in
     the dst_mask part of the section contents should be ignored.  */
  bfd_vma src_mask;

  /* dst_mask selects which parts of the instruction (or data) are
     replaced with a relocated value.  */
  bfd_vma dst_mask;

  /* If this field is non null, then the supplied function is
     called rather than the normal function.  This allows really
     strange relocation methods to be accommodated.  */
  bfd_reloc_status_type (*special_function)
    (bfd *, arelent *, struct bfd_symbol *, void *, asection *,
     bfd *, char **);

  /* The textual name of the relocation type.  */
  const char *name;
};

2.10.1.3 The HOWTO Macro ¶

The HOWTO macro fills in a reloc_howto_type (a typedef for const struct reloc_howto_struct).

#define HOWTO_INSTALL_ADDEND 0
#define HOWTO_RSIZE(sz) ((sz) < 0 ? -(sz) : (sz))
#define HOWTO(type, right, size, bits, pcrel, left, ovf, func, name,   \
              inplace, src_mask, dst_mask, pcrel_off)                  \
  { (unsigned) type, HOWTO_RSIZE (size), bits, right, left, ovf,       \
    size < 0, pcrel, inplace, pcrel_off, HOWTO_INSTALL_ADDEND,         \
    src_mask, dst_mask, func, name }

This is used to fill in an empty howto entry in an array.

#define EMPTY_HOWTO(C) \
  HOWTO ((C), 0, 1, 0, false, 0, complain_overflow_dont, NULL, \
         NULL, false, 0, 0, false)

static inline unsigned int
bfd_get_reloc_size (reloc_howto_type *howto)
{
  return howto->size;
}

2.10.1.4 arelent_chain ¶

How relocs are tied together in an asection:

typedef struct relent_chain
{
  arelent relent;
  struct relent_chain *next;
}
arelent_chain;

2.10.1.5 bfd_check_overflow ¶

Function: bfd_reloc_status_type bfd_check_overflow (enum complain_overflow how, unsigned int bitsize, unsigned int rightshift, unsigned int addrsize, bfd_vma relocation); ¶

Perform overflow checking on relocation which has bitsize significant bits and will be shifted right by rightshift bits, on a machine with addresses containing addrsize significant bits. The result is either of bfd_reloc_ok or bfd_reloc_overflow.

2.10.1.6 bfd_reloc_offset_in_range ¶

Function: bool bfd_reloc_offset_in_range (reloc_howto_type *howto, bfd *abfd, asection *section, bfd_size_type offset); ¶

Returns TRUE if the reloc described by HOWTO can be applied at OFFSET octets in SECTION.

2.10.1.7 bfd_perform_relocation ¶

Function: bfd_reloc_status_type bfd_perform_relocation (bfd *abfd, arelent *reloc_entry, void *data, asection *input_section, bfd *output_bfd, char **error_message); ¶

If output_bfd is supplied to this function, the generated image will be relocatable; the relocations are copied to the output file after they have been changed to reflect the new state of the world. There are two ways of reflecting the results of partial linkage in an output file: by modifying the output data in place, and by modifying the relocation record. Some native formats (e.g., basic a.out and basic coff) have no way of specifying an addend in the relocation type, so the addend has to go in the output data. This is no big deal since in these formats the output data slot will always be big enough for the addend. Complex reloc types with addends were invented to solve just this problem. The error_message argument is set to an error message if this return bfd_reloc_dangerous.

2.10.1.8 bfd_install_relocation ¶

Function: bfd_reloc_status_type bfd_install_relocation (bfd *abfd, arelent *reloc_entry, void *data, bfd_vma data_start, asection *input_section, char **error_message); ¶

This looks remarkably like bfd_perform_relocation, except it does not expect that the section contents have been filled in. I.e., it’s suitable for use when creating, rather than applying a relocation.

For now, this function should be considered reserved for the assembler.

2.10.2.1 bfd_reloc_code_real_type ¶

The insides of a reloc code. The idea is that, eventually, there will be one enumerator for every type of relocation we ever do. Pass one of these values to bfd_reloc_type_lookup, and it’ll return a howto pointer.

This does mean that the application must determine the correct enumerator value; you can’t get a howto pointer from a random set of attributes.

Here are the possible values for enum bfd_reloc_code_real:

: BFD_RELOC_64 ¶

: BFD_RELOC_32 ¶

: BFD_RELOC_26 ¶

: BFD_RELOC_24 ¶

: BFD_RELOC_16 ¶

: BFD_RELOC_14 ¶

: BFD_RELOC_8 ¶

Basic absolute relocations of N bits.

: BFD_RELOC_64_PCREL ¶

: BFD_RELOC_32_PCREL ¶

: BFD_RELOC_24_PCREL ¶

: BFD_RELOC_16_PCREL ¶

: BFD_RELOC_12_PCREL ¶

: BFD_RELOC_8_PCREL ¶

PC-relative relocations. Sometimes these are relative to the address of the relocation itself; sometimes they are relative to the start of the section containing the relocation. It depends on the specific target.

: BFD_RELOC_32_SECREL ¶

: BFD_RELOC_16_SECIDX ¶

Section relative relocations. Some targets need this for DWARF2.

: BFD_RELOC_32_GOT_PCREL ¶

: BFD_RELOC_16_GOT_PCREL ¶

: BFD_RELOC_8_GOT_PCREL ¶

: BFD_RELOC_32_GOTOFF ¶

: BFD_RELOC_16_GOTOFF ¶

: BFD_RELOC_LO16_GOTOFF ¶

: BFD_RELOC_HI16_GOTOFF ¶

: BFD_RELOC_HI16_S_GOTOFF ¶

: BFD_RELOC_8_GOTOFF ¶

: BFD_RELOC_64_PLT_PCREL ¶

: BFD_RELOC_32_PLT_PCREL ¶

: BFD_RELOC_24_PLT_PCREL ¶

: BFD_RELOC_16_PLT_PCREL ¶

: BFD_RELOC_8_PLT_PCREL ¶

: BFD_RELOC_64_PLTOFF ¶

: BFD_RELOC_32_PLTOFF ¶

: BFD_RELOC_16_PLTOFF ¶

: BFD_RELOC_LO16_PLTOFF ¶

: BFD_RELOC_HI16_PLTOFF ¶

: BFD_RELOC_HI16_S_PLTOFF ¶

: BFD_RELOC_8_PLTOFF ¶

For ELF.

: BFD_RELOC_SIZE32 ¶

: BFD_RELOC_SIZE64 ¶

Size relocations.

: BFD_RELOC_68K_GLOB_DAT ¶

: BFD_RELOC_68K_JMP_SLOT ¶

: BFD_RELOC_68K_RELATIVE ¶

: BFD_RELOC_68K_TLS_GD32 ¶

: BFD_RELOC_68K_TLS_GD16 ¶

: BFD_RELOC_68K_TLS_GD8 ¶

: BFD_RELOC_68K_TLS_LDM32 ¶

: BFD_RELOC_68K_TLS_LDM16 ¶

: BFD_RELOC_68K_TLS_LDM8 ¶

: BFD_RELOC_68K_TLS_LDO32 ¶

: BFD_RELOC_68K_TLS_LDO16 ¶

: BFD_RELOC_68K_TLS_LDO8 ¶

: BFD_RELOC_68K_TLS_IE32 ¶

: BFD_RELOC_68K_TLS_IE16 ¶

: BFD_RELOC_68K_TLS_IE8 ¶

: BFD_RELOC_68K_TLS_LE32 ¶

: BFD_RELOC_68K_TLS_LE16 ¶

: BFD_RELOC_68K_TLS_LE8 ¶

Relocations used by 68K ELF.

: BFD_RELOC_32_BASEREL ¶

: BFD_RELOC_16_BASEREL ¶

: BFD_RELOC_LO16_BASEREL ¶

: BFD_RELOC_HI16_BASEREL ¶

: BFD_RELOC_HI16_S_BASEREL ¶

: BFD_RELOC_8_BASEREL ¶

: BFD_RELOC_RVA ¶

Linkage-table relative.

: BFD_RELOC_8_FFnn ¶

Absolute 8-bit relocation, but used to form an address like 0xFFnn.

: BFD_RELOC_32_PCREL_S2 ¶

: BFD_RELOC_16_PCREL_S2 ¶

: BFD_RELOC_23_PCREL_S2 ¶

These PC-relative relocations are stored as word displacements – i.e., byte displacements shifted right two bits. The 30-bit word displacement (<<32_PCREL_S2>> – 32 bits, shifted 2) is used on the SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The signed 16-bit displacement is used on the MIPS, and the 23-bit displacement is used on the Alpha.

: BFD_RELOC_HI22 ¶

: BFD_RELOC_LO10 ¶

High 22 bits and low 10 bits of 32-bit value, placed into lower bits of the target word. These are used on the SPARC.

: BFD_RELOC_GPREL16 ¶

: BFD_RELOC_GPREL32 ¶

For systems that allocate a Global Pointer register, these are displacements off that register. These relocation types are handled specially, because the value the register will have is decided relatively late.

: BFD_RELOC_NONE ¶

: BFD_RELOC_SPARC_WDISP22 ¶

: BFD_RELOC_SPARC22 ¶

: BFD_RELOC_SPARC13 ¶

: BFD_RELOC_SPARC_GOT10 ¶

: BFD_RELOC_SPARC_GOT13 ¶

: BFD_RELOC_SPARC_GOT22 ¶

: BFD_RELOC_SPARC_PC10 ¶

: BFD_RELOC_SPARC_PC22 ¶

: BFD_RELOC_SPARC_WPLT30 ¶

: BFD_RELOC_SPARC_COPY ¶

: BFD_RELOC_SPARC_GLOB_DAT ¶

: BFD_RELOC_SPARC_JMP_SLOT ¶

: BFD_RELOC_SPARC_RELATIVE ¶

: BFD_RELOC_SPARC_UA16 ¶

: BFD_RELOC_SPARC_UA32 ¶

: BFD_RELOC_SPARC_UA64 ¶

: BFD_RELOC_SPARC_GOTDATA_HIX22 ¶

: BFD_RELOC_SPARC_GOTDATA_LOX10 ¶

: BFD_RELOC_SPARC_GOTDATA_OP_HIX22 ¶

: BFD_RELOC_SPARC_GOTDATA_OP_LOX10 ¶

: BFD_RELOC_SPARC_GOTDATA_OP ¶

: BFD_RELOC_SPARC_JMP_IREL ¶

: BFD_RELOC_SPARC_IRELATIVE ¶

SPARC ELF relocations. There is probably some overlap with other relocation types already defined.

: BFD_RELOC_SPARC_BASE13 ¶

: BFD_RELOC_SPARC_BASE22 ¶

I think these are specific to SPARC a.out (e.g., Sun 4).

: BFD_RELOC_SPARC_64 ¶

: BFD_RELOC_SPARC_10 ¶

: BFD_RELOC_SPARC_11 ¶

: BFD_RELOC_SPARC_OLO10 ¶

: BFD_RELOC_SPARC_HH22 ¶

: BFD_RELOC_SPARC_HM10 ¶

: BFD_RELOC_SPARC_LM22 ¶

: BFD_RELOC_SPARC_PC_HH22 ¶

: BFD_RELOC_SPARC_PC_HM10 ¶

: BFD_RELOC_SPARC_PC_LM22 ¶

: BFD_RELOC_SPARC_WDISP16 ¶

: BFD_RELOC_SPARC_WDISP19 ¶

: BFD_RELOC_SPARC_7 ¶

: BFD_RELOC_SPARC_6 ¶

: BFD_RELOC_SPARC_5 ¶

: BFD_RELOC_SPARC_DISP64 ¶

: BFD_RELOC_SPARC_PLT32 ¶

: BFD_RELOC_SPARC_PLT64 ¶

: BFD_RELOC_SPARC_HIX22 ¶

: BFD_RELOC_SPARC_LOX10 ¶

: BFD_RELOC_SPARC_H44 ¶

: BFD_RELOC_SPARC_M44 ¶

: BFD_RELOC_SPARC_L44 ¶

: BFD_RELOC_SPARC_REGISTER ¶

: BFD_RELOC_SPARC_H34 ¶

: BFD_RELOC_SPARC_SIZE32 ¶

: BFD_RELOC_SPARC_SIZE64 ¶

: BFD_RELOC_SPARC_WDISP10 ¶

SPARC64 relocations.

: BFD_RELOC_SPARC_REV32 ¶

SPARC little endian relocation.

: BFD_RELOC_SPARC_TLS_GD_HI22 ¶

: BFD_RELOC_SPARC_TLS_GD_LO10 ¶

: BFD_RELOC_SPARC_TLS_GD_ADD ¶

: BFD_RELOC_SPARC_TLS_GD_CALL ¶

: BFD_RELOC_SPARC_TLS_LDM_HI22 ¶

: BFD_RELOC_SPARC_TLS_LDM_LO10 ¶

: BFD_RELOC_SPARC_TLS_LDM_ADD ¶

: BFD_RELOC_SPARC_TLS_LDM_CALL ¶

: BFD_RELOC_SPARC_TLS_LDO_HIX22 ¶

: BFD_RELOC_SPARC_TLS_LDO_LOX10 ¶

: BFD_RELOC_SPARC_TLS_LDO_ADD ¶

: BFD_RELOC_SPARC_TLS_IE_HI22 ¶

: BFD_RELOC_SPARC_TLS_IE_LO10 ¶

: BFD_RELOC_SPARC_TLS_IE_LD ¶

: BFD_RELOC_SPARC_TLS_IE_LDX ¶

: BFD_RELOC_SPARC_TLS_IE_ADD ¶

: BFD_RELOC_SPARC_TLS_LE_HIX22 ¶

: BFD_RELOC_SPARC_TLS_LE_LOX10 ¶

: BFD_RELOC_SPARC_TLS_DTPMOD32 ¶

: BFD_RELOC_SPARC_TLS_DTPMOD64 ¶

: BFD_RELOC_SPARC_TLS_DTPOFF32 ¶

: BFD_RELOC_SPARC_TLS_DTPOFF64 ¶

: BFD_RELOC_SPARC_TLS_TPOFF32 ¶

: BFD_RELOC_SPARC_TLS_TPOFF64 ¶

SPARC TLS relocations.

: BFD_RELOC_SPU_IMM7 ¶

: BFD_RELOC_SPU_IMM8 ¶

: BFD_RELOC_SPU_IMM10 ¶

: BFD_RELOC_SPU_IMM10W ¶

: BFD_RELOC_SPU_IMM16 ¶

: BFD_RELOC_SPU_IMM16W ¶

: BFD_RELOC_SPU_IMM18 ¶

: BFD_RELOC_SPU_PCREL9a ¶

: BFD_RELOC_SPU_PCREL9b ¶

: BFD_RELOC_SPU_PCREL16 ¶

: BFD_RELOC_SPU_LO16 ¶

: BFD_RELOC_SPU_HI16 ¶

: BFD_RELOC_SPU_PPU32 ¶

: BFD_RELOC_SPU_PPU64 ¶

: BFD_RELOC_SPU_ADD_PIC ¶

SPU Relocations.

: BFD_RELOC_ALPHA_GPDISP_HI16 ¶

Alpha ECOFF and ELF relocations. Some of these treat the symbol or "addend" in some special way. For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when writing; when reading, it will be the absolute section symbol. The addend is the displacement in bytes of the "lda" instruction from the "ldah" instruction (which is at the address of this reloc).

: BFD_RELOC_ALPHA_GPDISP_LO16 ¶

For GPDISP_LO16 ("ignore") relocations, the symbol is handled as with GPDISP_HI16 relocs. The addend is ignored when writing the relocations out, and is filled in with the file’s GP value on reading, for convenience.

: BFD_RELOC_ALPHA_GPDISP ¶

The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 relocation except that there is no accompanying GPDISP_LO16 relocation.

: BFD_RELOC_ALPHA_LITERAL ¶

: BFD_RELOC_ALPHA_ELF_LITERAL ¶

: BFD_RELOC_ALPHA_LITUSE ¶

The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; the assembler turns it into a LDQ instruction to load the address of the symbol, and then fills in a register in the real instruction.

The LITERAL reloc, at the LDQ instruction, refers to the .lita section symbol. The addend is ignored when writing, but is filled in with the file’s GP value on reading, for convenience, as with the GPDISP_LO16 reloc.

The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. It should refer to the symbol to be referenced, as with 16_GOTOFF, but it generates output not based on the position within the .got section, but relative to the GP value chosen for the file during the final link stage.

The LITUSE reloc, on the instruction using the loaded address, gives information to the linker that it might be able to use to optimize away some literal section references. The symbol is ignored (read as the absolute section symbol), and the "addend" indicates the type of instruction using the register: 1 - "memory" fmt insn 2 - byte-manipulation (byte offset reg) 3 - jsr (target of branch)

: BFD_RELOC_ALPHA_HINT ¶

The HINT relocation indicates a value that should be filled into the "hint" field of a jmp/jsr/ret instruction, for possible branch- prediction logic which may be provided on some processors.

: BFD_RELOC_ALPHA_LINKAGE ¶

The LINKAGE relocation outputs a linkage pair in the object file, which is filled by the linker.

: BFD_RELOC_ALPHA_CODEADDR ¶

The CODEADDR relocation outputs a STO_CA in the object file, which is filled by the linker.

: BFD_RELOC_ALPHA_GPREL_HI16 ¶

: BFD_RELOC_ALPHA_GPREL_LO16 ¶

The GPREL_HI/LO relocations together form a 32-bit offset from the GP register.

: BFD_RELOC_ALPHA_BRSGP ¶

Like BFD_RELOC_23_PCREL_S2, except that the source and target must share a common GP, and the target address is adjusted for STO_ALPHA_STD_GPLOAD.

: BFD_RELOC_ALPHA_NOP ¶

The NOP relocation outputs a NOP if the longword displacement between two procedure entry points is < 2^21.

: BFD_RELOC_ALPHA_BSR ¶

The BSR relocation outputs a BSR if the longword displacement between two procedure entry points is < 2^21.

: BFD_RELOC_ALPHA_LDA ¶

The LDA relocation outputs a LDA if the longword displacement between two procedure entry points is < 2^16.

: BFD_RELOC_ALPHA_BOH ¶

The BOH relocation outputs a BSR if the longword displacement between two procedure entry points is < 2^21, or else a hint.

: BFD_RELOC_ALPHA_TLSGD ¶

: BFD_RELOC_ALPHA_TLSLDM ¶

: BFD_RELOC_ALPHA_DTPMOD64 ¶

: BFD_RELOC_ALPHA_GOTDTPREL16 ¶

: BFD_RELOC_ALPHA_DTPREL64 ¶

: BFD_RELOC_ALPHA_DTPREL_HI16 ¶

: BFD_RELOC_ALPHA_DTPREL_LO16 ¶

: BFD_RELOC_ALPHA_DTPREL16 ¶

: BFD_RELOC_ALPHA_GOTTPREL16 ¶

: BFD_RELOC_ALPHA_TPREL64 ¶

: BFD_RELOC_ALPHA_TPREL_HI16 ¶

: BFD_RELOC_ALPHA_TPREL_LO16 ¶

: BFD_RELOC_ALPHA_TPREL16 ¶

Alpha thread-local storage relocations.

: BFD_RELOC_MIPS_JMP ¶

: BFD_RELOC_MICROMIPS_JMP ¶

The MIPS jump instruction.

: BFD_RELOC_MIPS16_JMP ¶

The MIPS16 jump instruction.

: BFD_RELOC_MIPS16_GPREL ¶

MIPS16 GP relative reloc.

: BFD_RELOC_HI16 ¶

High 16 bits of 32-bit value; simple reloc.

: BFD_RELOC_HI16_S ¶

High 16 bits of 32-bit value but the low 16 bits will be sign extended and added to form the final result. If the low 16 bits form a negative number, we need to add one to the high value to compensate for the borrow when the low bits are added.

: BFD_RELOC_LO16 ¶

Low 16 bits.

: BFD_RELOC_HI16_PCREL ¶

High 16 bits of 32-bit pc-relative value.

: BFD_RELOC_HI16_S_PCREL ¶

High 16 bits of 32-bit pc-relative value, adjusted.

: BFD_RELOC_LO16_PCREL ¶

Low 16 bits of pc-relative value.

: BFD_RELOC_MIPS16_GOT16 ¶

: BFD_RELOC_MIPS16_CALL16 ¶

Equivalent of BFD_RELOC_MIPS_*, but with the MIPS16 layout of 16-bit immediate fields.

: BFD_RELOC_MIPS16_HI16 ¶

MIPS16 high 16 bits of 32-bit value.

: BFD_RELOC_MIPS16_HI16_S ¶

MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign extended and added to form the final result. If the low 16 bits form a negative number, we need to add one to the high value to compensate for the borrow when the low bits are added.

: BFD_RELOC_MIPS16_LO16 ¶

MIPS16 low 16 bits.

: BFD_RELOC_MIPS16_TLS_GD ¶

: BFD_RELOC_MIPS16_TLS_LDM ¶

: BFD_RELOC_MIPS16_TLS_DTPREL_HI16 ¶

: BFD_RELOC_MIPS16_TLS_DTPREL_LO16 ¶

: BFD_RELOC_MIPS16_TLS_GOTTPREL ¶

: BFD_RELOC_MIPS16_TLS_TPREL_HI16 ¶

: BFD_RELOC_MIPS16_TLS_TPREL_LO16 ¶

MIPS16 TLS relocations.

: BFD_RELOC_MIPS_LITERAL ¶

: BFD_RELOC_MICROMIPS_LITERAL ¶

Relocation against a MIPS literal section.

: BFD_RELOC_MICROMIPS_7_PCREL_S1 ¶

: BFD_RELOC_MICROMIPS_10_PCREL_S1 ¶

: BFD_RELOC_MICROMIPS_16_PCREL_S1 ¶

microMIPS PC-relative relocations.

: BFD_RELOC_MIPS16_16_PCREL_S1 ¶

MIPS16 PC-relative relocation.

: BFD_RELOC_MIPS_21_PCREL_S2 ¶

: BFD_RELOC_MIPS_26_PCREL_S2 ¶

: BFD_RELOC_MIPS_18_PCREL_S3 ¶

: BFD_RELOC_MIPS_19_PCREL_S2 ¶

MIPS PC-relative relocations.

: BFD_RELOC_MICROMIPS_GPREL16 ¶

: BFD_RELOC_MICROMIPS_HI16 ¶

: BFD_RELOC_MICROMIPS_HI16_S ¶

: BFD_RELOC_MICROMIPS_LO16 ¶

microMIPS versions of generic BFD relocs.

: BFD_RELOC_MIPS_GOT16 ¶

: BFD_RELOC_MICROMIPS_GOT16 ¶

: BFD_RELOC_MIPS_CALL16 ¶

: BFD_RELOC_MICROMIPS_CALL16 ¶

: BFD_RELOC_MIPS_GOT_HI16 ¶

: BFD_RELOC_MICROMIPS_GOT_HI16 ¶

: BFD_RELOC_MIPS_GOT_LO16 ¶

: BFD_RELOC_MICROMIPS_GOT_LO16 ¶

: BFD_RELOC_MIPS_CALL_HI16 ¶

: BFD_RELOC_MICROMIPS_CALL_HI16 ¶

: BFD_RELOC_MIPS_CALL_LO16 ¶

: BFD_RELOC_MICROMIPS_CALL_LO16 ¶

: BFD_RELOC_MIPS_SUB ¶

: BFD_RELOC_MICROMIPS_SUB ¶

: BFD_RELOC_MIPS_GOT_PAGE ¶

: BFD_RELOC_MICROMIPS_GOT_PAGE ¶

: BFD_RELOC_MIPS_GOT_OFST ¶

: BFD_RELOC_MICROMIPS_GOT_OFST ¶

: BFD_RELOC_MIPS_GOT_DISP ¶

: BFD_RELOC_MICROMIPS_GOT_DISP ¶

: BFD_RELOC_MIPS_SHIFT5 ¶

: BFD_RELOC_MIPS_SHIFT6 ¶

: BFD_RELOC_MIPS_INSERT_A ¶

: BFD_RELOC_MIPS_INSERT_B ¶

: BFD_RELOC_MIPS_DELETE ¶

: BFD_RELOC_MIPS_HIGHEST ¶

: BFD_RELOC_MICROMIPS_HIGHEST ¶

: BFD_RELOC_MIPS_HIGHER ¶

: BFD_RELOC_MICROMIPS_HIGHER ¶

: BFD_RELOC_MIPS_SCN_DISP ¶

: BFD_RELOC_MICROMIPS_SCN_DISP ¶

: BFD_RELOC_MIPS_16 ¶

: BFD_RELOC_MIPS_RELGOT ¶

: BFD_RELOC_MIPS_JALR ¶

: BFD_RELOC_MICROMIPS_JALR ¶

: BFD_RELOC_MIPS_TLS_DTPMOD32 ¶

: BFD_RELOC_MIPS_TLS_DTPREL32 ¶

: BFD_RELOC_MIPS_TLS_DTPMOD64 ¶

: BFD_RELOC_MIPS_TLS_DTPREL64 ¶

: BFD_RELOC_MIPS_TLS_GD ¶

: BFD_RELOC_MICROMIPS_TLS_GD ¶

: BFD_RELOC_MIPS_TLS_LDM ¶

: BFD_RELOC_MICROMIPS_TLS_LDM ¶

: BFD_RELOC_MIPS_TLS_DTPREL_HI16 ¶

: BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16 ¶

: BFD_RELOC_MIPS_TLS_DTPREL_LO16 ¶

: BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16 ¶

: BFD_RELOC_MIPS_TLS_GOTTPREL ¶

: BFD_RELOC_MICROMIPS_TLS_GOTTPREL ¶

: BFD_RELOC_MIPS_TLS_TPREL32 ¶

: BFD_RELOC_MIPS_TLS_TPREL64 ¶

: BFD_RELOC_MIPS_TLS_TPREL_HI16 ¶

: BFD_RELOC_MICROMIPS_TLS_TPREL_HI16 ¶

: BFD_RELOC_MIPS_TLS_TPREL_LO16 ¶

: BFD_RELOC_MICROMIPS_TLS_TPREL_LO16 ¶

: BFD_RELOC_MIPS_EH ¶

MIPS ELF relocations.

: BFD_RELOC_MIPS_COPY ¶

: BFD_RELOC_MIPS_JUMP_SLOT ¶

MIPS ELF relocations (VxWorks and PLT extensions).

: BFD_RELOC_MOXIE_10_PCREL ¶

Moxie ELF relocations.

: BFD_RELOC_FT32_10 ¶

: BFD_RELOC_FT32_20 ¶

: BFD_RELOC_FT32_17 ¶

: BFD_RELOC_FT32_18 ¶

: BFD_RELOC_FT32_RELAX ¶

: BFD_RELOC_FT32_SC0 ¶

: BFD_RELOC_FT32_SC1 ¶

: BFD_RELOC_FT32_15 ¶

: BFD_RELOC_FT32_DIFF32 ¶

FT32 ELF relocations.

: BFD_RELOC_FRV_LABEL16 ¶

: BFD_RELOC_FRV_LABEL24 ¶

: BFD_RELOC_FRV_LO16 ¶

: BFD_RELOC_FRV_HI16 ¶

: BFD_RELOC_FRV_GPREL12 ¶

: BFD_RELOC_FRV_GPRELU12 ¶

: BFD_RELOC_FRV_GPREL32 ¶

: BFD_RELOC_FRV_GPRELHI ¶

: BFD_RELOC_FRV_GPRELLO ¶

: BFD_RELOC_FRV_GOT12 ¶

: BFD_RELOC_FRV_GOTHI ¶

: BFD_RELOC_FRV_GOTLO ¶

: BFD_RELOC_FRV_FUNCDESC ¶

: BFD_RELOC_FRV_FUNCDESC_GOT12 ¶

: BFD_RELOC_FRV_FUNCDESC_GOTHI ¶

: BFD_RELOC_FRV_FUNCDESC_GOTLO ¶

: BFD_RELOC_FRV_FUNCDESC_VALUE ¶

: BFD_RELOC_FRV_FUNCDESC_GOTOFF12 ¶

: BFD_RELOC_FRV_FUNCDESC_GOTOFFHI ¶

: BFD_RELOC_FRV_FUNCDESC_GOTOFFLO ¶

: BFD_RELOC_FRV_GOTOFF12 ¶

: BFD_RELOC_FRV_GOTOFFHI ¶

: BFD_RELOC_FRV_GOTOFFLO ¶

: BFD_RELOC_FRV_GETTLSOFF ¶

: BFD_RELOC_FRV_TLSDESC_VALUE ¶

: BFD_RELOC_FRV_GOTTLSDESC12 ¶

: BFD_RELOC_FRV_GOTTLSDESCHI ¶

: BFD_RELOC_FRV_GOTTLSDESCLO ¶

: BFD_RELOC_FRV_TLSMOFF12 ¶

: BFD_RELOC_FRV_TLSMOFFHI ¶

: BFD_RELOC_FRV_TLSMOFFLO ¶

: BFD_RELOC_FRV_GOTTLSOFF12 ¶

: BFD_RELOC_FRV_GOTTLSOFFHI ¶

: BFD_RELOC_FRV_GOTTLSOFFLO ¶

: BFD_RELOC_FRV_TLSOFF ¶

: BFD_RELOC_FRV_TLSDESC_RELAX ¶

: BFD_RELOC_FRV_GETTLSOFF_RELAX ¶

: BFD_RELOC_FRV_TLSOFF_RELAX ¶

: BFD_RELOC_FRV_TLSMOFF ¶

Fujitsu Frv Relocations.

: BFD_RELOC_MN10300_GOTOFF24 ¶

This is a 24bit GOT-relative reloc for the mn10300.

: BFD_RELOC_MN10300_GOT32 ¶

This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes in the instruction.

: BFD_RELOC_MN10300_GOT24 ¶

This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes in the instruction.

: BFD_RELOC_MN10300_GOT16 ¶

This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes in the instruction.

: BFD_RELOC_MN10300_COPY ¶

Copy symbol at runtime.

: BFD_RELOC_MN10300_GLOB_DAT ¶

Create GOT entry.

: BFD_RELOC_MN10300_JMP_SLOT ¶

Create PLT entry.

: BFD_RELOC_MN10300_RELATIVE ¶

Adjust by program base.

: BFD_RELOC_MN10300_SYM_DIFF ¶

Together with another reloc targeted at the same location, allows for a value that is the difference of two symbols in the same section.

: BFD_RELOC_MN10300_ALIGN ¶

The addend of this reloc is an alignment power that must be honoured at the offset’s location, regardless of linker relaxation.

: BFD_RELOC_MN10300_TLS_GD ¶

: BFD_RELOC_MN10300_TLS_LD ¶

: BFD_RELOC_MN10300_TLS_LDO ¶

: BFD_RELOC_MN10300_TLS_GOTIE ¶

: BFD_RELOC_MN10300_TLS_IE ¶

: BFD_RELOC_MN10300_TLS_LE ¶

: BFD_RELOC_MN10300_TLS_DTPMOD ¶

: BFD_RELOC_MN10300_TLS_DTPOFF ¶

: BFD_RELOC_MN10300_TLS_TPOFF ¶

Various TLS-related relocations.

: BFD_RELOC_MN10300_32_PCREL ¶

This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the instruction.

: BFD_RELOC_MN10300_16_PCREL ¶

This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the instruction.

: BFD_RELOC_386_GOT32 ¶

: BFD_RELOC_386_PLT32 ¶

: BFD_RELOC_386_COPY ¶

: BFD_RELOC_386_GLOB_DAT ¶

: BFD_RELOC_386_JUMP_SLOT ¶

: BFD_RELOC_386_RELATIVE ¶

: BFD_RELOC_386_GOTOFF ¶

: BFD_RELOC_386_GOTPC ¶

: BFD_RELOC_386_TLS_TPOFF ¶

: BFD_RELOC_386_TLS_IE ¶

: BFD_RELOC_386_TLS_GOTIE ¶

: BFD_RELOC_386_TLS_LE ¶

: BFD_RELOC_386_TLS_GD ¶

: BFD_RELOC_386_TLS_LDM ¶

: BFD_RELOC_386_TLS_LDO_32 ¶

: BFD_RELOC_386_TLS_IE_32 ¶

: BFD_RELOC_386_TLS_LE_32 ¶

: BFD_RELOC_386_TLS_DTPMOD32 ¶

: BFD_RELOC_386_TLS_DTPOFF32 ¶

: BFD_RELOC_386_TLS_TPOFF32 ¶

: BFD_RELOC_386_TLS_GOTDESC ¶

: BFD_RELOC_386_TLS_DESC_CALL ¶

: BFD_RELOC_386_TLS_DESC ¶

: BFD_RELOC_386_IRELATIVE ¶

: BFD_RELOC_386_GOT32X ¶

i386/elf relocations.

: BFD_RELOC_X86_64_GOT32 ¶

: BFD_RELOC_X86_64_PLT32 ¶

: BFD_RELOC_X86_64_COPY ¶

: BFD_RELOC_X86_64_GLOB_DAT ¶

: BFD_RELOC_X86_64_JUMP_SLOT ¶

: BFD_RELOC_X86_64_RELATIVE ¶

: BFD_RELOC_X86_64_GOTPCREL ¶

: BFD_RELOC_X86_64_32S ¶

: BFD_RELOC_X86_64_DTPMOD64 ¶

: BFD_RELOC_X86_64_DTPOFF64 ¶

: BFD_RELOC_X86_64_TPOFF64 ¶

: BFD_RELOC_X86_64_TLSGD ¶

: BFD_RELOC_X86_64_TLSLD ¶

: BFD_RELOC_X86_64_DTPOFF32 ¶

: BFD_RELOC_X86_64_GOTTPOFF ¶

: BFD_RELOC_X86_64_TPOFF32 ¶

: BFD_RELOC_X86_64_GOTOFF64 ¶

: BFD_RELOC_X86_64_GOTPC32 ¶

: BFD_RELOC_X86_64_GOT64 ¶

: BFD_RELOC_X86_64_GOTPCREL64 ¶

: BFD_RELOC_X86_64_GOTPC64 ¶

: BFD_RELOC_X86_64_GOTPLT64 ¶

: BFD_RELOC_X86_64_PLTOFF64 ¶

: BFD_RELOC_X86_64_GOTPC32_TLSDESC ¶

: BFD_RELOC_X86_64_TLSDESC_CALL ¶

: BFD_RELOC_X86_64_TLSDESC ¶

: BFD_RELOC_X86_64_IRELATIVE ¶

: BFD_RELOC_X86_64_PC32_BND ¶

: BFD_RELOC_X86_64_PLT32_BND ¶

: BFD_RELOC_X86_64_GOTPCRELX ¶

: BFD_RELOC_X86_64_REX_GOTPCRELX ¶

: BFD_RELOC_X86_64_CODE_4_GOTPCRELX ¶

: BFD_RELOC_X86_64_CODE_4_GOTTPOFF ¶

: BFD_RELOC_X86_64_CODE_4_GOTPC32_TLSDESC ¶

: BFD_RELOC_X86_64_CODE_5_GOTPCRELX ¶

: BFD_RELOC_X86_64_CODE_5_GOTTPOFF ¶

: BFD_RELOC_X86_64_CODE_5_GOTPC32_TLSDESC ¶

: BFD_RELOC_X86_64_CODE_6_GOTPCRELX ¶

: BFD_RELOC_X86_64_CODE_6_GOTTPOFF ¶

: BFD_RELOC_X86_64_CODE_6_GOTPC32_TLSDESC ¶

x86-64/elf relocations.

: BFD_RELOC_NS32K_IMM_8 ¶

: BFD_RELOC_NS32K_IMM_16 ¶

: BFD_RELOC_NS32K_IMM_32 ¶

: BFD_RELOC_NS32K_IMM_8_PCREL ¶

: BFD_RELOC_NS32K_IMM_16_PCREL ¶

: BFD_RELOC_NS32K_IMM_32_PCREL ¶

: BFD_RELOC_NS32K_DISP_8 ¶

: BFD_RELOC_NS32K_DISP_16 ¶

: BFD_RELOC_NS32K_DISP_32 ¶

: BFD_RELOC_NS32K_DISP_8_PCREL ¶

: BFD_RELOC_NS32K_DISP_16_PCREL ¶

: BFD_RELOC_NS32K_DISP_32_PCREL ¶

ns32k relocations.

: BFD_RELOC_PDP11_DISP_8_PCREL ¶

: BFD_RELOC_PDP11_DISP_6_PCREL ¶

PDP11 relocations.

: BFD_RELOC_PJ_CODE_HI16 ¶

: BFD_RELOC_PJ_CODE_LO16 ¶

: BFD_RELOC_PJ_CODE_DIR16 ¶

: BFD_RELOC_PJ_CODE_DIR32 ¶

: BFD_RELOC_PJ_CODE_REL16 ¶

: BFD_RELOC_PJ_CODE_REL32 ¶

Picojava relocs. Not all of these appear in object files.

: BFD_RELOC_PPC_B26 ¶

: BFD_RELOC_PPC_BA26 ¶

: BFD_RELOC_PPC_TOC16 ¶

: BFD_RELOC_PPC_TOC16_LO ¶

: BFD_RELOC_PPC_TOC16_HI ¶

: BFD_RELOC_PPC_B16 ¶

: BFD_RELOC_PPC_B16_BRTAKEN ¶

: BFD_RELOC_PPC_B16_BRNTAKEN ¶

: BFD_RELOC_PPC_BA16 ¶

: BFD_RELOC_PPC_BA16_BRTAKEN ¶

: BFD_RELOC_PPC_BA16_BRNTAKEN ¶

: BFD_RELOC_PPC_COPY ¶

: BFD_RELOC_PPC_GLOB_DAT ¶

: BFD_RELOC_PPC_JMP_SLOT ¶

: BFD_RELOC_PPC_RELATIVE ¶

: BFD_RELOC_PPC_LOCAL24PC ¶

: BFD_RELOC_PPC_EMB_NADDR32 ¶

: BFD_RELOC_PPC_EMB_NADDR16 ¶

: BFD_RELOC_PPC_EMB_NADDR16_LO ¶

: BFD_RELOC_PPC_EMB_NADDR16_HI ¶

: BFD_RELOC_PPC_EMB_NADDR16_HA ¶

: BFD_RELOC_PPC_EMB_SDAI16 ¶

: BFD_RELOC_PPC_EMB_SDA2I16 ¶

: BFD_RELOC_PPC_EMB_SDA2REL ¶

: BFD_RELOC_PPC_EMB_SDA21 ¶

: BFD_RELOC_PPC_EMB_MRKREF ¶

: BFD_RELOC_PPC_EMB_RELSEC16 ¶

: BFD_RELOC_PPC_EMB_RELST_LO ¶

: BFD_RELOC_PPC_EMB_RELST_HI ¶

: BFD_RELOC_PPC_EMB_RELST_HA ¶

: BFD_RELOC_PPC_EMB_BIT_FLD ¶

: BFD_RELOC_PPC_EMB_RELSDA ¶

: BFD_RELOC_PPC_VLE_REL8 ¶

: BFD_RELOC_PPC_VLE_REL15 ¶

: BFD_RELOC_PPC_VLE_REL24 ¶

: BFD_RELOC_PPC_VLE_LO16A ¶

: BFD_RELOC_PPC_VLE_LO16D ¶

: BFD_RELOC_PPC_VLE_HI16A ¶

: BFD_RELOC_PPC_VLE_HI16D ¶

: BFD_RELOC_PPC_VLE_HA16A ¶

: BFD_RELOC_PPC_VLE_HA16D ¶

: BFD_RELOC_PPC_VLE_SDA21 ¶

: BFD_RELOC_PPC_VLE_SDA21_LO ¶

: BFD_RELOC_PPC_VLE_SDAREL_LO16A ¶

: BFD_RELOC_PPC_VLE_SDAREL_LO16D ¶

: BFD_RELOC_PPC_VLE_SDAREL_HI16A ¶

: BFD_RELOC_PPC_VLE_SDAREL_HI16D ¶

: BFD_RELOC_PPC_VLE_SDAREL_HA16A ¶

: BFD_RELOC_PPC_VLE_SDAREL_HA16D ¶

: BFD_RELOC_PPC_16DX_HA ¶

: BFD_RELOC_PPC_REL16DX_HA ¶

: BFD_RELOC_PPC_NEG ¶

: BFD_RELOC_PPC64_HIGHER ¶

: BFD_RELOC_PPC64_HIGHER_S ¶

: BFD_RELOC_PPC64_HIGHEST ¶

: BFD_RELOC_PPC64_HIGHEST_S ¶

: BFD_RELOC_PPC64_TOC16_LO ¶

: BFD_RELOC_PPC64_TOC16_HI ¶

: BFD_RELOC_PPC64_TOC16_HA ¶

: BFD_RELOC_PPC64_TOC ¶

: BFD_RELOC_PPC64_PLTGOT16 ¶

: BFD_RELOC_PPC64_PLTGOT16_LO ¶

: BFD_RELOC_PPC64_PLTGOT16_HI ¶

: BFD_RELOC_PPC64_PLTGOT16_HA ¶

: BFD_RELOC_PPC64_ADDR16_DS ¶

: BFD_RELOC_PPC64_ADDR16_LO_DS ¶

: BFD_RELOC_PPC64_GOT16_DS ¶

: BFD_RELOC_PPC64_GOT16_LO_DS ¶

: BFD_RELOC_PPC64_PLT16_LO_DS ¶

: BFD_RELOC_PPC64_SECTOFF_DS ¶

: BFD_RELOC_PPC64_SECTOFF_LO_DS ¶

: BFD_RELOC_PPC64_TOC16_DS ¶

: BFD_RELOC_PPC64_TOC16_LO_DS ¶

: BFD_RELOC_PPC64_PLTGOT16_DS ¶

: BFD_RELOC_PPC64_PLTGOT16_LO_DS ¶

: BFD_RELOC_PPC64_ADDR16_HIGH ¶

: BFD_RELOC_PPC64_ADDR16_HIGHA ¶

: BFD_RELOC_PPC64_REL16_HIGH ¶

: BFD_RELOC_PPC64_REL16_HIGHA ¶

: BFD_RELOC_PPC64_REL16_HIGHER ¶

: BFD_RELOC_PPC64_REL16_HIGHERA ¶

: BFD_RELOC_PPC64_REL16_HIGHEST ¶

: BFD_RELOC_PPC64_REL16_HIGHESTA ¶

: BFD_RELOC_PPC64_ADDR64_LOCAL ¶

: BFD_RELOC_PPC64_ENTRY ¶

: BFD_RELOC_PPC64_REL24_NOTOC ¶

: BFD_RELOC_PPC64_REL24_P9NOTOC ¶

: BFD_RELOC_PPC64_D34 ¶

: BFD_RELOC_PPC64_D34_LO ¶

: BFD_RELOC_PPC64_D34_HI30 ¶

: BFD_RELOC_PPC64_D34_HA30 ¶

: BFD_RELOC_PPC64_PCREL34 ¶

: BFD_RELOC_PPC64_GOT_PCREL34 ¶

: BFD_RELOC_PPC64_PLT_PCREL34 ¶

: BFD_RELOC_PPC64_ADDR16_HIGHER34 ¶

: BFD_RELOC_PPC64_ADDR16_HIGHERA34 ¶

: BFD_RELOC_PPC64_ADDR16_HIGHEST34 ¶

: BFD_RELOC_PPC64_ADDR16_HIGHESTA34 ¶

: BFD_RELOC_PPC64_REL16_HIGHER34 ¶

: BFD_RELOC_PPC64_REL16_HIGHERA34 ¶

: BFD_RELOC_PPC64_REL16_HIGHEST34 ¶

: BFD_RELOC_PPC64_REL16_HIGHESTA34 ¶

: BFD_RELOC_PPC64_D28 ¶

: BFD_RELOC_PPC64_PCREL28 ¶

Power(rs6000) and PowerPC relocations.

: BFD_RELOC_PPC_TLS ¶

: BFD_RELOC_PPC_TLSGD ¶

: BFD_RELOC_PPC_TLSLD ¶

: BFD_RELOC_PPC_TLSLE ¶

: BFD_RELOC_PPC_TLSIE ¶

: BFD_RELOC_PPC_TLSM ¶

: BFD_RELOC_PPC_TLSML ¶

: BFD_RELOC_PPC_DTPMOD ¶

: BFD_RELOC_PPC_TPREL16 ¶

: BFD_RELOC_PPC_TPREL16_LO ¶

: BFD_RELOC_PPC_TPREL16_HI ¶

: BFD_RELOC_PPC_TPREL16_HA ¶

: BFD_RELOC_PPC_TPREL ¶

: BFD_RELOC_PPC_DTPREL16 ¶

: BFD_RELOC_PPC_DTPREL16_LO ¶

: BFD_RELOC_PPC_DTPREL16_HI ¶

: BFD_RELOC_PPC_DTPREL16_HA ¶

: BFD_RELOC_PPC_DTPREL ¶

: BFD_RELOC_PPC_GOT_TLSGD16 ¶

: BFD_RELOC_PPC_GOT_TLSGD16_LO ¶

: BFD_RELOC_PPC_GOT_TLSGD16_HI ¶

: BFD_RELOC_PPC_GOT_TLSGD16_HA ¶

: BFD_RELOC_PPC_GOT_TLSLD16 ¶

: BFD_RELOC_PPC_GOT_TLSLD16_LO ¶

: BFD_RELOC_PPC_GOT_TLSLD16_HI ¶

: BFD_RELOC_PPC_GOT_TLSLD16_HA ¶

: BFD_RELOC_PPC_GOT_TPREL16 ¶

: BFD_RELOC_PPC_GOT_TPREL16_LO ¶

: BFD_RELOC_PPC_GOT_TPREL16_HI ¶

: BFD_RELOC_PPC_GOT_TPREL16_HA ¶

: BFD_RELOC_PPC_GOT_DTPREL16 ¶

: BFD_RELOC_PPC_GOT_DTPREL16_LO ¶

: BFD_RELOC_PPC_GOT_DTPREL16_HI ¶

: BFD_RELOC_PPC_GOT_DTPREL16_HA ¶

: BFD_RELOC_PPC64_TLSGD ¶

: BFD_RELOC_PPC64_TLSLD ¶

: BFD_RELOC_PPC64_TLSLE ¶

: BFD_RELOC_PPC64_TLSIE ¶

: BFD_RELOC_PPC64_TLSM ¶

: BFD_RELOC_PPC64_TLSML ¶

: BFD_RELOC_PPC64_TPREL16_DS ¶

: BFD_RELOC_PPC64_TPREL16_LO_DS ¶

: BFD_RELOC_PPC64_TPREL16_HIGH ¶

: BFD_RELOC_PPC64_TPREL16_HIGHA ¶

: BFD_RELOC_PPC64_TPREL16_HIGHER ¶

: BFD_RELOC_PPC64_TPREL16_HIGHERA ¶

: BFD_RELOC_PPC64_TPREL16_HIGHEST ¶

: BFD_RELOC_PPC64_TPREL16_HIGHESTA ¶

: BFD_RELOC_PPC64_DTPREL16_DS ¶

: BFD_RELOC_PPC64_DTPREL16_LO_DS ¶

: BFD_RELOC_PPC64_DTPREL16_HIGH ¶

: BFD_RELOC_PPC64_DTPREL16_HIGHA ¶

: BFD_RELOC_PPC64_DTPREL16_HIGHER ¶

: BFD_RELOC_PPC64_DTPREL16_HIGHERA ¶

: BFD_RELOC_PPC64_DTPREL16_HIGHEST ¶

: BFD_RELOC_PPC64_DTPREL16_HIGHESTA ¶

: BFD_RELOC_PPC64_TPREL34 ¶

: BFD_RELOC_PPC64_DTPREL34 ¶

: BFD_RELOC_PPC64_GOT_TLSGD_PCREL34 ¶

: BFD_RELOC_PPC64_GOT_TLSLD_PCREL34 ¶

: BFD_RELOC_PPC64_GOT_TPREL_PCREL34 ¶

: BFD_RELOC_PPC64_GOT_DTPREL_PCREL34 ¶

: BFD_RELOC_PPC64_TLS_PCREL ¶

PowerPC and PowerPC64 thread-local storage relocations.

: BFD_RELOC_I370_D12 ¶

IBM 370/390 relocations.

: BFD_RELOC_CTOR ¶

The type of reloc used to build a constructor table - at the moment probably a 32 bit wide absolute relocation, but the target can choose. It generally does map to one of the other relocation types.

: BFD_RELOC_ARM_PCREL_BRANCH ¶

ARM 26 bit pc-relative branch. The lowest two bits must be zero and are not stored in the instruction.

: BFD_RELOC_ARM_PCREL_BLX ¶

ARM 26 bit pc-relative branch. The lowest bit must be zero and is not stored in the instruction. The 2nd lowest bit comes from a 1 bit field in the instruction.

: BFD_RELOC_THUMB_PCREL_BLX ¶

Thumb 22 bit pc-relative branch. The lowest bit must be zero and is not stored in the instruction. The 2nd lowest bit comes from a 1 bit field in the instruction.

: BFD_RELOC_ARM_PCREL_CALL ¶

ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction.

: BFD_RELOC_ARM_PCREL_JUMP ¶

ARM 26-bit pc-relative branch for B or conditional BL instruction.

: BFD_RELOC_THUMB_PCREL_BRANCH5 ¶

ARM 5-bit pc-relative branch for Branch Future instructions.

: BFD_RELOC_THUMB_PCREL_BFCSEL ¶

ARM 6-bit pc-relative branch for BFCSEL instruction.

: BFD_RELOC_ARM_THUMB_BF17 ¶

ARM 17-bit pc-relative branch for Branch Future instructions.

: BFD_RELOC_ARM_THUMB_BF13 ¶

ARM 13-bit pc-relative branch for BFCSEL instruction.

: BFD_RELOC_ARM_THUMB_BF19 ¶

ARM 19-bit pc-relative branch for Branch Future Link instruction.

: BFD_RELOC_ARM_THUMB_LOOP12 ¶

ARM 12-bit pc-relative branch for Low Overhead Loop instructions.

: BFD_RELOC_THUMB_PCREL_BRANCH7 ¶

: BFD_RELOC_THUMB_PCREL_BRANCH9 ¶

: BFD_RELOC_THUMB_PCREL_BRANCH12 ¶

: BFD_RELOC_THUMB_PCREL_BRANCH20 ¶

: BFD_RELOC_THUMB_PCREL_BRANCH23 ¶

: BFD_RELOC_THUMB_PCREL_BRANCH25 ¶

Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches. The lowest bit must be zero and is not stored in the instruction. Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an "nn" one smaller in all cases. Note further that BRANCH23 corresponds to R_ARM_THM_CALL.

: BFD_RELOC_ARM_OFFSET_IMM ¶

12-bit immediate offset, used in ARM-format ldr and str instructions.

: BFD_RELOC_ARM_THUMB_OFFSET ¶

5-bit immediate offset, used in Thumb-format ldr and str instructions.

: BFD_RELOC_ARM_TARGET1 ¶

Pc-relative or absolute relocation depending on target. Used for entries in .init_array sections.

: BFD_RELOC_ARM_ROSEGREL32 ¶

Read-only segment base relative address.

: BFD_RELOC_ARM_SBREL32 ¶

Data segment base relative address.

: BFD_RELOC_ARM_TARGET2 ¶

This reloc is used for references to RTTI data from exception handling tables. The actual definition depends on the target. It may be a pc-relative or some form of GOT-indirect relocation.

: BFD_RELOC_ARM_PREL31 ¶

31-bit PC relative address.

: BFD_RELOC_ARM_MOVW ¶

: BFD_RELOC_ARM_MOVT ¶

: BFD_RELOC_ARM_MOVW_PCREL ¶

: BFD_RELOC_ARM_MOVT_PCREL ¶

: BFD_RELOC_ARM_THUMB_MOVW ¶

: BFD_RELOC_ARM_THUMB_MOVT ¶

: BFD_RELOC_ARM_THUMB_MOVW_PCREL ¶

: BFD_RELOC_ARM_THUMB_MOVT_PCREL ¶

Low and High halfword relocations for MOVW and MOVT instructions.

: BFD_RELOC_ARM_GOTFUNCDESC ¶

: BFD_RELOC_ARM_GOTOFFFUNCDESC ¶

: BFD_RELOC_ARM_FUNCDESC ¶

: BFD_RELOC_ARM_FUNCDESC_VALUE ¶

: BFD_RELOC_ARM_TLS_GD32_FDPIC ¶

: BFD_RELOC_ARM_TLS_LDM32_FDPIC ¶

: BFD_RELOC_ARM_TLS_IE32_FDPIC ¶

ARM FDPIC specific relocations.

: BFD_RELOC_ARM_JUMP_SLOT ¶

: BFD_RELOC_ARM_GLOB_DAT ¶

: BFD_RELOC_ARM_GOT32 ¶

: BFD_RELOC_ARM_PLT32 ¶

: BFD_RELOC_ARM_RELATIVE ¶

: BFD_RELOC_ARM_GOTOFF ¶

: BFD_RELOC_ARM_GOTPC ¶

: BFD_RELOC_ARM_GOT_PREL ¶

Relocations for setting up GOTs and PLTs for shared libraries.

: BFD_RELOC_ARM_TLS_GD32 ¶

: BFD_RELOC_ARM_TLS_LDO32 ¶

: BFD_RELOC_ARM_TLS_LDM32 ¶

: BFD_RELOC_ARM_TLS_DTPOFF32 ¶

: BFD_RELOC_ARM_TLS_DTPMOD32 ¶

: BFD_RELOC_ARM_TLS_TPOFF32 ¶

: BFD_RELOC_ARM_TLS_IE32 ¶

: BFD_RELOC_ARM_TLS_LE32 ¶

: BFD_RELOC_ARM_TLS_GOTDESC ¶

: BFD_RELOC_ARM_TLS_CALL ¶

: BFD_RELOC_ARM_THM_TLS_CALL ¶

: BFD_RELOC_ARM_TLS_DESCSEQ ¶

: BFD_RELOC_ARM_THM_TLS_DESCSEQ ¶

: BFD_RELOC_ARM_TLS_DESC ¶

ARM thread-local storage relocations.

: BFD_RELOC_ARM_ALU_PC_G0_NC ¶

: BFD_RELOC_ARM_ALU_PC_G0 ¶

: BFD_RELOC_ARM_ALU_PC_G1_NC ¶

: BFD_RELOC_ARM_ALU_PC_G1 ¶

: BFD_RELOC_ARM_ALU_PC_G2 ¶

: BFD_RELOC_ARM_LDR_PC_G0 ¶

: BFD_RELOC_ARM_LDR_PC_G1 ¶

: BFD_RELOC_ARM_LDR_PC_G2 ¶

: BFD_RELOC_ARM_LDRS_PC_G0 ¶

: BFD_RELOC_ARM_LDRS_PC_G1 ¶

: BFD_RELOC_ARM_LDRS_PC_G2 ¶

: BFD_RELOC_ARM_LDC_PC_G0 ¶

: BFD_RELOC_ARM_LDC_PC_G1 ¶

: BFD_RELOC_ARM_LDC_PC_G2 ¶

: BFD_RELOC_ARM_ALU_SB_G0_NC ¶

: BFD_RELOC_ARM_ALU_SB_G0 ¶

: BFD_RELOC_ARM_ALU_SB_G1_NC ¶

: BFD_RELOC_ARM_ALU_SB_G1 ¶

: BFD_RELOC_ARM_ALU_SB_G2 ¶

: BFD_RELOC_ARM_LDR_SB_G0 ¶

: BFD_RELOC_ARM_LDR_SB_G1 ¶

: BFD_RELOC_ARM_LDR_SB_G2 ¶

: BFD_RELOC_ARM_LDRS_SB_G0 ¶

: BFD_RELOC_ARM_LDRS_SB_G1 ¶

: BFD_RELOC_ARM_LDRS_SB_G2 ¶

: BFD_RELOC_ARM_LDC_SB_G0 ¶

: BFD_RELOC_ARM_LDC_SB_G1 ¶

: BFD_RELOC_ARM_LDC_SB_G2 ¶

ARM group relocations.

: BFD_RELOC_ARM_V4BX ¶

Annotation of BX instructions.

: BFD_RELOC_ARM_IRELATIVE ¶

ARM support for STT_GNU_IFUNC.

: BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC ¶

: BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC ¶

: BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC ¶

: BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC ¶

Thumb1 relocations to support execute-only code.

: BFD_RELOC_ARM_IMMEDIATE ¶

: BFD_RELOC_ARM_ADRL_IMMEDIATE ¶

: BFD_RELOC_ARM_T32_IMMEDIATE ¶

: BFD_RELOC_ARM_T32_ADD_IMM ¶

: BFD_RELOC_ARM_T32_IMM12 ¶

: BFD_RELOC_ARM_T32_ADD_PC12 ¶

: BFD_RELOC_ARM_SHIFT_IMM ¶

: BFD_RELOC_ARM_SMC ¶

: BFD_RELOC_ARM_HVC ¶

: BFD_RELOC_ARM_SWI ¶

: BFD_RELOC_ARM_MULTI ¶

: BFD_RELOC_ARM_CP_OFF_IMM ¶

: BFD_RELOC_ARM_CP_OFF_IMM_S2 ¶

: BFD_RELOC_ARM_T32_CP_OFF_IMM ¶

: BFD_RELOC_ARM_T32_CP_OFF_IMM_S2 ¶

: BFD_RELOC_ARM_T32_VLDR_VSTR_OFF_IMM ¶

: BFD_RELOC_ARM_ADR_IMM ¶

: BFD_RELOC_ARM_LDR_IMM ¶

: BFD_RELOC_ARM_LITERAL ¶

: BFD_RELOC_ARM_IN_POOL ¶

: BFD_RELOC_ARM_OFFSET_IMM8 ¶

: BFD_RELOC_ARM_T32_OFFSET_U8 ¶

: BFD_RELOC_ARM_T32_OFFSET_IMM ¶

: BFD_RELOC_ARM_HWLITERAL ¶

: BFD_RELOC_ARM_THUMB_ADD ¶

: BFD_RELOC_ARM_THUMB_IMM ¶

: BFD_RELOC_ARM_THUMB_SHIFT ¶

These relocs are only used within the ARM assembler. They are not (at present) written to any object files.

: BFD_RELOC_SH_PCDISP8BY2 ¶

: BFD_RELOC_SH_PCDISP12BY2 ¶

: BFD_RELOC_SH_IMM3 ¶

: BFD_RELOC_SH_IMM3U ¶

: BFD_RELOC_SH_DISP12 ¶

: BFD_RELOC_SH_DISP12BY2 ¶

: BFD_RELOC_SH_DISP12BY4 ¶

: BFD_RELOC_SH_DISP12BY8 ¶

: BFD_RELOC_SH_DISP20 ¶

: BFD_RELOC_SH_DISP20BY8 ¶

: BFD_RELOC_SH_IMM4 ¶

: BFD_RELOC_SH_IMM4BY2 ¶

: BFD_RELOC_SH_IMM4BY4 ¶

: BFD_RELOC_SH_IMM8 ¶

: BFD_RELOC_SH_IMM8BY2 ¶

: BFD_RELOC_SH_IMM8BY4 ¶

: BFD_RELOC_SH_PCRELIMM8BY2 ¶

: BFD_RELOC_SH_PCRELIMM8BY4 ¶

: BFD_RELOC_SH_SWITCH16 ¶

: BFD_RELOC_SH_SWITCH32 ¶

: BFD_RELOC_SH_USES ¶

: BFD_RELOC_SH_COUNT ¶

: BFD_RELOC_SH_ALIGN ¶

: BFD_RELOC_SH_CODE ¶

: BFD_RELOC_SH_DATA ¶

: BFD_RELOC_SH_LABEL ¶

: BFD_RELOC_SH_LOOP_START ¶

: BFD_RELOC_SH_LOOP_END ¶

: BFD_RELOC_SH_COPY ¶

: BFD_RELOC_SH_GLOB_DAT ¶

: BFD_RELOC_SH_JMP_SLOT ¶

: BFD_RELOC_SH_RELATIVE ¶

: BFD_RELOC_SH_GOTPC ¶

: BFD_RELOC_SH_GOT_LOW16 ¶

: BFD_RELOC_SH_GOT_MEDLOW16 ¶

: BFD_RELOC_SH_GOT_MEDHI16 ¶

: BFD_RELOC_SH_GOT_HI16 ¶

: BFD_RELOC_SH_GOTPLT_LOW16 ¶

: BFD_RELOC_SH_GOTPLT_MEDLOW16 ¶

: BFD_RELOC_SH_GOTPLT_MEDHI16 ¶

: BFD_RELOC_SH_GOTPLT_HI16 ¶

: BFD_RELOC_SH_PLT_LOW16 ¶

: BFD_RELOC_SH_PLT_MEDLOW16 ¶

: BFD_RELOC_SH_PLT_MEDHI16 ¶

: BFD_RELOC_SH_PLT_HI16 ¶

: BFD_RELOC_SH_GOTOFF_LOW16 ¶

: BFD_RELOC_SH_GOTOFF_MEDLOW16 ¶

: BFD_RELOC_SH_GOTOFF_MEDHI16 ¶

: BFD_RELOC_SH_GOTOFF_HI16 ¶

: BFD_RELOC_SH_GOTPC_LOW16 ¶

: BFD_RELOC_SH_GOTPC_MEDLOW16 ¶

: BFD_RELOC_SH_GOTPC_MEDHI16 ¶

: BFD_RELOC_SH_GOTPC_HI16 ¶

: BFD_RELOC_SH_COPY64 ¶

: BFD_RELOC_SH_GLOB_DAT64 ¶

: BFD_RELOC_SH_JMP_SLOT64 ¶

: BFD_RELOC_SH_RELATIVE64 ¶

: BFD_RELOC_SH_GOT10BY4 ¶

: BFD_RELOC_SH_GOT10BY8 ¶

: BFD_RELOC_SH_GOTPLT10BY4 ¶

: BFD_RELOC_SH_GOTPLT10BY8 ¶

: BFD_RELOC_SH_GOTPLT32 ¶

: BFD_RELOC_SH_SHMEDIA_CODE ¶

: BFD_RELOC_SH_IMMU5 ¶

: BFD_RELOC_SH_IMMS6 ¶

: BFD_RELOC_SH_IMMS6BY32 ¶

: BFD_RELOC_SH_IMMU6 ¶

: BFD_RELOC_SH_IMMS10 ¶

: BFD_RELOC_SH_IMMS10BY2 ¶

: BFD_RELOC_SH_IMMS10BY4 ¶

: BFD_RELOC_SH_IMMS10BY8 ¶

: BFD_RELOC_SH_IMMS16 ¶

: BFD_RELOC_SH_IMMU16 ¶

: BFD_RELOC_SH_IMM_LOW16 ¶

: BFD_RELOC_SH_IMM_LOW16_PCREL ¶

: BFD_RELOC_SH_IMM_MEDLOW16 ¶

: BFD_RELOC_SH_IMM_MEDLOW16_PCREL ¶

: BFD_RELOC_SH_IMM_MEDHI16 ¶

: BFD_RELOC_SH_IMM_MEDHI16_PCREL ¶

: BFD_RELOC_SH_IMM_HI16 ¶

: BFD_RELOC_SH_IMM_HI16_PCREL ¶

: BFD_RELOC_SH_PT_16 ¶

: BFD_RELOC_SH_TLS_GD_32 ¶

: BFD_RELOC_SH_TLS_LD_32 ¶

: BFD_RELOC_SH_TLS_LDO_32 ¶

: BFD_RELOC_SH_TLS_IE_32 ¶

: BFD_RELOC_SH_TLS_LE_32 ¶

: BFD_RELOC_SH_TLS_DTPMOD32 ¶

: BFD_RELOC_SH_TLS_DTPOFF32 ¶

: BFD_RELOC_SH_TLS_TPOFF32 ¶

: BFD_RELOC_SH_GOT20 ¶

: BFD_RELOC_SH_GOTOFF20 ¶

: BFD_RELOC_SH_GOTFUNCDESC ¶

: BFD_RELOC_SH_GOTFUNCDESC20 ¶

: BFD_RELOC_SH_GOTOFFFUNCDESC ¶

: BFD_RELOC_SH_GOTOFFFUNCDESC20 ¶

: BFD_RELOC_SH_FUNCDESC ¶

Renesas / SuperH SH relocs. Not all of these appear in object files.

: BFD_RELOC_ARC_NONE ¶

: BFD_RELOC_ARC_8 ¶

: BFD_RELOC_ARC_16 ¶

: BFD_RELOC_ARC_24 ¶

: BFD_RELOC_ARC_32 ¶

: BFD_RELOC_ARC_N8 ¶

: BFD_RELOC_ARC_N16 ¶

: BFD_RELOC_ARC_N24 ¶

: BFD_RELOC_ARC_N32 ¶

: BFD_RELOC_ARC_SDA ¶

: BFD_RELOC_ARC_SECTOFF ¶

: BFD_RELOC_ARC_S21H_PCREL ¶

: BFD_RELOC_ARC_S21W_PCREL ¶

: BFD_RELOC_ARC_S25H_PCREL ¶

: BFD_RELOC_ARC_S25W_PCREL ¶

: BFD_RELOC_ARC_SDA32 ¶

: BFD_RELOC_ARC_SDA_LDST ¶

: BFD_RELOC_ARC_SDA_LDST1 ¶

: BFD_RELOC_ARC_SDA_LDST2 ¶

: BFD_RELOC_ARC_SDA16_LD ¶

: BFD_RELOC_ARC_SDA16_LD1 ¶

: BFD_RELOC_ARC_SDA16_LD2 ¶

: BFD_RELOC_ARC_S13_PCREL ¶

: BFD_RELOC_ARC_W ¶

: BFD_RELOC_ARC_32_ME ¶

: BFD_RELOC_ARC_32_ME_S ¶

: BFD_RELOC_ARC_N32_ME ¶

: BFD_RELOC_ARC_SECTOFF_ME ¶

: BFD_RELOC_ARC_SDA32_ME ¶

: BFD_RELOC_ARC_W_ME ¶

: BFD_RELOC_AC_SECTOFF_U8 ¶

: BFD_RELOC_AC_SECTOFF_U8_1 ¶

: BFD_RELOC_AC_SECTOFF_U8_2 ¶

: BFD_RELOC_AC_SECTOFF_S9 ¶

: BFD_RELOC_AC_SECTOFF_S9_1 ¶

: BFD_RELOC_AC_SECTOFF_S9_2 ¶

: BFD_RELOC_ARC_SECTOFF_ME_1 ¶

: BFD_RELOC_ARC_SECTOFF_ME_2 ¶

: BFD_RELOC_ARC_SECTOFF_1 ¶

: BFD_RELOC_ARC_SECTOFF_2 ¶

: BFD_RELOC_ARC_SDA_12 ¶

: BFD_RELOC_ARC_SDA16_ST2 ¶

: BFD_RELOC_ARC_32_PCREL ¶

: BFD_RELOC_ARC_PC32 ¶

: BFD_RELOC_ARC_GOT32 ¶

: BFD_RELOC_ARC_GOTPC32 ¶

: BFD_RELOC_ARC_PLT32 ¶

: BFD_RELOC_ARC_COPY ¶

: BFD_RELOC_ARC_GLOB_DAT ¶

: BFD_RELOC_ARC_JMP_SLOT ¶

: BFD_RELOC_ARC_RELATIVE ¶

: BFD_RELOC_ARC_GOTOFF ¶

: BFD_RELOC_ARC_GOTPC ¶

: BFD_RELOC_ARC_S21W_PCREL_PLT ¶

: BFD_RELOC_ARC_S25H_PCREL_PLT ¶

: BFD_RELOC_ARC_TLS_DTPMOD ¶

: BFD_RELOC_ARC_TLS_TPOFF ¶

: BFD_RELOC_ARC_TLS_GD_GOT ¶

: BFD_RELOC_ARC_TLS_GD_LD ¶

: BFD_RELOC_ARC_TLS_GD_CALL ¶

: BFD_RELOC_ARC_TLS_IE_GOT ¶

: BFD_RELOC_ARC_TLS_DTPOFF ¶

: BFD_RELOC_ARC_TLS_DTPOFF_S9 ¶

: BFD_RELOC_ARC_TLS_LE_S9 ¶

: BFD_RELOC_ARC_TLS_LE_32 ¶

: BFD_RELOC_ARC_S25W_PCREL_PLT ¶

: BFD_RELOC_ARC_S21H_PCREL_PLT ¶

: BFD_RELOC_ARC_NPS_CMEM16 ¶

: BFD_RELOC_ARC_JLI_SECTOFF ¶

ARC relocs.

: BFD_RELOC_BFIN_16_IMM ¶

ADI Blackfin 16 bit immediate absolute reloc.

: BFD_RELOC_BFIN_16_HIGH ¶

ADI Blackfin 16 bit immediate absolute reloc higher 16 bits.

: BFD_RELOC_BFIN_4_PCREL ¶

ADI Blackfin ’a’ part of LSETUP.

: BFD_RELOC_BFIN_5_PCREL ¶

ADI Blackfin.