LXR 6.1/​cpukit/​libdl/​rtl-mdreloc-v850.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:16

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  *  @file
  *
  *  @ingroup
  *
  *  @brief
  */
 
 /*
  * Copyright (C) 2014 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.
  */
 
 
 #include <sys/cdefs.h>
 
 #include <errno.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
 #include <rtems/rtl/rtl.h>
 #include "rtl-elf.h"
 #include "rtl-error.h"
 #include <rtems/rtl/rtl-trace.h>
 #include "rtl-unwind.h"
 #include "rtl-unwind-dw2.h"
 
 uint32_t
 rtems_rtl_elf_section_flags (const rtems_rtl_obj* obj,
                              const Elf_Shdr*      shdr)
 {
   return 0;
 }
 
 uint32_t
 rtems_rtl_elf_arch_parse_section (const rtems_rtl_obj* obj,
                                   int                  section,
                                   const char*          name,
                                   const Elf_Shdr*      shdr,
                                   const uint32_t       flags)
 {
   (void) obj;
   (void) section;
   (void) name;
   (void) shdr;
   return flags;
 }
 
 bool
 rtems_rtl_elf_arch_section_alloc (const rtems_rtl_obj* obj,
                                   rtems_rtl_obj_sect*  sect)
 {
   (void) obj;
   (void) sect;
   return false;
 }
 
 bool
 rtems_rtl_elf_arch_section_free (const rtems_rtl_obj* obj,
                                   rtems_rtl_obj_sect*  sect)
 {
   (void) obj;
   (void) sect;
   return false;
 }
 
 bool
 rtems_rtl_elf_rel_resolve_sym (Elf_Word type)
 {
   return true;
 }
 
 uint32_t rtems_rtl_obj_tramp_alignment (const rtems_rtl_obj* obj)
 {
   (void) obj;
   return sizeof(uint32_t);
 }
 
 size_t
 rtems_rtl_elf_relocate_tramp_max_size (void)
 {
   /*
    * Disable by returning 0.
    */
   return 0;
 }
 
 rtems_rtl_elf_rel_status
 rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
                                    const Elf_Rela*           rela,
                                    const rtems_rtl_obj_sect* sect,
                                    const char*               symname,
                                    const Elf_Byte            syminfo,
                                    const Elf_Word            symvalue)
 {
   (void) obj;
   (void) rela;
   (void) sect;
   (void) symname;
   (void) syminfo;
   (void) symvalue;
   return rtems_rtl_elf_rel_no_error;
 }
 
 rtems_rtl_elf_rel_status
 rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
                              const Elf_Rela*           rela,
                              const rtems_rtl_obj_sect* sect,
                              const char*               symname,
                              const Elf_Byte            syminfo,
                              const Elf_Word            symvalue)
 {
   Elf_Addr *where;
   Elf_Word tmp;
 
   where = (Elf_Addr *)(sect->base + rela->r_offset);
 
   if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC)) {
       printf("rela relocation type is %ld\n", ELF_R_TYPE(rela->r_info));
       printf("relocated address 0x%08lx\n", (Elf_Addr)where);
   }
 
   switch (ELF_R_TYPE(rela->r_info)) {
     case R_TYPE(NONE):
       break;
 
     case R_TYPE(HI16_S):
       tmp = (Elf_Sword)(symvalue + rela->r_addend) >> 16;
       ((uint16_t *)where)[0] = tmp & 0xffff;
       break;
 
     case R_TYPE(LO16):
       tmp = symvalue + rela->r_addend;
       ((uint16_t *)where)[0] = tmp & 0xffff;
       break;
 
     case R_TYPE(LO16_S1):
       tmp = symvalue + rela->r_addend;
       ((uint16_t *)where)[0] = tmp & 0xfffe | 0x1;
       break;
 
     case R_TYPE(22_PCREL):
       tmp =  symvalue + rela->r_addend - (Elf_Addr)where;
       if (((Elf_Sword)tmp > 0x1fffff) || ((Elf_Sword)tmp < -0x200000)) {
         printf("Overflow\n");
         return rtems_rtl_elf_rel_failure;
       }
 
       ((uint16_t *)where)[0] = (*(uint16_t *)where & 0xffc0) |
         ((tmp >> 16) & 0x3f);
       ((uint16_t *)where)[1] = (tmp & 0xfffe);
 
       break;
 
     case R_TYPE(ABS32):
       tmp = symvalue + rela->r_addend;
       tmp += ((uint16_t *)where)[0];
       tmp += ((uint16_t *)where)[1] << 16;
       ((uint16_t *)where)[0] = tmp & 0xffff;
       ((uint16_t *)where)[1] = (tmp >> 16) & 0xffff;
       break;
 
     default:
       rtems_rtl_set_error (EINVAL, "rela type record not supported");
       printf("error reloc type\n");
       return rtems_rtl_elf_rel_failure;
   }
 
   return rtems_rtl_elf_rel_no_error;
 }
 
 rtems_rtl_elf_rel_status
 rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
                                   const Elf_Rel*            rel,
                                   const rtems_rtl_obj_sect* sect,
                                   const char*               symname,
                                   const Elf_Byte            syminfo,
                                   const Elf_Word            symvalue)
 {
   (void) obj;
   (void) rel;
   (void) sect;
   (void) symname;
   (void) syminfo;
   (void) symvalue;
   rtems_rtl_set_error (EINVAL, "rel type record not supported");
   return rtems_rtl_elf_rel_failure;
 }
 
 rtems_rtl_elf_rel_status
 rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
                             const Elf_Rel*            rel,
                             const rtems_rtl_obj_sect* sect,
                             const char*               symname,
                             const Elf_Byte            syminfo,
                             const Elf_Word            symvalue)
 {
   (void) obj;
   (void) rel;
   (void) sect;
   (void) symname;
   (void) syminfo;
   (void) symvalue;
   rtems_rtl_set_error (EINVAL, "rel type record not supported");
   return rtems_rtl_elf_rel_failure;
 }
 
 bool
 rtems_rtl_elf_unwind_parse (const rtems_rtl_obj* obj,
                             const char*          name,
                             uint32_t             flags)
 {
   return rtems_rtl_elf_unwind_dw2_parse (obj, name, flags);
 }
 
 bool
 rtems_rtl_elf_unwind_register (rtems_rtl_obj* obj)
 {
   return rtems_rtl_elf_unwind_dw2_register (obj);
 }
 
 bool
 rtems_rtl_elf_unwind_deregister (rtems_rtl_obj* obj)
 {
   return rtems_rtl_elf_unwind_dw2_deregister (obj);
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team