dl-machine.h

Glibc 2.3.2源代码(解压后有100多M)

	      /* The first 32k entries of glink can set an index and
		 branch using two instructions;  Past that point,
		 glink uses three instructions.  */
	      if (i < 0x8000)
          	glink_offset += 2;
	      else
          	glink_offset += 3;
	    }

	  /* Now, we've modified data.  We need to write the changes from
	     the data cache to a second-level unified cache, then make
	     sure that stale data in the instruction cache is removed.
	     (In a multiprocessor system, the effect is more complex.)
	     Most of the PLT shouldn't be in the instruction cache, but
	     there may be a little overlap at the start and the end.

	     Assumes that dcbst and icbi apply to lines of 16 bytes or
	     more.  Current known line sizes are 16, 32, and 128 bytes.  */

	  for (p = (char *) plt; p < (char *) &plt[offset]; p += 16)
	    PPC_DCBST (p);
	  PPC_SYNC;
	}
    }
  return lazy;
}

/* Change the PLT entry whose reloc is 'reloc' to call the actual
   routine.  */
static inline Elf64_Addr
elf_machine_fixup_plt (struct link_map *map, lookup_t sym_map,
		       const Elf64_Rela *reloc,
		       Elf64_Addr *reloc_addr, Elf64_Addr finaladdr)
{
  Elf64_FuncDesc *plt = (Elf64_FuncDesc *) reloc_addr;
  Elf64_FuncDesc *rel = (Elf64_FuncDesc *) finaladdr;
  Elf64_Addr offset = 0;
#ifndef RTLD_BOOTSTRAP
  weak_extern (GL(dl_rtld_map));
#endif

  /* If sym_map is NULL, it's a weak undefined sym;  Leave the plt zero.  */
  if (sym_map == NULL)
    return 0;

  /* If the opd entry is not yet relocated (because it's from a shared
     object that hasn't been processed yet), then manually reloc it.  */
  if (map != sym_map && !sym_map->l_relocated
#ifndef RTLD_BOOTSTRAP
      /* Bootstrap map doesn't have l_relocated set for it.  */
      && sym_map != &GL(dl_rtld_map)
#endif
      )
    offset = sym_map->l_addr;

  /* For PPC64, fixup_plt copies the function descriptor from opd
     over the corresponding PLT entry.
     Initially, PLT Entry[i] is set up for lazy linking, or is zero.
     For lazy linking, the fd_toc and fd_aux entries are irrelevant,
     so for thread safety we write them before changing fd_func.  */

  plt->fd_aux = rel->fd_aux + offset;
  plt->fd_toc = rel->fd_toc + offset;
  PPC_DCBST (&plt->fd_aux);
  PPC_DCBST (&plt->fd_toc);
  PPC_SYNC;

  plt->fd_func = rel->fd_func + offset;
  PPC_DCBST (&plt->fd_func);
  PPC_SYNC;

  return finaladdr;
}

/* Return the final value of a plt relocation.  */
static inline Elf64_Addr
elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
		       Elf64_Addr value)
{
  return value + reloc->r_addend;
}

#endif /* dl_machine_h */

#ifdef RESOLVE_MAP

#define PPC_LO(v) ((v) & 0xffff)
#define PPC_HI(v) (((v) >> 16) & 0xffff)
#define PPC_HA(v) PPC_HI ((v) + 0x8000)
#define PPC_HIGHER(v) (((v) >> 32) & 0xffff)
#define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
#define PPC_HIGHEST(v) (((v) >> 48) & 0xffff)
#define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
#define BIT_INSERT(old, val, mask) ((old & ~(Elf64_Addr) mask) | (val & mask))

#define dont_expect(X) __builtin_expect ((X), 0)

extern void _dl_reloc_overflow (struct link_map *map,
                                const char *name,
                                Elf64_Addr *const reloc_addr,
                                const Elf64_Sym *sym,
                                const Elf64_Sym *refsym)
                                attribute_hidden;

static inline void
elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
			   Elf64_Addr *const reloc_addr)
{
  *reloc_addr = l_addr + reloc->r_addend;
}

/* Perform the relocation specified by RELOC and SYM (which is fully
   resolved).  MAP is the object containing the reloc.  */
static inline void
elf_machine_rela (struct link_map *map,
		  const Elf64_Rela *reloc,
		  const Elf64_Sym *sym,
		  const struct r_found_version *version,
		  Elf64_Addr *const reloc_addr)
{
  int r_type = ELF64_R_TYPE (reloc->r_info);
  struct link_map *sym_map;
  Elf64_Addr value, raw_value;
#ifndef RTLD_BOOTSTRAP
  const Elf64_Sym *const refsym = sym;
#endif

  if (r_type == R_PPC64_RELATIVE)
    {
      *reloc_addr = map->l_addr + reloc->r_addend;
      return;
    }

  if (r_type == R_PPC64_NONE)
    return;

  sym_map = RESOLVE_MAP (&sym, version, r_type);
  value = raw_value = reloc->r_addend;
  if (sym_map)
    {
      raw_value += sym->st_value;
      value = raw_value + sym_map->l_addr;
    }

  switch (r_type)
    {
    case R_PPC64_ADDR64:
    case R_PPC64_GLOB_DAT:
      *reloc_addr = value;
      return;

#if defined USE_TLS && (!defined RTLD_BOOTSTRAP || USE___THREAD)

    case R_PPC64_DTPMOD64:
#ifdef RTLD_BOOTSTRAP
    /* During startup the dynamic linker is always index 1.  */
      *reloc_addr = 1;
#else
    /* Get the information from the link map returned by the
       resolve function.  */
      if (sym_map != NULL)
	*reloc_addr = sym_map->l_tls_modid;
#endif
      return;

    case R_PPC64_TPREL64:
#ifdef RTLD_BOOTSTRAP
      *reloc_addr = (sym_map->l_tls_offset - TLS_TCB_SIZE
		     + raw_value - TLS_TP_OFFSET);
#else
      if (sym_map)
	{
	  CHECK_STATIC_TLS (map, sym_map);
	  *reloc_addr = (sym_map->l_tls_offset - TLS_TCB_SIZE
			 + raw_value - TLS_TP_OFFSET);
	}
#endif
      return;

    case R_PPC64_DTPREL64:
#ifndef RTLD_BOOTSTRAP
      /* During relocation all TLS symbols are defined and used.
	 Therefore the offset is already correct.  */
      *reloc_addr = raw_value - TLS_DTV_OFFSET;
#endif
      return;
#endif

    case R_PPC64_JMP_SLOT:

      elf_machine_fixup_plt (map, sym_map, reloc, reloc_addr, value);
      return;

#ifndef RTLD_BOOTSTRAP /* None of the following appear in ld.so */
    case R_PPC64_ADDR16_LO_DS:
      if (dont_expect ((value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_ADDR16_LO_DS",
                            reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
					       value, 0xfffc);
      break;

    case R_PPC64_TPREL16_LO_DS:
      if (dont_expect ((value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_TPREL16_LO_DS",
                            reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_DTPREL16_LO_DS:
      if (dont_expect ((value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_DTPREL16_LO_DS",
                            reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_GOT_TPREL16_LO_DS:
      if (dont_expect ((value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_GOT_TPREL16_LO_DS",
                            reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_GOT_DTPREL16_LO_DS:
      if (dont_expect ((value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_GOT_DTPREL16_LO_DS",
                            reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_ADDR16_LO:
    case R_PPC64_TPREL16_LO:
    case R_PPC64_DTPREL16_LO:
    case R_PPC64_GOT_TLSGD16_LO:
    case R_PPC64_GOT_TLSLD16_LO:
      *(Elf64_Half *) reloc_addr = PPC_LO (value);
      break;

    case R_PPC64_ADDR16_HI:
    case R_PPC64_TPREL16_HI:
    case R_PPC64_DTPREL16_HI:
    case R_PPC64_GOT_TPREL16_HI:
    case R_PPC64_GOT_DTPREL16_HI:
    case R_PPC64_GOT_TLSGD16_HI:
    case R_PPC64_GOT_TLSLD16_HI:
      *(Elf64_Half *) reloc_addr = PPC_HI (value);
      break;

    case R_PPC64_ADDR16_HA:
    case R_PPC64_TPREL16_HA:
    case R_PPC64_DTPREL16_HA:
    case R_PPC64_GOT_TLSGD16_HA:
    case R_PPC64_GOT_TLSLD16_HA:
      *(Elf64_Half *) reloc_addr = PPC_HA (value);
      break;

    case R_PPC64_REL24:
      {
        Elf64_Addr delta = value - (Elf64_Xword) reloc_addr;
        if (dont_expect ((delta + 0x2000000) >= 0x4000000 || (delta & 3) != 0))
          _dl_reloc_overflow (map, "R_PPC64_REL24", reloc_addr, sym, refsym);
        *(Elf64_Word *) reloc_addr = BIT_INSERT (*(Elf64_Word *) reloc_addr,
                                                delta, 0x3fffffc);
      }
      break;

    case R_PPC64_COPY:
      if (dont_expect (sym == NULL))
      /* This can happen in trace mode when an object could not be found. */
        return;
      if (dont_expect (sym->st_size > refsym->st_size
        || (GL(dl_verbose) && sym->st_size < refsym->st_size)))
	      {
          const char *strtab;

          strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
          _dl_error_printf ("%s: Symbol `%s' has different size" \
                            " in shared object," \
                            " consider re-linking\n",
                            _dl_argv[0] ?: "<program name unknown>",
                              strtab + refsym->st_name);
	      }
      memcpy (reloc_addr, (char *) value, MIN (sym->st_size, refsym->st_size));
      return;

    case R_PPC64_UADDR64:
      /* We are big-endian.  */
      ((char *) reloc_addr)[0] = (value >> 56) & 0xff;
      ((char *) reloc_addr)[1] = (value >> 48) & 0xff;
      ((char *) reloc_addr)[2] = (value >> 40) & 0xff;
      ((char *) reloc_addr)[3] = (value >> 32) & 0xff;
      ((char *) reloc_addr)[4] = (value >> 24) & 0xff;
      ((char *) reloc_addr)[5] = (value >> 16) & 0xff;
      ((char *) reloc_addr)[6] = (value >> 8) & 0xff;
      ((char *) reloc_addr)[7] = (value >> 0) & 0xff;
      return;

    case R_PPC64_UADDR32:
      /* We are big-endian.  */
      ((char *) reloc_addr)[0] = (value >> 24) & 0xff;
      ((char *) reloc_addr)[1] = (value >> 16) & 0xff;
      ((char *) reloc_addr)[2] = (value >> 8) & 0xff;
      ((char *) reloc_addr)[3] = (value >> 0) & 0xff;
      return;

    case R_PPC64_ADDR24:
      if (dont_expect ((value + 0x2000000) >= 0x4000000 || (value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_ADDR24", reloc_addr, sym, refsym);
      *(Elf64_Word *) reloc_addr = BIT_INSERT (*(Elf64_Word *) reloc_addr,
					       value, 0x3fffffc);
      break;

    case R_PPC64_ADDR16:
      if (dont_expect ((value + 0x8000) >= 0x10000))
        _dl_reloc_overflow (map, "R_PPC64_ADDR16", reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = value;
      break;

    case R_PPC64_UADDR16:
      if (dont_expect ((value + 0x8000) >= 0x10000))
        _dl_reloc_overflow (map, "R_PPC64_UADDR16", reloc_addr, sym, refsym);
      /* We are big-endian.  */
      ((char *) reloc_addr)[0] = (value >> 8) & 0xff;
      ((char *) reloc_addr)[1] = (value >> 0) & 0xff;
      break;

    case R_PPC64_ADDR16_DS:
      if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_ADDR16_DS", reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
					       value, 0xfffc);
      break;

    case R_PPC64_TPREL16_DS:
      if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_TPREL16_DS", reloc_addr,
                            sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_DTPREL16_DS:
      if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_DTPREL16_DS", reloc_addr,
                            sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_GOT_TPREL16_DS:
      if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_GOT_TPREL16_DS", reloc_addr,
                            sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_GOT_DTPREL16_DS:
      if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
        _dl_reloc_overflow (map, "R_PPC64_GOT_DTPREL16_DS",
                            reloc_addr, sym, refsym);
      *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
                                              value, 0xfffc);
      break;

    case R_PPC64_ADDR16_HIGHER:
    case R_PPC64_TPREL16_HIGHER:
    case R_PPC64_DTPREL16_HIGHER:
      *(Elf64_Half *) reloc_addr = PPC_HIGHER (value);
      break;

    case R_PPC64_ADDR16_HIGHEST:
    case R_PPC64_TPREL16_HIGHEST:
    case R_PPC64_DTPREL16_HIGHEST:
      *(Elf64_Half *) reloc_addr = PPC_HIGHEST (value);
      break;

    case R_PPC64_ADDR16_HIGHERA:
    case R_PPC64_TPREL16_HIGHERA:
    case R_PPC64_DTPREL16_HIGHERA:
      *(Elf64_Half *) reloc_addr = PPC_HIGHERA (value);
      break;

    case R_PPC64_ADDR16_HIGHESTA:
    case R_PPC64_TPREL16_HIGHESTA:
    case R_PPC64_DTPREL16_HIGHESTA:
      *(Elf64_Half *) reloc_addr = PPC_HIGHESTA (value);
      break;

    case R_PPC64_ADDR14:
    case R_PPC64_ADDR14_BRTAKEN:
    case R_PPC64_ADDR14_BRNTAKEN:
      {
        Elf64_Word insn;
        if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
	        _dl_reloc_overflow (map, "R_PPC64_ADDR14", reloc_addr, sym, refsym);
        insn = BIT_INSERT (*(Elf64_Word *) reloc_addr, value, 0xfffc);
        if (r_type != R_PPC64_ADDR14)
	        {
	          insn &= ~(1 << 21);
	          if (r_type == R_PPC64_ADDR14_BRTAKEN)
	            insn |= 1 << 21;
	          if ((insn & (0x14 << 21)) == (0x04 << 21))
	            insn |= 0x02 << 21;
	          else if ((insn & (0x14 << 21)) == (0x10 << 21))
	            insn |= 0x08 << 21;
	        }
        *(Elf64_Word *) reloc_addr = insn;
      }
      break;

    case R_PPC64_REL32:
      *(Elf64_Word *) reloc_addr = value - (Elf64_Xword) reloc_addr;
      return;
#endif /* !RTLD_BOOTSTRAP */

    default:
      _dl_reloc_bad_type (map, r_type, 0);
      return;
    }
  MODIFIED_CODE_NOQUEUE (reloc_addr);
}

static inline void
elf_machine_lazy_rel (struct link_map *map,
		      Elf64_Addr l_addr, const Elf64_Rela *reloc)
{
  /* elf_machine_runtime_setup handles this.  */
}

#endif /* RESOLVE */