自学教程：C++ ELF_R_TYPE函数代码示例

static void check_rela(Elf_Rela *rela, struct module *me){	struct mod_arch_syminfo *info;	info = me->arch.syminfo + ELF_R_SYM (rela->r_info);	switch (ELF_R_TYPE (rela->r_info)) {	case R_390_GOT12:	/* 12 bit GOT offset.  */	case R_390_GOT16:	/* 16 bit GOT offset.  */	case R_390_GOT20:	/* 20 bit GOT offset.  */	case R_390_GOT32:	/* 32 bit GOT offset.  */	case R_390_GOT64:	/* 64 bit GOT offset.  */	case R_390_GOTENT:	/* 32 bit PC rel. to GOT entry shifted by 1. */	case R_390_GOTPLT12:	/* 12 bit offset to jump slot.	*/	case R_390_GOTPLT16:	/* 16 bit offset to jump slot.  */	case R_390_GOTPLT20:	/* 20 bit offset to jump slot.  */	case R_390_GOTPLT32:	/* 32 bit offset to jump slot.  */	case R_390_GOTPLT64:	/* 64 bit offset to jump slot.	*/	case R_390_GOTPLTENT:	/* 32 bit rel. offset to jump slot >> 1. */		if (info->got_offset == -1UL) {			info->got_offset = me->arch.got_size;			me->arch.got_size += sizeof(void*);		}		break;	case R_390_PLT16DBL:	/* 16 bit PC rel. PLT shifted by 1.  */	case R_390_PLT32DBL:	/* 32 bit PC rel. PLT shifted by 1.  */	case R_390_PLT32:	/* 32 bit PC relative PLT address.  */	case R_390_PLT64:	/* 64 bit PC relative PLT address.  */	case R_390_PLTOFF16:	/* 16 bit offset from GOT to PLT. */	case R_390_PLTOFF32:	/* 32 bit offset from GOT to PLT. */	case R_390_PLTOFF64:	/* 16 bit offset from GOT to PLT. */		if (info->plt_offset == -1UL) {			info->plt_offset = me->arch.plt_size;			me->arch.plt_size += PLT_ENTRY_SIZE;		}		break;	case R_390_COPY:	case R_390_GLOB_DAT:	case R_390_JMP_SLOT:	case R_390_RELATIVE:		/* Only needed if we want to support loading of 		   modules linked with -shared. */		break;	}}

int_rtld_relocate_plt_lazy(const Obj_Entry *obj){    if (!obj->relocbase)        return 0;    for (const Elf_Rel *rel = obj->pltrel; rel < obj->pltrellim; rel++) {        Elf_Addr *where = (Elf_Addr *)(obj->relocbase + rel->r_offset);        assert(ELF_R_TYPE(rel->r_info) == R_TYPE(JUMP_SLOT));        /* Just relocate the GOT slots pointing into the PLT */        *where += (Elf_Addr)obj->relocbase;        rdbg(("fixup !main in %s --> %p", obj->path, (void *)*where));    }    return 0;}

/* *  * Process the PLT relocations. *   */intreloc_plt(Obj_Entry *obj){	const Elf_Rel *rellim;	const Elf_Rel *rel;			rellim = (const Elf_Rel *)((char *)obj->pltrel +	    obj->pltrelsize);	for (rel = obj->pltrel;  rel < rellim;  rel++) {		Elf_Addr *where;		assert(ELF_R_TYPE(rel->r_info) == R_ARM_JUMP_SLOT);				where = (Elf_Addr *)(obj->relocbase + rel->r_offset);		*where += (Elf_Addr )obj->relocbase;	}		return (0);}

/* * Process the special R_386_COPY relocations in the main program.  These * copy data from a shared object into a region in the main program's BSS * segment. * * Returns 0 on success, -1 on failure. */intdo_copy_relocations(Obj_Entry *dstobj){    const Elf_Rel *rellim;    const Elf_Rel *rel;    assert(dstobj->mainprog);	/* COPY relocations are invalid elsewhere */    rellim = (const Elf_Rel *) ((caddr_t) dstobj->rel + dstobj->relsize);    for (rel = dstobj->rel;  rel < rellim;  rel++) {	if (ELF_R_TYPE(rel->r_info) == R_386_COPY) {	    void *dstaddr;	    const Elf_Sym *dstsym;	    const char *name;	    unsigned long hash;	    size_t size;	    const void *srcaddr;	    const Elf_Sym *srcsym;	    Obj_Entry *srcobj;	    dstaddr = (void *) (dstobj->relocbase + rel->r_offset);	    dstsym = dstobj->symtab + ELF_R_SYM(rel->r_info);	    name = dstobj->strtab + dstsym->st_name;	    hash = elf_hash(name);	    size = dstsym->st_size;	    for (srcobj = dstobj->next;  srcobj != NULL;  srcobj = srcobj->next)		if ((srcsym = symlook_obj(name, hash, srcobj, false)) != NULL)		    break;	    if (srcobj == NULL) {		_rtld_error("Undefined symbol /"%s/" referenced from COPY"		  " relocation in %s", name, dstobj->path);		return -1;	    }	    srcaddr = (const void *) (srcobj->relocbase + srcsym->st_value);	    memcpy(dstaddr, srcaddr, size);	}    }    return 0;}

el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel){    uint64_t *p = (uint64_t*) (rel->r_offset + ctx->base_load_vaddr);    uint32_t type = ELF_R_TYPE(rel->r_info);    uint32_t sym  = ELF_R_SYM(rel->r_info);    switch (type) {        case R_AMD64_NONE: break;        case R_AMD64_RELATIVE:            EL_DEBUG("Applying R_AMD64_RELATIVE reloc @%p/n", p);            *p = rel->r_addend + ctx->base_load_vaddr;            break;        default:            EL_DEBUG("Bad relocation %u/n", type);            return EL_BADREL;    }    return EL_OK;}

voidgrub_arch_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,				 grub_size_t *got){  const Elf_Ehdr *e = ehdr;  const Elf_Shdr *s;  unsigned i;  *tramp = 0;  *got = 0;  /* Find a symbol table.  */  for (i = 0, s = (const Elf_Shdr *) ((const char *) e + e->e_shoff);       i < e->e_shnum;       i++, s = (const Elf_Shdr *) ((const char *) s + e->e_shentsize))    if (s->sh_type == SHT_SYMTAB)      break;  if (i == e->e_shnum)    return;  for (i = 0, s = (const Elf_Shdr *) ((const char *) e + e->e_shoff);       i < e->e_shnum;       i++, s = (const Elf_Shdr *) ((const char *) s + e->e_shentsize))    if (s->sh_type == SHT_RELA)      {	const Elf_Rela *rel, *max;		for (rel = (const Elf_Rela *) ((const char *) e + s->sh_offset),	       max = rel + s->sh_size / s->sh_entsize;	     rel < max;	     rel++)	  if (ELF_R_TYPE (rel->r_info) == GRUB_ELF_R_PPC_REL24)	    (*tramp)++;	      }  return;}

/* ARGSUSED3 */voidundo_reloc(void *vrel, uchar_t *oaddr, uchar_t *iaddr, Reloc *reloc){	Rela		*rel = vrel;	const Rel_entry	*rep;	Xword		rtype = ELF_R_TYPE(rel->r_info, M_MACH);	ulong_t		*_oaddr;	ulong_t		*_iaddr;	switch (rtype) {	case R_SPARC_NONE:		break;	case R_SPARC_COPY:		(void) memset((void *)oaddr, 0, (size_t)reloc->r_size);		break;	case R_SPARC_JMP_SLOT:		/* LINTED */		_oaddr = (unsigned long *)oaddr;		/* LINTED */		_iaddr = (unsigned long *)iaddr;		if (_iaddr) {			*_oaddr++ = *_iaddr++;			*_oaddr++ = *_iaddr++;			*_oaddr = *_iaddr;		} else {			*_oaddr++ = 0;			*_oaddr++ = 0;			*_oaddr = 0;		}		break;	default:		rep = &reloc_table[rtype];		if (iaddr)			(void) memcpy(oaddr, iaddr, rep->re_fsize);		else			(void) memset(oaddr, 0, rep->re_fsize);	}}

/* ARGSUSED3 */voidinc_reloc(void *vnrel, void *vorel, Reloc *reloc, uchar_t *oaddr,    uchar_t *iaddr){	Rela	*nrel = vnrel;	Rela	*orel = vorel;	if (ELF_R_TYPE(nrel->r_info, M_MACH) == R_AMD64_JUMP_SLOT) {		/* LINTED */		ulong_t	*_oaddr = (ulong_t *)oaddr;		/* LINTED */		ulong_t	*_iaddr = (ulong_t *)iaddr;		if (_iaddr)			*_oaddr = *_iaddr + reloc->r_value;		else			*_oaddr = reloc->r_value;	}	*nrel = *orel;	nrel->r_offset += reloc->r_value;}

intreloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockState *lockstate){	const Elf_Rela *relalim;	const Elf_Rela *rela;	Elf_Addr *where, target, *ptr;	if (!obj->irelative)		return (0);	relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);	for (rela = obj->pltrela;  rela < relalim;  rela++) {		if (ELF_R_TYPE(rela->r_info) == R_AARCH64_IRELATIVE) {			ptr = (Elf_Addr *)(obj->relocbase + rela->r_addend);			where = (Elf_Addr *)(obj->relocbase + rela->r_offset);			lock_release(rtld_bind_lock, lockstate);			target = call_ifunc_resolver(ptr);			wlock_acquire(rtld_bind_lock, lockstate);			*where = target;		}	}	obj->irelative = false;	return (0);}

static int_rtld_relocate_plt_object(const Obj_Entry *obj, const Elf_Rel *rel,	Elf_Addr *tp){	Elf_Addr *where = (Elf_Addr *)(obj->relocbase + rel->r_offset);	Elf_Addr new_value;	const Elf_Sym  *def;	const Obj_Entry *defobj;	unsigned long info = rel->r_info;	assert(ELF_R_TYPE(info) == R_TYPE(JUMP_SLOT));	def = _rtld_find_plt_symdef(ELF_R_SYM(info), obj, &defobj, tp != NULL);	if (__predict_false(def == NULL))		return -1;	if (__predict_false(def == &_rtld_sym_zero))		return 0;	if (ELF_ST_TYPE(def->st_info) == STT_GNU_IFUNC) {		if (tp == NULL)			return 0;		new_value = _rtld_resolve_ifunc(defobj, def);	} else {		new_value = (Elf_Addr)(defobj->relocbase + def->st_value);	}	/* Set the Thumb bit, if needed.  */	if (ELF_ST_TYPE(def->st_info) == STT_ARM_TFUNC)		new_value |= 1;	rdbg(("bind now/fixup in %s --> old=%p new=%p",	    defobj->strtab + def->st_name, (void *)*where, (void *)new_value));	if (*where != new_value)		*where = new_value;	if (tp)		*tp = new_value;	return 0;}

/* * LD_BIND_NOW was set - force relocation for all jump slots */intreloc_jmpslots(Obj_Entry *obj, int flags, RtldLockState *lockstate){	const Obj_Entry *defobj;	const Elf_Rela *relalim;	const Elf_Rela *rela;	const Elf_Sym *def;	if (obj->jmpslots_done)		return (0);	relalim = (const Elf_Rela *)((const char *)obj->pltrela +	    obj->pltrelasize);	for (rela = obj->pltrela; rela < relalim; rela++) {		Elf_Addr *where, target;		where = (Elf_Addr *)(obj->relocbase + rela->r_offset);		switch(ELF_R_TYPE(rela->r_info)) {		case R_AARCH64_JUMP_SLOT:			def = find_symdef(ELF_R_SYM(rela->r_info), obj,			    &defobj, SYMLOOK_IN_PLT | flags, NULL, lockstate);			if (def == NULL)				return (-1);			if (ELF_ST_TYPE(def->st_info) == STT_GNU_IFUNC) {				obj->gnu_ifunc = true;				continue;			}			target = (Elf_Addr)(defobj->relocbase + def->st_value);			reloc_jmpslot(where, target, defobj, obj,			    (const Elf_Rel *)rela);			break;		}	}	obj->jmpslots_done = true;	return (0);}

intreloc_iresolve(Obj_Entry *obj, RtldLockState *lockstate){    const Elf_Rel *rellim;    const Elf_Rel *rel;    Elf_Addr *where, target;    if (!obj->irelative)	return (0);    rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);    for (rel = obj->pltrel;  rel < rellim;  rel++) {	switch (ELF_R_TYPE(rel->r_info)) {	case R_386_IRELATIVE:	  where = (Elf_Addr *)(obj->relocbase + rel->r_offset);	  lock_release(rtld_bind_lock, lockstate);	  target = call_ifunc_resolver(obj->relocbase + *where);	  wlock_acquire(rtld_bind_lock, lockstate);	  *where = target;	  break;	}    }    obj->irelative = false;    return (0);}

bool ElfRelocations::ApplyRelaReloc(const ELF::Rela* rela,                                    const ElfSymbols* symbols,                                    SymbolResolver* resolver,                                    Error* error) {  const ELF::Word rel_type = ELF_R_TYPE(rela->r_info);  const ELF::Word rel_symbol = ELF_R_SYM(rela->r_info);  ELF::Addr sym_addr = 0;  ELF::Addr reloc = static_cast<ELF::Addr>(rela->r_offset + load_bias_);  RLOG("  reloc=%p offset=%p type=%d symbol=%d/n",       reloc,       rela->r_offset,       rel_type,       rel_symbol);  if (rel_type == 0)    return true;  bool resolved = false;  // If this is a symbolic relocation, compute the symbol's address.  if (__builtin_expect(rel_symbol != 0, 0)) {    if (!ResolveSymbol(rel_type,                       rel_symbol,                       symbols,                       resolver,                       reloc,                       &sym_addr,                       error)) {      return false;    }    resolved = true;  }  return ApplyResolvedRelaReloc(rela, sym_addr, resolved, error);}

//.........这里部分代码省略.........		relbgn = (ulong_t)(REL(lmp));		relend = relbgn + (ulong_t)(RELSZ(lmp));		if (pltbgn) {			if (!relbgn || (relbgn > pltbgn))				relbgn = pltbgn;			if (!relbgn || (relend < pltend))				relend = pltend;		}	}	if (!relbgn || (relbgn == relend)) {		DBG_CALL(Dbg_reloc_run(lmp, 0, plt, DBG_REL_NONE));		return (1);	}	DBG_CALL(Dbg_reloc_run(lmp, M_REL_SHT_TYPE, plt, DBG_REL_START));	/*	 * If we're processing a dynamic executable in lazy mode there is no	 * need to scan the .rel.plt table, however if we're processing a shared	 * object in lazy mode the .got addresses associated to each .plt must	 * be relocated to reflect the location of the shared object.	 */	if (pltbgn && ((MODE(lmp) & RTLD_NOW) == 0) &&	    (FLAGS(lmp) & FLG_RT_FIXED))		noplt = 1;	sip = SYMINFO(lmp);	/*	 * Loop through relocations.	 */	while (relbgn < relend) {		mmapobj_result_t	*mpp;		uint_t			sb_flags = 0;		rtype = ELF_R_TYPE(((Rel *)relbgn)->r_info, M_MACH);		/*		 * If this is a RELATIVE relocation in a shared object (the		 * common case), and if we are not debugging, then jump into a		 * tighter relocation loop (elf_reloc_relative).		 */		if ((rtype == R_386_RELATIVE) &&		    ((FLAGS(lmp) & FLG_RT_FIXED) == 0) && (DBG_ENABLED == 0)) {			if (relacount) {				relbgn = elf_reloc_relative_count(relbgn,				    relacount, relsiz, basebgn, lmp,				    textrel, 0);				relacount = 0;			} else {				relbgn = elf_reloc_relative(relbgn, relend,				    relsiz, basebgn, lmp, textrel, 0);			}			if (relbgn >= relend)				break;			rtype = ELF_R_TYPE(((Rel *)relbgn)->r_info, M_MACH);		}		roffset = ((Rel *)relbgn)->r_offset;		/*		 * If this is a shared object, add the base address to offset.		 */		if (!(FLAGS(lmp) & FLG_RT_FIXED)) {			/*			 * If we're processing lazy bindings, we have to step			 * through the plt entries and add the base address			 * to the corresponding got entry.

/* Process the non-PLT relocations. */intreloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int flags,    RtldLockState *lockstate){	const Elf_Rela *relalim;	const Elf_Rela *rela;	SymCache *cache;	const Elf_Sym *def;	const Obj_Entry *defobj;	Elf_Addr *where, symval;	Elf32_Addr *where32;	int r;	r = -1;	/*	 * The dynamic loader may be called from a thread, we have	 * limited amounts of stack available so we cannot use alloca().	 */	if (obj != obj_rtld) {		cache = calloc(obj->dynsymcount, sizeof(SymCache));		/* No need to check for NULL here */	} else		cache = NULL;	relalim = (const Elf_Rela *)((caddr_t)obj->rela + obj->relasize);	for (rela = obj->rela;  rela < relalim;  rela++) {		/*		 * First, resolve symbol for relocations which		 * reference symbols.		 */		switch (ELF_R_TYPE(rela->r_info)) {		case R_X86_64_64:		case R_X86_64_PC32:		case R_X86_64_GLOB_DAT:		case R_X86_64_TPOFF64:		case R_X86_64_TPOFF32:		case R_X86_64_DTPMOD64:		case R_X86_64_DTPOFF64:		case R_X86_64_DTPOFF32:			def = find_symdef(ELF_R_SYM(rela->r_info), obj,			    &defobj, flags, cache, lockstate);			if (def == NULL)				goto done;			/*			 * If symbol is IFUNC, only perform relocation			 * when caller allowed it by passing			 * SYMLOOK_IFUNC flag.  Skip the relocations			 * otherwise.			 *			 * Also error out in case IFUNC relocations			 * are specified for TLS, which cannot be			 * usefully interpreted.			 */			if (ELF_ST_TYPE(def->st_info) == STT_GNU_IFUNC) {				switch (ELF_R_TYPE(rela->r_info)) {				case R_X86_64_64:				case R_X86_64_PC32:				case R_X86_64_GLOB_DAT:					if ((flags & SYMLOOK_IFUNC) == 0) {						obj->non_plt_gnu_ifunc = true;						continue;					}					symval = (Elf_Addr)rtld_resolve_ifunc(					    defobj, def);					break;				case R_X86_64_TPOFF64:				case R_X86_64_TPOFF32:				case R_X86_64_DTPMOD64:				case R_X86_64_DTPOFF64:				case R_X86_64_DTPOFF32:					_rtld_error("%s: IFUNC for TLS reloc",					    obj->path);					goto done;				}			} else {				if ((flags & SYMLOOK_IFUNC) != 0)					continue;				symval = (Elf_Addr)defobj->relocbase +				    def->st_value;			}			break;		default:			if ((flags & SYMLOOK_IFUNC) != 0)				continue;			break;		}		where = (Elf_Addr *)(obj->relocbase + rela->r_offset);		where32 = (Elf32_Addr *)where;		switch (ELF_R_TYPE(rela->r_info)) {		case R_X86_64_NONE:			break;		case R_X86_64_64:			*where = symval + rela->r_addend;			break;		case R_X86_64_PC32:			/*			 * I don't think the dynamic linker should			 * ever see this type of relocation.  But the//.........这里部分代码省略.........

/* * 1. _gp_disp symbol are not considered in this file. * 2. There is a local/external column; * local corresponds to (STB_LOCAL & STT_SECTION) and * all others are external. Because if the type of a * symbol is STT_SECTION, it must be STB_LOCAL. Thus * just consider symtype here. */boolrtems_rtl_elf_relocate_rel (const rtems_rtl_obj_t*      obj,                            const Elf_Rel*              rel,                            const rtems_rtl_obj_sect_t* sect,                            const char*                 symname,                            const Elf_Byte              syminfo,                            const Elf_Word              symvalue){  Elf_Addr *where;  Elf_Word  tmp;  Elf_Word addend = (Elf_Word)0;  Elf_Word local = 0;  uint32_t t;  static Elf_Addr *where_hi16;  static Elf_Addr ahl;  where = (Elf_Addr *)(sect->base + rel->r_offset);  addend = *where;  if (syminfo == STT_SECTION)    local = 1;  switch (ELF_R_TYPE(rel->r_info)) {    case R_TYPE(NONE):      break;    case R_TYPE(16):      tmp = addend & 0xffff;      if ((tmp & 0x8000) == 0x8000)        tmp |= 0xffff0000; /* Sign extend */      tmp = symvalue + (int)tmp;      if ((tmp & 0xffff0000) != 0) {        printf("R_MIPS_16 Overflow/n");        return false;      }      *where = (tmp & 0xffff) | (*where & 0xffff0000);      if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))        printf ("rtl: R_MIPS_16 %p @ %p in %s/n",                (void *)*(where), where, rtems_rtl_obj_oname (obj));      break;    case R_TYPE(32):      tmp = symvalue + addend;      if (addend != tmp)        *where = tmp;      if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))        printf ("rtl: R_MIPS_32 %p @ %p in %s/n",                (void *)*(where), where, rtems_rtl_obj_oname (obj));      break;    case R_TYPE(26):        addend &= 0x03ffffff;        addend <<= 2;      if (local == 1) { /* STB_LOCAL and STT_SECTION */        tmp = symvalue + (((Elf_Addr)where & 0xf0000000) | addend);        tmp >>= 2;      } else { /* external */

int_rtld_relocate_nonplt_objects(Obj_Entry *obj){    for (const Elf_Rela *rela = obj->rela; rela < obj->relalim; rela++) {        Elf_Addr        *where;        const Elf_Sym   *def;        const Obj_Entry *defobj;        unsigned long	 symnum;        Elf_Addr	 addend;        where = (Elf_Addr *)(obj->relocbase + rela->r_offset);        symnum = ELF_R_SYM(rela->r_info);        addend = rela->r_addend;        switch (ELF_R_TYPE(rela->r_info)) {        case R_TYPE(NONE):            break;        case R_TYPE(ABS64):	/* word B + S + A */        case R_TYPE(GLOB_DAT):	/* word B + S */            def = _rtld_find_symdef(symnum, obj, &defobj, false);            if (def == NULL)                return -1;            *where = addend + (Elf_Addr)defobj->relocbase +                     def->st_value;            rdbg(("ABS64/GLOB_DAT %s in %s --> %p @ %p in %s",                  obj->strtab + obj->symtab[symnum].st_name,                  obj->path, (void *)tmp, where, defobj->path));            break;        case R_TYPE(RELATIVE):	/* word B + A */            *where = addend + (Elf_Addr)obj->relocbase;            rdbg(("RELATIVE in %s --> %p", obj->path,                  (void *)tmp));            break;        case R_TYPE(COPY):            /*             * These are deferred until all other relocations have             * been done.  All we do here is make sure that the             * COPY relocation is not in a shared library.  They             * are allowed only in executable files.             */            if (obj->isdynamic) {                _rtld_error(                    "%s: Unexpected R_COPY relocation in shared library",                    obj->path);                return -1;            }            rdbg(("COPY (avoid in main)"));            break;        case R_TLS_TYPE(TLS_DTPREL):            def = _rtld_find_symdef(symnum, obj, &defobj, false);            if (def == NULL)                return -1;            *where = addend + (Elf_Addr)(def->st_value);            rdbg(("TLS_DTPOFF32 %s in %s --> %p",                  obj->strtab + obj->symtab[symnum].st_name,                  obj->path, (void *)tmp));            break;        case R_TLS_TYPE(TLS_DTPMOD):            def = _rtld_find_symdef(symnum, obj, &defobj, false);            if (def == NULL)                return -1;            *where = (Elf_Addr)(defobj->tlsindex);            rdbg(("TLS_DTPMOD %s in %s --> %p",                  obj->strtab + obj->symtab[symnum].st_name,                  obj->path, (void *)tmp));            break;        case R_TLS_TYPE(TLS_TPREL):            def = _rtld_find_symdef(symnum, obj, &defobj, false);            if (def == NULL)                return -1;            if (!defobj->tls_done &&                    _rtld_tls_offset_allocate(obj))                return -1;            *where = (Elf_Addr)def->st_value + defobj->tlsoffset +                     sizeof(struct tls_tcb);            rdbg(("TLS_TPOFF32 %s in %s --> %p",                  obj->strtab + obj->symtab[symnum].st_name,                  obj->path, (void *)tmp));            break;        default:            rdbg(("sym = %lu, type = %lu, offset = %p, "                  "contents = %p, symbol = %s",                  symnum, (u_long)ELF_R_TYPE(rela->r_info),                  (void *)rela->r_offset, *where,                  obj->strtab + obj->symtab[symnum].st_name));//.........这里部分代码省略.........

/* Process one elf relocation with addend. */static intelf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,    int type, int local, elf_lookup_fn lookup){	Elf64_Addr *where, val;	Elf32_Addr *where32, val32;	Elf_Addr addr;	Elf_Addr addend;	Elf_Size rtype, symidx;	const Elf_Rel *rel;	const Elf_Rela *rela;	switch (type) {	case ELF_RELOC_REL:		rel = (const Elf_Rel *)data;		where = (Elf_Addr *) (relocbase + rel->r_offset);		rtype = ELF_R_TYPE(rel->r_info);		symidx = ELF_R_SYM(rel->r_info);		/* Addend is 32 bit on 32 bit relocs */		switch (rtype) {		case R_X86_64_PC32:		case R_X86_64_32S:			addend = *(Elf32_Addr *)where;			break;		default:			addend = *where;			break;		}		break;	case ELF_RELOC_RELA:		rela = (const Elf_Rela *)data;		where = (Elf_Addr *) (relocbase + rela->r_offset);		addend = rela->r_addend;		rtype = ELF_R_TYPE(rela->r_info);		symidx = ELF_R_SYM(rela->r_info);		break;	default:		panic("unknown reloc type %d/n", type);	}	switch (rtype) {		case R_X86_64_NONE:	/* none */			break;		case R_X86_64_64:		/* S + A */			addr = lookup(lf, symidx, 1);			val = addr + addend;			if (addr == 0)				return -1;			if (*where != val)				*where = val;			break;		case R_X86_64_PC32:	/* S + A - P */			addr = lookup(lf, symidx, 1);			where32 = (Elf32_Addr *)where;			val32 = (Elf32_Addr)(addr + addend - (Elf_Addr)where);			if (addr == 0)				return -1;			if (*where32 != val32)				*where32 = val32;			break;		case R_X86_64_32S:	/* S + A sign extend */			addr = lookup(lf, symidx, 1);			val32 = (Elf32_Addr)(addr + addend);			where32 = (Elf32_Addr *)where;			if (addr == 0)				return -1;			if (*where32 != val32)				*where32 = val32;			break;		case R_X86_64_COPY:	/* none */			/*			 * There shouldn't be copy relocations in kernel			 * objects.			 */			printf("kldload: unexpected R_COPY relocation/n");			return -1;			break;		case R_X86_64_GLOB_DAT:	/* S */		case R_X86_64_JMP_SLOT:	/* XXX need addend + offset */			addr = lookup(lf, symidx, 1);			if (addr == 0)				return -1;			if (*where != addr)				*where = addr;			break;		case R_X86_64_RELATIVE:	/* B + A */			addr = relocbase + addend;			val = addr;			if (*where != val)				*where = val;			break;//.........这里部分代码省略.........

int_dl_md_reloc(elf_object_t *object, int rel, int relasz){	long	i;	long	numrela;	int	fails = 0;	Elf64_Addr loff;	Elf64_Rela  *relas;	struct load_list *llist;	loff = object->obj_base;	numrela = object->Dyn.info[relasz] / sizeof(Elf64_Rela);	relas = (Elf64_Rela *)(object->Dyn.info[rel]);	if (relas == NULL)		return(0);	/*	 * unprotect some segments if we need it.	 * XXX - we unprotect way to much. only the text can have cow	 * relocations.	 */	if ((object->dyn.textrel == 1) && (rel == DT_REL || rel == DT_RELA)) {		for (llist = object->load_list; llist != NULL; llist = llist->next) {			if (!(llist->prot & PROT_WRITE)) {				_dl_mprotect(llist->start, llist->size,				    llist->prot|PROT_WRITE);			}		}	}	for (i = 0; i < numrela; i++, relas++) {		Elf64_Addr *r_addr;		Elf64_Addr ooff;		const Elf64_Sym *sym, *this;		const char *symn;		r_addr = (Elf64_Addr *)(relas->r_offset + loff);		if (ELF64_R_SYM(relas->r_info) == 0xffffffff)			continue;		sym = object->dyn.symtab;		sym += ELF64_R_SYM(relas->r_info);		symn = object->dyn.strtab + sym->st_name;		this = NULL;		switch (ELF64_R_TYPE(relas->r_info)) {		case R_TYPE(REFQUAD):			ooff =  _dl_find_symbol_bysym(object,			    ELF64_R_SYM(relas->r_info), &this,			    SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_NOTPLT,			    sym, NULL);			if (this == NULL)				goto resolve_failed;			*r_addr += ooff + this->st_value + relas->r_addend;			break;		case R_TYPE(RELATIVE):			/*			 * There is a lot of unaligned RELATIVE			 * relocs generated by gcc in the exception handlers.			 */			if ((((Elf_Addr) r_addr) & 0x7) != 0) {				Elf_Addr tmp;#if 0_dl_printf("unaligned RELATIVE: %p type: %d %s 0x%lx -> 0x%lx/n", r_addr,    ELF_R_TYPE(relas->r_info), object->load_name, *r_addr, *r_addr+loff);#endif				_dl_bcopy(r_addr, &tmp, sizeof(Elf_Addr));				tmp += loff;				_dl_bcopy(&tmp, r_addr, sizeof(Elf_Addr));			} else				*r_addr += loff;			break;		case R_TYPE(JMP_SLOT):			ooff = _dl_find_symbol(symn, &this,			    SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT,			    sym, object, NULL);			if (this == NULL)				goto resolve_failed;			*r_addr = ooff + this->st_value + relas->r_addend;			break;		case R_TYPE(GLOB_DAT):			ooff =  _dl_find_symbol_bysym(object,			    ELF64_R_SYM(relas->r_info), &this,			    SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_NOTPLT,			    sym, NULL);			if (this == NULL)				goto resolve_failed;			*r_addr = ooff + this->st_value + relas->r_addend;			break;		case R_TYPE(NONE):			break;		default:			_dl_printf("%s:"			    " %s: unsupported relocation '%s' %d at %lx/n",			    _dl_progname, object->load_name, symn,			    ELF64_R_TYPE(relas->r_info), r_addr );			_dl_exit(1);//.........这里部分代码省略.........

void_rtld_relocate_nonplt_self(Elf_Dyn *dynp, Elf_Addr relocbase){	const Elf_Rel *rel = 0, *rellim;	Elf_Addr relsz = 0;	const Elf_Sym *symtab = NULL, *sym;	Elf_Addr *where;	Elf_Addr *got = NULL;	Elf_Word local_gotno = 0, symtabno = 0, gotsym = 0;	size_t i;	for (; dynp->d_tag != DT_NULL; dynp++) {		switch (dynp->d_tag) {		case DT_REL:			rel = (const Elf_Rel *)(relocbase + dynp->d_un.d_ptr);			break;		case DT_RELSZ:			relsz = dynp->d_un.d_val;			break;		case DT_SYMTAB:			symtab = (const Elf_Sym *)(relocbase + dynp->d_un.d_ptr);			break;		case DT_PLTGOT:			got = (Elf_Addr *)(relocbase + dynp->d_un.d_ptr);			break;		case DT_MIPS_LOCAL_GOTNO:			local_gotno = dynp->d_un.d_val;			break;		case DT_MIPS_SYMTABNO:			symtabno = dynp->d_un.d_val;			break;		case DT_MIPS_GOTSYM:			gotsym = dynp->d_un.d_val;			break;		}	}	i = (got[1] & GOT1_MASK) ? 2 : 1;	/* Relocate the local GOT entries */	got += i;	for (; i < local_gotno; i++) {		*got++ += relocbase;	}	sym = symtab + gotsym;	/* Now do the global GOT entries */	for (i = gotsym; i < symtabno; i++) {		*got = sym->st_value + relocbase;		++sym;		++got;	}	rellim = (const Elf_Rel *)((caddr_t)rel + relsz);	for (; rel < rellim; rel++) {		Elf_Word r_symndx, r_type;		where = (void *)(relocbase + rel->r_offset);		r_symndx = ELF_R_SYM(rel->r_info);		r_type = ELF_R_TYPE(rel->r_info);		switch (r_type & 0xff) {		case R_TYPE(REL32): {			const size_t rlen =			    ELF_R_NXTTYPE_64_P(r_type)				? sizeof(Elf_Sxword)				: sizeof(Elf_Sword);			Elf_Sxword old = load_ptr(where, rlen);			Elf_Sxword val = old;#ifdef __mips_n64			assert(r_type == R_TYPE(REL32)			    || r_type == (R_TYPE(REL32)|(R_TYPE(64) << 8)));#endif			assert(r_symndx < gotsym);			sym = symtab + r_symndx;			assert(ELF_ST_BIND(sym->st_info) == STB_LOCAL);			val += relocbase;			store_ptr(where, val, sizeof(Elf_Sword));			dbg("REL32/L(%p) %p -> %p in <self>",			    where, (void *)old, (void *)val);			store_ptr(where, val, rlen);			break;		}		case R_TYPE(GPREL32):		case R_TYPE(NONE):			break;		default:			abort();			break;		}	}}

//.........这里部分代码省略.........			}		} else {			/* TODO: add cache here */			def = find_symdef(i, obj, &defobj, flags, NULL,			    lockstate);			if (def == NULL) {				dbg("Warning4, can't find symbole %d", i);				return -1;			}			*got = def->st_value + (Elf_Addr)defobj->relocbase;			if ((Elf_Addr)(*got) == (Elf_Addr)obj->relocbase) {				dbg("Warning4, i:%d maps to relocbase address:%p",				    i, obj->relocbase);				dbg("via first obj symbol %s",				    obj->strtab + obj->symtab[i].st_name);				dbg("found in obj %p:%s",				    defobj, defobj->path);			}		}		dbg("  --> now %lx", (u_long) *got);		++sym;		++got;	}	got = obj->pltgot;	rellim = (const Elf_Rel *)((caddr_t)obj->rel + obj->relsize);	for (rel = obj->rel; rel < rellim; rel++) {		Elf_Word	r_symndx, r_type;		void		*where;		where = obj->relocbase + rel->r_offset;		r_symndx = ELF_R_SYM(rel->r_info);		r_type = ELF_R_TYPE(rel->r_info);		switch (r_type & 0xff) {		case R_TYPE(NONE):			break;		case R_TYPE(REL32): {			/* 32-bit PC-relative reference */			const size_t rlen =			    ELF_R_NXTTYPE_64_P(r_type)				? sizeof(Elf_Sxword)				: sizeof(Elf_Sword);			Elf_Sxword old = load_ptr(where, rlen);			Elf_Sxword val = old;			def = obj->symtab + r_symndx;			if (r_symndx >= obj->gotsym) {				val += got[obj->local_gotno + r_symndx - obj->gotsym];				dbg("REL32/G(%p) %p --> %p (%s) in %s",				    where, (void *)old, (void *)val,				    obj->strtab + def->st_name,				    obj->path);			} else {				/*				 * XXX: ABI DIFFERENCE!				 *				 * Old NetBSD binutils would generate shared				 * libs with section-relative relocations being				 * already adjusted for the start address of				 * the section.				 *				 * New binutils, OTOH, generate shared libs

/* * Resolve a symbol in an ELF object. There are two cases here. * * If 'resolver' is NULL, only symbols resolvable internally are * resolved, and exceptions are stored, not posted. Otherwise, * only symbols resolvable externally are resolved, 'resolver' is * used to resolve them, and exceptions are posted. */static inline jint_jc_elf_resolve_sym(_jc_env *env, _jc_elf *elf, _jc_elf_loadable *loadable,	const Elf_Rela *rela, _jc_elf_resolver *resolver, void *arg){	const Elf_Word type = ELF_R_TYPE(rela->r_info);	_jc_elf_info *const info = elf->info;	const Elf_Sym *const sym = &info->symbols[ELF_R_SYM(rela->r_info)];	const char *name = info->strings + sym->st_name;	switch (sym->st_shndx) {	case SHN_ABS:		if (resolver != NULL)			break;		if (_jc_elf_arch_reloc(env, elf->pathname,		    loadable->vaddr, rela->r_offset, type,		    sym->st_value, rela->r_addend) != JNI_OK)			return JNI_ERR;		break;	case SHN_UNDEF:	    {		Elf_Addr value;		if (resolver == NULL)			break;		if ((*resolver)(env, arg,		    info->strings + sym->st_name, &value) != JNI_OK)			return JNI_ERR;		if (_jc_elf_arch_reloc(env, elf->pathname, loadable->vaddr,		    rela->r_offset, type, value, rela->r_addend) != JNI_OK) {			_jc_post_exception_info(env);			return JNI_ERR;		}		break;	    }	case SHN_COMMON:		_JC_ASSERT(resolver == NULL);		_JC_EX_STORE(env, LinkageError,		    "%s: ELF symbol `%s' is common (not supported)",		    elf->pathname, name);		return JNI_ERR;	default:	    {		const _jc_elf_loadable *sym_section;		/* Skip if only resolving externals */		if (resolver != NULL)			break;		/* Sanity check the symbol's section */		if (sym->st_shndx >= info->ehdr->e_shnum		    || (sym_section		      = info->shdr2section[sym->st_shndx]) == NULL) {			_JC_EX_STORE(env, LinkageError,			    "%s: invalid section index %d for symbol `%s'",			    elf->pathname, sym->st_shndx, name);			return JNI_ERR;		}		/* Apply relocation */		if (_jc_elf_arch_reloc(env, elf->pathname,		    loadable->vaddr, rela->r_offset, type,		    (Elf_Addr)(sym_section->vaddr + sym->st_value),		    rela->r_addend) != JNI_OK)			return JNI_ERR;		break;	    }	}	/* Done */	return JNI_OK;}

intkobj_reloc(kobj_t ko, uintptr_t relocbase, const void *data,	   bool isrela, bool local){	Elf64_Addr *where, val;	Elf32_Addr *where32, val32;	Elf64_Addr addr;	Elf64_Addr addend;	uintptr_t rtype, symidx;	const Elf_Rel *rel;	const Elf_Rela *rela;	if (isrela) {		rela = (const Elf_Rela *)data;		where = (Elf64_Addr *)(relocbase + rela->r_offset);		addend = rela->r_addend;		rtype = ELF_R_TYPE(rela->r_info);		symidx = ELF_R_SYM(rela->r_info);	} else {		rel = (const Elf_Rel *)data;		where = (Elf64_Addr *)(relocbase + rel->r_offset);		rtype = ELF_R_TYPE(rel->r_info);		symidx = ELF_R_SYM(rel->r_info);		/* Addend is 32 bit on 32 bit relocs */		switch (rtype) {		case R_X86_64_PC32:		case R_X86_64_32:		case R_X86_64_32S:			addend = *(Elf32_Addr *)where;			break;		default:			addend = *where;			break;		}	}	switch (rtype) {	case R_X86_64_NONE:	/* none */		break;	case R_X86_64_64:		/* S + A */		addr = kobj_sym_lookup(ko, symidx);		if (addr == 0)			return -1;		val = addr + addend;		*where = val;		break;	case R_X86_64_PC32:	/* S + A - P */		addr = kobj_sym_lookup(ko, symidx);		if (addr == 0)			return -1;		where32 = (Elf32_Addr *)where;		val32 = (Elf32_Addr)(addr + addend - (Elf64_Addr)where);		*where32 = val32;		break;	case R_X86_64_32:	/* S + A */	case R_X86_64_32S:	/* S + A sign extend */		addr = kobj_sym_lookup(ko, symidx);		if (addr == 0)			return -1;		val32 = (Elf32_Addr)(addr + addend);		where32 = (Elf32_Addr *)where;		*where32 = val32;		break;	case R_X86_64_GLOB_DAT:	/* S */	case R_X86_64_JUMP_SLOT:/* XXX need addend + offset */		addr = kobj_sym_lookup(ko, symidx);		if (addr == 0)			return -1;		*where = addr;		break;	case R_X86_64_RELATIVE:	/* B + A */		addr = relocbase + addend;		val = addr;		*where = val;		break;	default:		printf("kobj_reloc: unexpected relocation type %ld/n", rtype);		return -1;	}	return 0;}

/* Process one elf relocation with addend. */static intelf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,    int type, int local, elf_lookup_fn lookup){	Elf_Addr *where;	Elf_Addr addr;	Elf_Addr addend;	Elf_Word rtype, symidx;	const Elf_Rel *rel;	const Elf_Rela *rela;	int error;	switch (type) {	case ELF_RELOC_REL:		rel = (const Elf_Rel *)data;		where = (Elf_Addr *) (relocbase + rel->r_offset);		addend = load_ptr(where);		rtype = ELF_R_TYPE(rel->r_info);		symidx = ELF_R_SYM(rel->r_info);		break;	case ELF_RELOC_RELA:		rela = (const Elf_Rela *)data;		where = (Elf_Addr *) (relocbase + rela->r_offset);		addend = rela->r_addend;		rtype = ELF_R_TYPE(rela->r_info);		symidx = ELF_R_SYM(rela->r_info);		break;	default:		panic("unknown reloc type %d/n", type);	}	if (local) {		if (rtype == R_ARM_RELATIVE) {	/* A + B */			addr = elf_relocaddr(lf, relocbase + addend);			if (load_ptr(where) != addr)				store_ptr(where, addr);		}		return (0);	}	switch (rtype) {		case R_ARM_NONE:	/* none */			break;		case R_ARM_ABS32:			error = lookup(lf, symidx, 1, &addr);			if (error != 0)				return -1;			store_ptr(where, addr + load_ptr(where));			break;		case R_ARM_COPY:	/* none */			/*			 * There shouldn't be copy relocations in kernel			 * objects.			 */			printf("kldload: unexpected R_COPY relocation/n");			return -1;			break;		case R_ARM_JUMP_SLOT:			error = lookup(lf, symidx, 1, &addr);			if (error == 0) {				store_ptr(where, addr);				return (0);			}			return (-1);		case R_ARM_RELATIVE:			break;		default:			printf("kldload: unexpected relocation type %d/n",			       rtype);			return -1;	}	return(0);}

//.........这里部分代码省略.........        //        // Set pointer to symbol table entry associated with the relocation entry.        //        Elf_Sym *Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);                Elf_Shdr *SymShdr;        UINT8 *Targ;        UINT16 Address;        //        // Check section header index found in symbol table and get the section         // header location.        //        if (Sym->st_shndx == SHN_UNDEF            || Sym->st_shndx == SHN_ABS            || Sym->st_shndx > mEhdr->e_shnum) {          Error (NULL, 0, 3000, "Invalid", "%s bad symbol definition.", mInImageName);        }        SymShdr = GetShdrByIndex(Sym->st_shndx);        //        // Convert the relocation data to a pointer into the coff file.        //        // Note:         //   r_offset is the virtual address of the storage unit to be relocated.        //   sh_addr is the virtual address for the base of the section.        //        Targ = mCoffFile + SecOffset + (Rel->r_offset - SecShdr->sh_addr);        //        // Determine how to handle each relocation type based on the machine type.        //        if (mEhdr->e_machine == EM_386) {          switch (ELF_R_TYPE(Rel->r_info)) {          case R_386_NONE:            break;          case R_386_32:            //            // Absolute relocation.            //  Converts Targ from a absolute virtual address to the absolute            //  COFF address.            //            *(UINT32 *)Targ = *(UINT32 *)Targ - SymShdr->sh_addr              + mCoffSectionsOffset[Sym->st_shndx];            break;          case R_386_PC32:            //            // Relative relocation: Symbol - Ip + Addend            //            *(UINT32 *)Targ = *(UINT32 *)Targ              + (mCoffSectionsOffset[Sym->st_shndx] - SymShdr->sh_addr)              - (SecOffset - SecShdr->sh_addr);            break;          default:            Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_386 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));          }        } else if (mEhdr->e_machine == EM_ARM) {          switch (ELF32_R_TYPE(Rel->r_info)) {          case R_ARM_RBASE:            // No relocation - no action required            // break skipped          case R_ARM_PC24:          case R_ARM_XPC25:          case R_ARM_THM_PC22:          case R_ARM_THM_JUMP19: