Skip site navigation (1)Skip section navigation (2)

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
gelf(3ELF)		     ELF Library Functions		    gelf(3ELF)

NAME
       gelf,  gelf_checksum, gelf_fsize, gelf_getcap, gelf_getclass, gelf_get-
       dyn,    gelf_getehdr,	gelf_getmove,	 gelf_getphdr,	  gelf_getrel,
       gelf_getrela,  gelf_getshdr,  gelf_getsym,  gelf_getsyminfo,  gelf_get-
       symshndx, gelf_newehdr, gelf_newphdr, gelf_update_cap, gelf_update_dyn,
       gelf_update_ehdr,	 gelf_update_getmove,	     gelf_update_move,
       gelf_update_phdr, gelf_update_rel, gelf_update_rela,  gelf_update_shdr,
       gelf_update_sym,	      gelf_update_symshndx,	  gelf_update_syminfo,
       gelf_xlatetof, gelf_xlatetom - generic class-independent	ELF interface

SYNOPSIS
       cc [ flag... ] file...  -lelf [ library... ]
       #include	<gelf.h>

       long gelf_checksum(Elf *elf);

       size_t gelf_fsize(Elf *elf, Elf_Type type, size_t cnt, unsigned ver);

       int gelf_getcap(Elf_Data	*src, int ndx, GElf_Cap	*dst);

       int gelf_getclass(Elf *elf);

       GElf_Dyn	*gelf_getdyn(Elf_Data *src, int	ndx, GElf_Dyn *dst);

       GElf_Ehdr *gelf_getehdr(Elf *elf, GElf_Ehdr *dst);

       GElf_Move *gelf_getmove(Elf_Data	*src, int ndx, GElf_Move *dst);

       GElf_Phdr *gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst);

       GElf_Rel	*gelf_getrel(Elf_Data *src, int	ndx, GElf_Rel *dst);

       GElf_Rela *gelf_getrela(Elf_Data	*src, int ndx, GElf_Rela *dst);

       GElf_Shdr *gelf_getshdr(Elf_Scn *scn, GElf_Shdr *dst);

       GElf_Sym	*gelf_getsym(Elf_Data *src, int	ndx, GElf_Sym *dst);

       GElf_Syminfo  *gelf_getsyminfo(Elf_Data	*src,  int  ndx,  GElf_Syminfo
       *dst);

       GElf_Sym	 *gelf_getsymshndx(Elf_Data  *symsrc,  Elf_Data	*shndxsrc, int
       ndx, GElf_Sym *symdst, Elf32_Word *shndxdst);

       unsigned	long gelf_newehdr(Elf *elf, int	class);

       unsigned	long gelf_newphdr(Elf *elf, size_t phnum);

       int gelf_update_cap(Elf_Data *dst, int ndx, GElf_Cap *src);

       int gelf_update_dyn(Elf_Data *dst, int ndx, GElf_Dyn *src);

       int gelf_update_ehdr(Elf	*elf, GElf_Ehdr	*src);

       int gelf_update_move(Elf_Data *dst, int ndx, GElf_Move *src);

       int gelf_update_phdr(Elf	*elf, int ndx, GElf_Phdr *src);

       int gelf_update_rel(Elf_Data *dst, int ndx, GElf_Rel *src);

       int gelf_update_rela(Elf_Data *dst, int ndx, GElf_Rela *src);

       int gelf_update_shdr(Elf_Scn *dst, GElf_Shdr *src);

       int gelf_update_sym(Elf_Data *dst, int ndx, GElf_Sym *src);

       int gelf_update_syminfo(Elf_Data	*dst, int ndx, GElf_Syminfo *src);

       int gelf_update_symshndx(Elf_Data *symdst, Elf_Data *shndxdst, int ndx,
       GElf_Sym	*symsrc, Elf32_Word shndxsrc);

       Elf_Data	 *gelf_xlatetof(Elf  *elf, Elf_Data *dst, const	Elf_Data *src,
       unsigned	encode);

       Elf_Data	*gelf_xlatetom(Elf *elf, Elf_Data *dst,	const  Elf_Data	 *src,
       unsigned	encode);

DESCRIPTION
       GElf  is	 a  generic,  ELF  class-independent  API for manipulating ELF
       object files. GElf provides a single,  common  interface	 for  handling
       32-bit  and 64-bit ELF format object files. GElf	is a translation layer
       between the application	and  the  class-dependent  parts  of  the  ELF
       library.	 Thus,	the application	can use	GElf, which in turn, will call
       the corresponding elf32_	or elf64_ functions on behalf of the  applica-
       tion.  The data structures returned are all large enough	to hold	32-bit
       and 64-bit data.

       GElf provides a simple, class-independent layer of indirection over the
       class-dependent	ELF32  and  ELF64 API's. GElf is stateless, and	may be
       used along side the ELF32 and ELF64 API's.

       GElf always returns a copy of the underlying ELF32 or ELF64  structure,
       and  therefore  the programming practice	of using the address of	an ELF
       header as the base offset for the ELF's mapping into memory  should  be
       avoided.	 Also,	data accessed by type-casting the Elf_Data buffer to a
       class-dependent type and	treating it like an array, for example,	a sym-
       bol table, will not work	under GElf, and	the gelf_get functions must be
       used instead. See the EXAMPLE section.

       Programs	that create or modify ELF files	 using	libelf(3LIB)  need  to
       perform	an  extra  step	 when using GElf. Modifications	to GElf	values
       must be explicitly flushed to the underlying ELF32 or ELF64  structures
       by way of the gelf_update_ interfaces. Use of elf_update	or elf_flagelf
       and the like remains the	same.

       The sizes of versioning structures remain the same  between  ELF32  and
       ELF64.  The  GElf  API only defines types for versioning, rather	than a
       functional API. The processing of versioning information	will stay  the
       same in the GElf	environment as it was in the class-dependent ELF envi-
       ronment.

   List	of Functions
       gelf_checksum()	       An   analog   to	   elf32_checksum(3ELF)	   and
			       elf64_checksum(3ELF).

       gelf_fsize()	       An     analog	to    elf32_fsize(3ELF)	   and
			       elf64_fsize(3ELF).

       gelf_getcap()	       Retrieves the Elf32_Cap or  Elf64_Cap  informa-
			       tion  from  the	capability  table at the given
			       index. dst points to  the  location  where  the
			       GElf_Cap	capability entry is stored.

       gelf_getclass()	       Returns	one  of	the constants ELFCLASS32, ELF-
			       CLASS64 or ELFCLASSNONE.

       gelf_getdyn()	       Retrieves the Elf32_Dyn or  Elf64_Dyn  informa-
			       tion from the dynamic table at the given	index.
			       dst points to the location where	 the  GElf_Dyn
			       dynamic entry is	stored.

       gelf_getehdr()	       An    analog    to    elf32_getehdr(3ELF)   and
			       elf64_getehdr(3ELF). dst	points to the location
			       where the GElf_Ehdr header is stored.

       gelf_getmove()	       Retrieves the Elf32_Move	or Elf64_Move informa-
			       tion from the move table	at  the	 given	index.
			       dst  points to the location where the GElf_Move
			       move entry is stored.

       gelf_getphdr()	       An analog toelf32_getphdr(3ELF) and  elf64_get-
			       phdr(3ELF).  dst	 points	 to the	location where
			       the GElf_Phdr program header is stored.

       gelf_getrel()	       Retrieves the Elf32_Rel or  Elf64_Rel  informa-
			       tion  from  the	relocation  table at the given
			       index. dst points to  the  location  where  the
			       GElf_Rel	relocation entry is stored.

       gelf_getrela()	       Retrieves the Elf32_Rela	or Elf64_Rela informa-
			       tion from the relocation	 table	at  the	 given
			       index.  dst  points  to	the location where the
			       GElf_Rela relocation entry is stored.

       gelf_getshdr()	       An analog to elf32_getshdr(3ELF)	and elf64_get-
			       shdr(3ELF).  dst	 points	 to the	location where
			       the GElf_Shdr section header is stored.

       gelf_getsym()	       Retrieves the Elf32_Sym or  Elf64_Sym  informa-
			       tion  from the symbol table at the given	index.
			       dst points to the location where	 the  GElf_Sym
			       symbol entry is stored.

       gelf_getsyminfo()       Retrieves  the  Elf32_Syminfo  or Elf64_Syminfo
			       information from	the relocation	table  at  the
			       given  index.  dst points to the	location where
			       the GElf_Syminfo	symbol	information  entry  is
			       stored.

       gelf_getsymshndx()      Provides	 an  extension	to  gelf_getsym() that
			       retrieves the Elf32_Sym or  Elf64_Sym  informa-
			       tion, and the section index from	the symbol ta-
			       ble at the given	index ndx.

			       The symbols section index is typically recorded
			       in the st_shndx field of	the symbols structure.
			       However,	a file that requires ELF Extended Sec-
			       tions  may  record  an  st_shndx	 of SHN_XINDEX
			       indicating  that	 the  section  index  must  be
			       obtained	 from  an  associated SHT_SYMTAB_SHNDX
			       section entry. If xshndx	and shndxdata are non-
			       null,  the  value  recorded at index ndx	of the
			       SHT_SYMTAB_SHNDX	table pointed to by  shndxdata
			       is returned in xshndx. See USAGE.

       gelf_newehdr()	       An    analog    to    elf32_newehdr(3ELF)   and
			       elf64_newehdr(3ELF).

       gelf_newphdr()	       An analog to elf32_newphdr(3ELF)	and elf64_new-
			       phdr(3ELF).

       gelf_update_cap()       Copies  the  GElf_Cap information back into the
			       underlying Elf32_Cap or Elf64_Cap structure  at
			       the given index.

       gelf_update_dyn()       Copies  the  GElf_Dyn information back into the
			       underlying Elf32_Dyn or Elf64_Dyn structure  at
			       the given index.

       gelf_update_ehdr()      Copies the contents of the GElf_Ehdr ELF	header
			       to  the	underlying  Elf32_Ehdr	or  Elf64_Ehdr
			       structure.

       gelf_update_move()      Copies  the GElf_Move information back into the
			       underlying Elf32_Move or	 Elf64_Move  structure
			       at the given index.

       gelf_update_phdr()      Copies  of  the	contents  of GElf_Phdr program
			       header  to   underlying	 the   Elf32_Phdr   or
			       Elf64_Phdr structure.

       gelf_update_rel()       Copies  the  GElf_Rel information back into the
			       underlying Elf32_Rel or Elf64_Rel structure  at
			       the given index.

       gelf_update_rela()      Copies  the GElf_Rela information back into the
			       underlying Elf32_Rela or	 Elf64_Rela  structure
			       at the given index.

       gelf_update_shdr()      Copies  of  the	contents  of GElf_Shdr section
			       header  to   underlying	 the   Elf32_Shdr   or
			       Elf64_Shdr structure.

       gelf_update_sym()       Copies  the  GElf_Sym information back into the
			       underlying Elf32_Sym or Elf64_Sym structure  at
			       the given index.

       gelf_update_syminfo()   Copies  the  GElf_Syminfo information back into
			       the underlying Elf32_Syminfo  or	 Elf64_Syminfo
			       structure at the	given index.

       gelf_update_symshndx()  Provides	an extension to	gelf_update_sym() that
			       copies the GElf_Sym information back  into  the
			       Elf32_Sym  or  Elf64_Sym	structure at the given
			       index ndx, and copies the extended xshndx  sec-
			       tion  index  into  the  Elf32_Word at the given
			       index ndx in the	buffer described by shndxdata.
			       See USAGE.

       gelf_xlatetof()	       An    analog    to   elf32_xlatetof(3ELF)   and
			       elf64_xlatetof(3ELF)

       gelf_xlatetom()	       An   analog   to	   elf32_xlatetom(3ELF)	   and
			       elf64_xlatetom(3ELF)

RETURN VALUES
       Upon  failure,  all  GElf  functions  return  0	and set	elf_errno. See
       elf_errno(3ELF)

EXAMPLES
       Example 1: Printing the ELF Symbol Table

       #include	<stdio.h>
       #include	<sys/types.h>
       #include	<sys/stat.h>
       #include	<fcntl.h>
       #include	<libelf.h>
       #include	<gelf.h>

       void
       main(int	argc, char **argv)
       {
	   Elf	       *elf;
	   Elf_Scn     *scn = NULL;
	   GElf_Shdr   shdr;
	   Elf_Data    *data;
	   int	       fd, ii, count;

	   elf_version(EV_CURRENT);

	   fd =	open(argv[1], O_RDONLY);
	   elf = elf_begin(fd, ELF_C_READ, NULL);

	   while ((scn = elf_nextscn(elf, scn))	!= NULL) {
	       gelf_getshdr(scn, &shdr);
	       if (shdr.sh_type	== SHT_SYMTAB) {
		   /* found a symbol table, go print it. */
		   break;
	       }
	   }

	   data	= elf_getdata(scn, NULL);
	   count = shdr.sh_size	/ shdr.sh_entsize;

	   /* print the	symbol names */
	   for (ii = 0;	ii < count; ++ii) {
	       GElf_Sym	sym;
	       gelf_getsym(data, ii, &sym);
	       printf("%s\n", elf_strptr(elf, shdr.sh_link, sym.st_name));
	   }
	   elf_end(elf);
	   close(fd);
       }

USAGE
       ELF Extended Sections are employed to allow an ELF file to contain more
       than 0xff00 (SHN_LORESERVE) section. See	the Linker and Libraries Guide
       for more	information.

FILES
       /lib/libelf.so.1		       shared object

       /lib/64/libelf.so.1	       64-bit shared object

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Stable			   |
       +-----------------------------+-----------------------------+
       |MT Level		     |MT-Safe			   |
       +-----------------------------+-----------------------------+

SEE ALSO
       elf(3ELF),   elf32_checksum(3ELF),    elf32_fsize(3ELF),	   elf32_gete-
       hdr(3ELF),    elf32_newehdr(3ELF),    elf32_getphdr(3ELF),   elf32_new-
       phdr(3ELF),  elf32_getshdr(3ELF),  elf32_xlatetof(3ELF),	  elf32_xlate-
       tom(3ELF), elf_errno(3ELF), libelf(3LIB), attributes(5)

       Linker and Libraries Guide

SunOS 5.10			  8 June 2004			    gelf(3ELF)

NAME | SYNOPSIS | DESCRIPTION | RETURN VALUES | EXAMPLES | USAGE | FILES | ATTRIBUTES | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=gelf&manpath=SunOS+5.10>

home | help