Subversion Repositories HelenOS

/* reloc_ia64.S - position independent IA-64 ELF shared object relocator

   Copyright (C) 1999 Hewlett-Packard Co.

	Contributed by David Mosberger <davidm@hpl.hp.com>.

   This file is part of GNU-EFI, the GNU EFI development environment.

   GNU EFI is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2, or (at your option)

   any later version.

   GNU EFI is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with GNU EFI; see the file COPYING.  If not, write to the Free

   Software Foundation, 59 Temple Place - Suite 330, Boston, MA

   02111-1307, USA. */

/*

 * This is written in assembly because the entire code needs to be position

 * independent.  Note that the compiler does not generate code that's position

 * independent by itself because it relies on the global offset table being

 * relocated.

 */

	.text

	.psr abi64

	.psr lsb

	.lsb

/*

 * This constant determines how many R_IA64_FPTR64LSB relocations we

 * can deal with.  If you get EFI_BUFFER_TOO_SMALL errors, you may

 * need to increase this number.

 */

#define MAX_FUNCTION_DESCRIPTORS	750

#define ST_VALUE_OFF	8		/* offset of st_value in elf sym */

#define EFI_SUCCESS		0

#define EFI_LOAD_ERROR		1

#define EFI_BUFFER_TOO_SMALL	5

#define DT_NULL		0		/* Marks end of dynamic section */

#define DT_RELA		7		/* Address of Rela relocs */

#define DT_RELASZ	8		/* Total size of Rela relocs */

#define DT_RELAENT	9		/* Size of one Rela reloc */

#define DT_SYMTAB	6		/* Address of symbol table */

#define DT_SYMENT	11		/* Size of one symbol table entry */

#define R_IA64_NONE		0

#define R_IA64_REL64MSB		0x6e

#define R_IA64_REL64LSB		0x6f

#define R_IA64_DIR64MSB		0x26

#define R_IA64_DIR64LSB		0x27

#define R_IA64_FPTR64MSB	0x46

#define R_IA64_FPTR64LSB	0x47

#define	ldbase	in0	/* load address (address of .text) */

#define	dyn	in1	/* address of _DYNAMIC */

#define d_tag	r16

#define d_val	r17

#define rela	r18

#define relasz	r19

#define relaent	r20

#define addr	r21

#define r_info	r22

#define r_offset r23

#define r_addend r24

#define r_type	r25

#define r_sym	r25	/* alias of r_type ! */

#define fptr	r26

#define fptr_limit r27

#define symtab	f8

#define syment	f9

#define ftmp	f10

#define	target	r16

#define val	r17

#define NLOC	0

#define Pnull		p6

#define Prela		p7

#define Prelasz		p8

#define Prelaent	p9

#define Psymtab		p10

#define Psyment		p11

#define Pnone		p6

#define Prel		p7

#define Pfptr		p8

#define Pmore		p6

#define Poom		p6	/* out-of-memory */

	.global _relocate

	.proc _relocate

_relocate:

	alloc r2=ar.pfs,2,0,0,0

	movl	fptr = @gprel(fptr_mem_base)

	;;

	add	fptr = fptr, gp

	movl	fptr_limit = @gprel(fptr_mem_limit)

	;;

	add	fptr_limit = fptr_limit, gp

search_dynamic:

	ld8	d_tag = [dyn],8

	;;

	ld8	d_val = [dyn],8

	cmp.eq	Pnull,p0 = DT_NULL,d_tag

(Pnull)	br.cond.sptk.few apply_relocs

	cmp.eq	Prela,p0 = DT_RELA,d_tag

	cmp.eq	Prelasz,p0 = DT_RELASZ,d_tag

	cmp.eq	Psymtab,p0 = DT_SYMTAB,d_tag

	cmp.eq	Psyment,p0 = DT_SYMENT,d_tag

	cmp.eq	Prelaent,p0 = DT_RELAENT,d_tag

	;;

(Prela)	add rela = d_val, ldbase

(Prelasz) mov relasz = d_val

(Prelaent) mov relaent = d_val

(Psymtab) add val = d_val, ldbase

(Psyment) setf.sig syment = d_val

	;;

(Psymtab) setf.sig symtab = val

	br.sptk.few search_dynamic

apply_loop:

	ld8	r_offset = [rela]

	add	addr = 8,rela

	sub	relasz = relasz,relaent

	;;

	ld8	r_info = [addr],8

	;;

	ld8	r_addend = [addr]

	add	target = ldbase, r_offset

	add	rela = rela,relaent

	extr.u	r_type = r_info, 0, 32

	;;

	cmp.eq	Pnone,p0 = R_IA64_NONE,r_type

	cmp.eq	Prel,p0 = R_IA64_REL64LSB,r_type

	cmp.eq	Pfptr,p0 = R_IA64_FPTR64LSB,r_type

(Prel)	br.cond.sptk.few apply_REL64

	;;

	cmp.eq	Prel,p0 = R_IA64_DIR64LSB,r_type // treat DIR64 just like REL64

(Pnone)	br.cond.sptk.few apply_relocs

(Prel)	br.cond.sptk.few apply_REL64

(Pfptr)	br.cond.sptk.few apply_FPTR64

	mov	r8 = EFI_LOAD_ERROR

	br.ret.sptk.few rp

apply_relocs:

	cmp.ltu	Pmore,p0=0,relasz

(Pmore)	br.cond.sptk.few apply_loop

	mov	r8 = EFI_SUCCESS

	br.ret.sptk.few rp

apply_REL64:

	ld8 val = [target]

	;;

	add val = val,ldbase

	;;

	st8 [target] = val

	br.cond.sptk.few apply_relocs

	// FPTR relocs are a bit more interesting: we need to lookup

	// the symbol's value in symtab, allocate 16 bytes of memory,

	// store the value in [target] in the first and the gp in the

	// second dword.

apply_FPTR64:

	st8	[target] = fptr

	extr.u	r_sym = r_info,32,32

	add	target = 8,fptr

	;;

	setf.sig ftmp = r_sym

	mov	r8=EFI_BUFFER_TOO_SMALL

	;;

	cmp.geu	Poom,p0 = fptr,fptr_limit

	xma.lu	ftmp = ftmp,syment,symtab

(Poom)	br.ret.sptk.few rp

	;;

	getf.sig addr = ftmp

	st8	[target] = gp

	;;

	add	addr = ST_VALUE_OFF, addr

	;;

	ld8	val = [addr]

	;;

	add	val = val,ldbase

	;;

	st8	[fptr] = val,16

	br.cond.sptk.few apply_relocs

	.endp _relocate

	.data

	.align 16

fptr_mem_base:

	.space  MAX_FUNCTION_DESCRIPTORS*16

fptr_mem_limit: