arch/x86/lib/relocate.c

   1 /*
   2  * (C) Copyright 2008-2011
   3  * Graeme Russ, <graeme.russ@gmail.com>
   4  *
   5  * (C) Copyright 2002
   6  * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
   7  *
   8  * (C) Copyright 2002
   9  * Wolfgang Denk, DENX Software Engineering, <wd@denx.de>
  10  *
  11  * (C) Copyright 2002
  12  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
  13  * Marius Groeger <mgroeger@sysgo.de>
  14  *
  15  * SPDX-License-Identifier:     GPL-2.0+
  16  */
  17
  18 #include <common.h>
  19 #include <inttypes.h>
  20 #include <asm/u-boot-x86.h>
  21 #include <asm/relocate.h>
  22 #include <asm/sections.h>
  23 #include <elf.h>
  24
  25 DECLARE_GLOBAL_DATA_PTR;
  26
  27 int copy_uboot_to_ram(void)
  28 {
  29         size_t len = (uintptr_t)&__data_end - (uintptr_t)&__text_start;
  30
  31         if (gd->flags & GD_FLG_SKIP_RELOC)
  32                 return 0;
  33         memcpy((void *)gd->relocaddr, (void *)&__text_start, len);
  34
  35         return 0;
  36 }
  37
  38 int clear_bss(void)
  39 {
  40         ulong dst_addr = (ulong)&__bss_start + gd->reloc_off;
  41         size_t len = (uintptr_t)&__bss_end - (uintptr_t)&__bss_start;
  42
  43         if (gd->flags & GD_FLG_SKIP_RELOC)
  44                 return 0;
  45         memset((void *)dst_addr, 0x00, len);
  46
  47         return 0;
  48 }
  49
  50 #if CONFIG_IS_ENABLED(X86_64)
  51 static void do_elf_reloc_fixups64(unsigned int text_base, uintptr_t size,
  52                                   Elf64_Rela *re_src, Elf64_Rela *re_end)
  53 {
  54         Elf64_Addr *offset_ptr_rom, *last_offset = NULL;
  55         Elf64_Addr *offset_ptr_ram;
  56
  57         do {
  58                 /* Get the location from the relocation entry */
  59                 offset_ptr_rom = (Elf64_Addr *)(uintptr_t)re_src->r_offset;
  60
  61                 /* Check that the location of the relocation is in .text */
  62                 if (offset_ptr_rom >= (Elf64_Addr *)(uintptr_t)text_base &&
  63                     offset_ptr_rom > last_offset) {
  64                         /* Switch to the in-RAM version */
  65                         offset_ptr_ram = (Elf64_Addr *)((ulong)offset_ptr_rom +
  66                                                         gd->reloc_off);
  67
  68                         /* Check that the target points into .text */
  69                         if (*offset_ptr_ram >= text_base &&
  70                             *offset_ptr_ram <= text_base + size) {
  71                                 *offset_ptr_ram = gd->reloc_off +
  72                                                         re_src->r_addend;
  73                         } else {
  74                                 debug("   %p: %lx: rom reloc %lx, ram %p, value %lx, limit %"
  75                                       PRIXPTR "\n",
  76                                       re_src, (ulong)re_src->r_info,
  77                                       (ulong)re_src->r_offset, offset_ptr_ram,
  78                                       (ulong)*offset_ptr_ram, text_base + size);
  79                         }
  80                 } else {
  81                         debug("   %p: %lx: rom reloc %lx, last %p\n", re_src,
  82                               (ulong)re_src->r_info, (ulong)re_src->r_offset,
  83                               last_offset);
  84                 }
  85                 last_offset = offset_ptr_rom;
  86
  87         } while (++re_src < re_end);
  88 }
  89 #else
  90 static void do_elf_reloc_fixups32(unsigned int text_base, uintptr_t size,
  91                                   Elf32_Rel *re_src, Elf32_Rel *re_end)
  92 {
  93         Elf32_Addr *offset_ptr_rom, *last_offset = NULL;
  94         Elf32_Addr *offset_ptr_ram;
  95
  96         do {
  97                 /* Get the location from the relocation entry */
  98                 offset_ptr_rom = (Elf32_Addr *)(uintptr_t)re_src->r_offset;
  99
 100                 /* Check that the location of the relocation is in .text */
 101                 if (offset_ptr_rom >= (Elf32_Addr *)(uintptr_t)text_base &&
 102                     offset_ptr_rom > last_offset) {
 103
 104                         /* Switch to the in-RAM version */
 105                         offset_ptr_ram = (Elf32_Addr *)((ulong)offset_ptr_rom +
 106                                                         gd->reloc_off);
 107
 108                         /* Check that the target points into .text */
 109                         if (*offset_ptr_ram >= text_base &&
 110                             *offset_ptr_ram <= text_base + size) {
 111                                 *offset_ptr_ram += gd->reloc_off;
 112                         } else {
 113                                 debug("   %p: rom reloc %x, ram %p, value %x,"
 114                                         " limit %" PRIXPTR "\n", re_src,
 115                                         re_src->r_offset, offset_ptr_ram,
 116                                         *offset_ptr_ram,
 117                                         text_base + size);
 118                         }
 119                 } else {
 120                         debug("   %p: rom reloc %x, last %p\n", re_src,
 121                                re_src->r_offset, last_offset);
 122                 }
 123                 last_offset = offset_ptr_rom;
 124
 125         } while (++re_src < re_end);
 126 }
 127 #endif
 128
 129 /*
 130  * This function has more error checking than you might expect. Please see
 131  * this commit message for more information:
 132  *    62f7970a x86: Add error checking to x86 relocation code
 133  */
 134 int do_elf_reloc_fixups(void)
 135 {
 136         void *re_src = (void *)(&__rel_dyn_start);
 137         void *re_end = (void *)(&__rel_dyn_end);
 138         uint text_base;
 139
 140         /* The size of the region of u-boot that runs out of RAM. */
 141         uintptr_t size = (uintptr_t)&__bss_end - (uintptr_t)&__text_start;
 142
 143         if (gd->flags & GD_FLG_SKIP_RELOC)
 144                 return 0;
 145         if (re_src == re_end)
 146                 panic("No relocation data");
 147
 148 #ifdef CONFIG_SYS_TEXT_BASE
 149         text_base = CONFIG_SYS_TEXT_BASE;
 150 #else
 151         panic("No CONFIG_SYS_TEXT_BASE");
 152 #endif
 153 #if CONFIG_IS_ENABLED(X86_64)
 154         do_elf_reloc_fixups64(text_base, size, re_src, re_end);
 155 #else
 156         do_elf_reloc_fixups32(text_base, size, re_src, re_end);
 157 #endif
 158
 159         return 0;
 160 }