rtl-obj.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-2-Clause */
 
/*
 *  COPYRIGHT (c) 2012,2019 Chris Johns <chrisj@rtems.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#if !defined (_RTEMS_RTL_OBJ_H_)
#define _RTEMS_RTL_OBJ_H_
 
#include <rtems.h>
#include <rtems/chain.h>
#include <rtems/rtl/rtl-sym.h>
#include <rtems/rtl/rtl-unresolved.h>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#define RTEMS_RTL_FMT_ELF     (1 << 0)
#define RTEMS_RTL_FMT_COMP    (1 << 1)
#define RTEMS_RTL_FMT_PRIVATE (1 << 16)
 
typedef struct rtems_rtl_loader_format
{
  const char* label;
 
  uint32_t flags;
} rtems_rtl_loader_format;
 
typedef bool (*rtems_rtl_loader_check) (rtems_rtl_obj* obj, int fd);
 
typedef bool (*rtems_rtl_loader_load) (rtems_rtl_obj* obj, int fd);
 
typedef bool (*rtems_rtl_loader_unload) (rtems_rtl_obj* obj);
 
typedef rtems_rtl_loader_format* (*rtems_rtl_loader_sig) (void);
 
typedef struct rtems_rtl_loader_table
{
  rtems_rtl_loader_check  check;     
  rtems_rtl_loader_load   load;      
  rtems_rtl_loader_unload unload;    
  rtems_rtl_loader_sig    signature; 
} rtems_rtl_loader_table;
 
#define RTEMS_RTL_OBJ_SECT_TEXT       (1 << 0)  
#define RTEMS_RTL_OBJ_SECT_CONST      (1 << 1)  
#define RTEMS_RTL_OBJ_SECT_DATA       (1 << 2)  
#define RTEMS_RTL_OBJ_SECT_BSS        (1 << 3)  
#define RTEMS_RTL_OBJ_SECT_EH         (1 << 4)  
#define RTEMS_RTL_OBJ_SECT_TLS        (1 << 5)  
#define RTEMS_RTL_OBJ_SECT_REL        (1 << 6)  
#define RTEMS_RTL_OBJ_SECT_RELA       (1 << 7)  
#define RTEMS_RTL_OBJ_SECT_SYM        (1 << 8)  
#define RTEMS_RTL_OBJ_SECT_STR        (1 << 9)  
#define RTEMS_RTL_OBJ_SECT_ALLOC      (1 << 10  
#define RTEMS_RTL_OBJ_SECT_LOAD       (1 << 11) 
#define RTEMS_RTL_OBJ_SECT_WRITE      (1 << 12) 
#define RTEMS_RTL_OBJ_SECT_EXEC       (1 << 13) 
#define RTEMS_RTL_OBJ_SECT_ZERO       (1 << 14) 
#define RTEMS_RTL_OBJ_SECT_LINK       (1 << 15) 
#define RTEMS_RTL_OBJ_SECT_CTOR       (1 << 16) 
#define RTEMS_RTL_OBJ_SECT_DTOR       (1 << 17) 
#define RTEMS_RTL_OBJ_SECT_LOCD       (1 << 18) 
#define RTEMS_RTL_OBJ_SECT_ARCH_ALLOC (1 << 19) 
#define RTEMS_RTL_OBJ_SECT_TYPES (RTEMS_RTL_OBJ_SECT_TEXT | \
                                  RTEMS_RTL_OBJ_SECT_CONST | \
                                  RTEMS_RTL_OBJ_SECT_DATA | \
                                  RTEMS_RTL_OBJ_SECT_BSS | \
                                  RTEMS_RTL_OBJ_SECT_TLS | \
                                  RTEMS_RTL_OBJ_SECT_EH)
 
struct rtems_rtl_obj_sect
{
  rtems_chain_node node;        
  int              section;     
  const char*      name;        
  size_t           size;        
  off_t            offset;      
  uint32_t         alignment;   
  int              link;        
  int              info;        
  uint32_t         flags;       
  void*            base;        
  int              load_order;  
};
 
struct rtems_rtl_obj_depends
{
  rtems_chain_node node;        
  size_t           dependents;  
  rtems_rtl_obj*   depends[];   
};
 
typedef bool (*rtems_rtl_obj_depends_iterator) (rtems_rtl_obj* obj,
                                                rtems_rtl_obj* dependent,
                                                void*          data);
 
#define RTEMS_RTL_OBJ_LOCKED       (1 << 0) 
#define RTEMS_RTL_OBJ_UNRESOLVED   (1 << 1) 
#define RTEMS_RTL_OBJ_BASE         (1 << 2) 
#define RTEMS_RTL_OBJ_RELOC_TAG    (1 << 3) 
#define RTEMS_RTL_OBJ_DEP_VISITED  (1 << 4) 
#define RTEMS_RTL_OBJ_CTOR_RUN     (1 << 5) 
struct rtems_rtl_obj
{
  rtems_chain_node    link;            
  uint32_t            flags;           
  size_t              users;           
  size_t              refs;            
  int                 format;          
  const char*         fname;           
  const char*         oname;           
  const char*         aname;           
  off_t               ooffset;         
  size_t              fsize;           
  rtems_chain_control sections;        
  rtems_chain_control dependents;      
  rtems_rtl_obj_sym*  local_table;     
  size_t              local_syms;      
  size_t              local_size;      
  rtems_rtl_obj_sym*  global_table;    
  size_t              global_syms;     
  size_t              global_size;     
  size_t              unresolved;      
  void*               text_base;       
  size_t              text_size;       
  void*               const_base;      
  size_t              const_size;      
  void*               eh_base;         
  size_t              eh_size;         
  void*               data_base;       
  size_t              data_size;       
  void*               bss_base;        
  size_t              bss_size;        
  size_t              exec_size;       
  void*               entry;           
  uint32_t            checksum;        
  uint32_t*           sec_num;         
  uint32_t            obj_num;         
  void*               tramp_base;      
  size_t              tramp_size;      
  size_t              tramp_slots;     
  size_t              tramp_slot_size; 
  void*               tramp_brk;       
  size_t              tramp_relocs;    
  struct link_map*    linkmap;         
  void*               loader;          
};
 
typedef bool (*rtems_rtl_obj_sect_handler)(rtems_rtl_obj*      obj,
                                           int                 fd,
                                           rtems_rtl_obj_sect* sect,
                                           void*               data);
 
static inline const char* rtems_rtl_obj_fname (const rtems_rtl_obj* obj)
{
  return obj->fname;
}
 
static inline bool rtems_rtl_obj_fname_valid (const rtems_rtl_obj* obj)
{
  return obj->fname;
}
 
static inline const char* rtems_rtl_obj_oname (const rtems_rtl_obj* obj)
{
  return obj->oname;
}
 
static inline bool rtems_rtl_obj_oname_valid (const rtems_rtl_obj* obj)
{
  return obj->oname;
}
 
static inline const char* rtems_rtl_obj_aname (const rtems_rtl_obj* obj)
{
  return obj->aname;
}
 
static inline bool rtems_rtl_obj_aname_valid (const rtems_rtl_obj* obj)
{
  return obj->aname;
}
 
static inline bool rtems_rtl_obj_text_inside (const rtems_rtl_obj* obj,
                                              const void*          address)
{
  return
    (address >= obj->text_base) &&
    ((char*) address < ((char*) obj->text_base + obj->text_size));
}
 
static inline size_t rtems_rtl_obj_align (size_t   offset,
                                          uint32_t alignment)
{
  if ((alignment > 1) && ((offset & (alignment - 1)) != 0))
    offset = (offset + alignment) & ~(alignment - 1);
  return offset;
}
 
static inline bool rtems_rtl_obj_has_symbol (const rtems_rtl_obj*     obj,
                                             const rtems_rtl_obj_sym* sym)
{
  return (sym >= obj->global_table &&
          sym < (obj->global_table + obj->global_syms));
}
 
static inline size_t rtems_rtl_obj_has_trampolines (const rtems_rtl_obj* obj)
{
  return obj->tramp_slot_size != 0 && obj->tramp_slots != 0;
}
 
static inline size_t rtems_rtl_obj_tramp_avail_space (const rtems_rtl_obj* obj)
{
  return (char*) obj->tramp_brk - (char*) obj->tramp_base;
}
 
static inline bool rtems_rtl_obj_has_tramp_space (const rtems_rtl_obj* obj,
                                                  const size_t         size)
{
  return (obj->tramp_base != NULL &&
          (rtems_rtl_obj_tramp_avail_space (obj) + size) <= obj->tramp_size);
}
 
static inline size_t rtems_rtl_obj_trampoline_slots (const rtems_rtl_obj* obj)
{
  return obj->tramp_slots;
}
 
static inline size_t rtems_rtl_obj_trampolines (const rtems_rtl_obj* obj)
{
  return obj->tramp_base == NULL || obj->tramp_slots == 0 ?
    0 : rtems_rtl_obj_tramp_avail_space (obj) / obj->tramp_slot_size;
}
 
static inline bool rtems_rtl_obj_sect_is_arch_alloc (rtems_rtl_obj_sect* sect)
{
  return (sect->flags & RTEMS_RTL_OBJ_SECT_ARCH_ALLOC) != 0;
}
 
rtems_rtl_obj* rtems_rtl_obj_alloc (void);
 
bool rtems_rtl_obj_free (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_unresolved (rtems_rtl_obj* obj);
 
bool rtems_rtl_parse_name (const char*  name,
                           const char** aname,
                           const char** oname,
                           off_t*       ooffset);
 
bool rtems_rtl_obj_find_file (rtems_rtl_obj* obj, const char* name);
 
bool rtems_rtl_obj_add_section (rtems_rtl_obj* obj,
                                int            section,
                                const char*    name,
                                size_t         size,
                                off_t          offset,
                                uint32_t       alignment,
                                int            link,
                                int            info,
                                uint32_t       flags);
 
void rtems_rtl_obj_erase_sections (rtems_rtl_obj* obj);
 
rtems_rtl_obj_sect* rtems_rtl_obj_find_section (const rtems_rtl_obj* obj,
                                                const char*          name);
 
rtems_rtl_obj_sect* rtems_rtl_obj_find_section_by_index (const rtems_rtl_obj* obj,
                                                         int                  index);
 
rtems_rtl_obj_sect* rtems_rtl_obj_find_section_by_mask (const rtems_rtl_obj* obj,
                                                        int                  index,
                                                        uint32_t             mask);
 
bool rtems_rtl_obj_alloc_dependents (rtems_rtl_obj* obj, size_t dependents);
 
void rtems_rtl_obj_erase_dependents (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_add_dependent (rtems_rtl_obj* obj, rtems_rtl_obj* dependent);
 
bool rtems_rtl_obj_remove_dependencies (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_iterate_dependents (rtems_rtl_obj*                 obj,
                                       rtems_rtl_obj_depends_iterator iterator,
                                       void*                          data);
 
size_t rtems_rtl_obj_text_size (const rtems_rtl_obj* obj);
 
uint32_t rtems_rtl_obj_text_alignment (const rtems_rtl_obj* obj);
 
size_t rtems_rtl_obj_const_size (const rtems_rtl_obj* obj);
 
uint32_t rtems_rtl_obj_const_alignment (const rtems_rtl_obj* obj);
 
size_t rtems_rtl_obj_eh_size (const rtems_rtl_obj* obj);
 
uint32_t rtems_rtl_obj_eh_alignment (const rtems_rtl_obj* obj);
 
size_t rtems_rtl_obj_data_size (const rtems_rtl_obj* obj);
 
uint32_t rtems_rtl_obj_data_alignment (const rtems_rtl_obj* obj);
 
size_t rtems_rtl_obj_bss_size (const rtems_rtl_obj* obj);
 
uint32_t rtems_rtl_obj_bss_alignment (const rtems_rtl_obj* obj);
 
size_t rtems_rtl_obj_tramp_size (const rtems_rtl_obj* obj);
 
uint32_t rtems_rtl_obj_tramp_alignment (const rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_relocate (rtems_rtl_obj*             obj,
                             int                        fd,
                             rtems_rtl_obj_sect_handler handler,
                             void*                      data);
 
void rtems_rtl_obj_synchronize_cache (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_relocate_unresolved (rtems_rtl_unresolv_reloc* reloc,
                                        rtems_rtl_obj_sym*        sym);
 
bool rtems_rtl_obj_load_symbols (rtems_rtl_obj*             obj,
                                 int                        fd,
                                 rtems_rtl_obj_sect_handler handler,
                                 void*                      data);
 
bool rtems_rtl_obj_alloc_sections (rtems_rtl_obj*             obj,
                                   int                        fd,
                                   rtems_rtl_obj_sect_handler handler,
                                   void*                      data);
 
bool rtems_rtl_obj_resize_sections (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_load_sections (rtems_rtl_obj*             obj,
                                  int                        fd,
                                  rtems_rtl_obj_sect_handler handler,
                                  void*                      data);
 
bool rtems_rtl_obj_ctors_to_run (rtems_rtl_obj* obj);
 
void rtems_rtl_obj_run_ctors (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_dtors_to_run (rtems_rtl_obj* obj);
 
void rtems_rtl_obj_run_dtors (rtems_rtl_obj* obj);
 
size_t rtems_rtl_obj_get_reference (rtems_rtl_obj* obj);
 
void rtems_rtl_obj_inc_reference (rtems_rtl_obj* obj);
 
void rtems_rtl_obj_dec_reference (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_orphaned (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_load (rtems_rtl_obj* obj);
 
bool rtems_rtl_obj_unload (rtems_rtl_obj* obj);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif