diff --git a/lib/libc/gen/nlist.c b/lib/libc/gen/nlist.c
index b52d7c2a82e3..73b9ea16f7fe 100644
--- a/lib/libc/gen/nlist.c
+++ b/lib/libc/gen/nlist.c
@@ -243,8 +243,8 @@ __elf_fdnlist(fd, list)
 {
 	struct nlist *p;
 	Elf_Off symoff = 0, symstroff = 0;
-	Elf_Word symsize = 0, symstrsize = 0;
-	Elf_Sword cc, i;
+	Elf_Size symsize = 0, symstrsize = 0;
+	Elf_Ssize cc, i;
 	int nent = -1;
 	int errsave;
 	Elf_Sym sbuf[1024];
@@ -252,7 +252,7 @@ __elf_fdnlist(fd, list)
 	Elf_Ehdr ehdr;
 	char *strtab = NULL;
 	Elf_Shdr *shdr = NULL;
-	Elf_Word shdr_size;
+	Elf_Size shdr_size;
 	void *base;
 	struct stat st;
 
diff --git a/libexec/rtld-elf/rtld.c b/libexec/rtld-elf/rtld.c
index 244b5db9b372..ca538d5fa6dc 100644
--- a/libexec/rtld-elf/rtld.c
+++ b/libexec/rtld-elf/rtld.c
@@ -449,7 +449,7 @@ _rtld(Elf_Addr *sp, func_ptr_type *exit_proc, Obj_Entry **objp)
 }
 
 Elf_Addr
-_rtld_bind(Obj_Entry *obj, Elf_Word reloff)
+_rtld_bind(Obj_Entry *obj, Elf_Size reloff)
 {
     const Elf_Rel *rel;
     const Elf_Sym *def;
diff --git a/libexec/rtld-elf/rtld.h b/libexec/rtld-elf/rtld.h
index bee36aff1e70..28fe510c46be 100644
--- a/libexec/rtld-elf/rtld.h
+++ b/libexec/rtld-elf/rtld.h
@@ -122,8 +122,8 @@ typedef struct Struct_Obj_Entry {
      * These two items have to be set right for compatibility with the
      * original ElfKit crt1.o.
      */
-    Elf_Word magic;		/* Magic number (sanity check) */
-    Elf_Word version;		/* Version number of struct format */
+    Elf_Size magic;		/* Magic number (sanity check) */
+    Elf_Size version;		/* Version number of struct format */
 
     struct Struct_Obj_Entry *next;
     char *path;			/* Pathname of underlying file (%) */
diff --git a/libexec/rtld-elf/sparc64/reloc.c b/libexec/rtld-elf/sparc64/reloc.c
index acc6701bcbe0..4e66211fc553 100644
--- a/libexec/rtld-elf/sparc64/reloc.c
+++ b/libexec/rtld-elf/sparc64/reloc.c
@@ -193,7 +193,7 @@ static long reloc_target_bitmask[] = {
 
 static int reloc_nonplt_object(Obj_Entry *obj, const Elf_Rela *rela,
 			       SymCache *cache);
-static void install_plt(Elf_Half *pltgot, Elf_Addr proc);
+static void install_plt(Elf_Word *pltgot, Elf_Addr proc);
 
 extern char _rtld_bind_start_0[];
 extern char _rtld_bind_start_1[];
@@ -280,13 +280,13 @@ reloc_nonplt_object(Obj_Entry *obj, const Elf_Rela *rela, SymCache *cache)
 	const Obj_Entry *defobj;
 	const Elf_Sym *def;
 	Elf_Addr *where;
-	Elf_Half *where32;
+	Elf_Word *where32;
 	Elf_Word type;
 	Elf_Addr value;
 	Elf_Addr mask;
 
 	where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
-	where32 = (Elf_Half *)where;
+	where32 = (Elf_Word *)where;
 	defobj = NULL;
 	def = NULL;
 
@@ -468,7 +468,7 @@ reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target, const Obj_Entry *obj,
 {
 	const Elf_Rela *rela = (const Elf_Rela *)rel;
 	Elf_Addr offset;
-	Elf_Half *where;
+	Elf_Word *where;
 
 	if (rela - refobj->pltrela < 32764) {
 		/*
@@ -496,7 +496,7 @@ reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target, const Obj_Entry *obj,
 		 * have a choice of several different relocation techniques
 		 * which are increasingly expensive.
 		 */
-		where = (Elf_Half *)wherep;
+		where = (Elf_Word *)wherep;
 		offset = ((Elf_Addr)where) - target;
 		if (offset <= (1L<<20) && offset >= -(1L<<20)) {
 			/*
@@ -687,10 +687,10 @@ reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target, const Obj_Entry *obj,
 void
 init_pltgot(Obj_Entry *obj)
 {
-	Elf_Half *entry;
+	Elf_Word *entry;
 
 	if (obj->pltgot != NULL) {
-		entry = (Elf_Half *)obj->pltgot;
+		entry = (Elf_Word *)obj->pltgot;
 		install_plt(&entry[0], (Elf_Addr)_rtld_bind_start_0);
 		install_plt(&entry[8], (Elf_Addr)_rtld_bind_start_1);
 		obj->pltgot[8] = (Elf_Addr)obj;
@@ -698,7 +698,7 @@ init_pltgot(Obj_Entry *obj)
 }
 
 static void
-install_plt(Elf_Half *pltgot, Elf_Addr proc)
+install_plt(Elf_Word *pltgot, Elf_Addr proc)
 {
 	pltgot[0] = SAVE;
 	flush(pltgot, 0);
diff --git a/share/man/man5/elf.5 b/share/man/man5/elf.5
index 82412006d1d6..d19f3d400ce3 100644
--- a/share/man/man5/elf.5
+++ b/share/man/man5/elf.5
@@ -88,23 +88,22 @@ symbol tables.
 .Pp
 The following types are being used for 32-bit architectures:
 .Bd -literal -offset indent
-Elf32_Addr	Unsigned program address
-Elf32_Half	Unsigned halfword field
-Elf32_Off	Unsigned file offset
-Elf32_Sword	Signed large integer
-Elf32_Word	Field or unsigned large integer
-Elf32_Size	Unsigned object size
+Elf32_Addr	Unsigned 32-bit program address
+Elf32_Half	Unsigned 16-bit field
+Elf32_Off	Unsigned 32-bit file offset
+Elf32_Sword	Signed 32-bit field or integer
+Elf32_Word	Unsigned 32-bit field or integer
 .Ed
 .Pp
 For 64-bit architectures we have the following types:
 .Bd -literal -offset indent
-Elf64_Addr	Unsigned program address
-Elf64_Half	Unsigned halfword field
-Elf64_Off	Unsigned file offset
-Elf64_Sword	Signed large integer
-Elf64_Word	Field or unsigned large integer
-Elf64_Size	Unsigned object size
-Elf64_Quarter	Unsigned quarterword field
+Elf64_Addr	Unsigned 64-bit program address
+Elf64_Half	Unsigned 16-bit field
+Elf64_Off	Unsigned 64-bit file offset
+Elf64_Sword	Signed 32-bit field
+Elf64_Word	Unsigned 32-bit field
+Elf64_Sxword	Signed 64-bit field or integer
+Elf64_Xword	Unsigned 64-bit field or integer
 .Ed
 .Pp
 All data structures that the file format defines follow the
@@ -137,19 +136,19 @@ typedef struct {
 .Bd -literal -offset indent
 typedef struct {
 	unsigned char   e_ident[EI_NIDENT];
-	Elf64_Quarter   e_type;
-	Elf64_Quarter   e_machine;
-	Elf64_Half      e_version;
+	Elf64_Half      e_type;
+	Elf64_Half      e_machine;
+	Elf64_Word      e_version;
 	Elf64_Addr      e_entry;
 	Elf64_Off       e_phoff;
 	Elf64_Off       e_shoff;
-	Elf64_Half      e_flags;
-	Elf64_Quarter   e_ehsize;
-	Elf64_Quarter   e_phentsize;
-	Elf64_Quarter   e_phnum;
-	Elf64_Quarter   e_shentsize;
-	Elf64_Quarter   e_shnum;
-	Elf64_Quarter   e_shstrndx;
+	Elf64_Word      e_flags;
+	Elf64_Half      e_ehsize;
+	Elf64_Half      e_phentsize;
+	Elf64_Half      e_phnum;
+	Elf64_Half      e_shentsize;
+	Elf64_Half      e_shnum;
+	Elf64_Half      e_shstrndx;
 } Elf64_Ehdr;
 .Ed
 .Pp
@@ -416,23 +415,23 @@ typedef struct {
         Elf32_Off       p_offset;
         Elf32_Addr      p_vaddr;
         Elf32_Addr      p_paddr;
-        Elf32_Size      p_filesz;
-        Elf32_Size      p_memsz;
+        Elf32_Word      p_filesz;
+        Elf32_Word      p_memsz;
         Elf32_Word      p_flags;
-        Elf32_Size      p_align;
+        Elf32_Word      p_align;
 } Elf32_Phdr;
 .Ed
 .Pp
 .Bd -literal -offset indent
 typedef struct {
-        Elf64_Half      p_type;
-        Elf64_Half      p_flags;
+        Elf64_Word      p_type;
+        Elf64_Word      p_flags;
         Elf64_Off       p_offset;
         Elf64_Addr      p_vaddr;
         Elf64_Addr      p_paddr;
-        Elf64_Size      p_filesz;
-        Elf64_Size      p_memsz;
-        Elf64_Size      p_align;
+        Elf64_Xword     p_filesz;
+        Elf64_Xword     p_memsz;
+        Elf64_Xword     p_align;
 } Elf64_Phdr;
 .Ed
 .Pp
@@ -631,26 +630,26 @@ typedef struct {
 	Elf32_Word      sh_flags;
 	Elf32_Addr      sh_addr;
 	Elf32_Off       sh_offset;
-	Elf32_Size      sh_size;
+	Elf32_Word      sh_size;
 	Elf32_Word      sh_link;
 	Elf32_Word      sh_info;
-	Elf32_Size      sh_addralign;
-	Elf32_Size      sh_entsize;
+	Elf32_Word      sh_addralign;
+	Elf32_Word      sh_entsize;
 } Elf32_Shdr;
 .Ed
 .Pp
 .Bd -literal -offset indent
 typedef struct {
-	Elf64_Half      sh_name;
-	Elf64_Half      sh_type;
-	Elf64_Size      sh_flags;
+	Elf64_Word      sh_name;
+	Elf64_Word      sh_type;
+	Elf64_Xword     sh_flags;
 	Elf64_Addr      sh_addr;
 	Elf64_Off       sh_offset;
-	Elf64_Size      sh_size;
-	Elf64_Half      sh_link;
-	Elf64_Half      sh_info;
-	Elf64_Size      sh_addralign;
-	Elf64_Size      sh_entsize;
+	Elf64_Xword     sh_size;
+	Elf64_Word      sh_link;
+	Elf64_Word      sh_info;
+	Elf64_Xword     sh_addralign;
+	Elf64_Xword     sh_entsize;
 } Elf64_Shdr;
 .Ed
 .Pp
@@ -1073,7 +1072,7 @@ index is a subscript into this array.
 typedef struct {
 	Elf32_Word      st_name;
 	Elf32_Addr      st_value;
-	Elf32_Size      st_size;
+	Elf32_Word      st_size;
 	unsigned char   st_info;
 	unsigned char   st_other;
 	Elf32_Half      st_shndx;
@@ -1082,12 +1081,12 @@ typedef struct {
 .Pp
 .Bd -literal -offset indent
 typedef struct {
-	Elf64_Half      st_name;
+	Elf64_Word      st_name;
 	unsigned char   st_info;
 	unsigned char   st_other;
-	Elf64_Quarter   st_shndx;
+	Elf64_Half      st_shndx;
 	Elf64_Addr      st_value;
-	Elf64_Size      st_size;
+	Elf64_Xword     st_size;
 } Elf64_Sym;
 .Ed
 .Pp
@@ -1217,7 +1216,7 @@ typedef struct {
 .Bd -literal -offset indent
 typedef struct {
 	Elf64_Addr      r_offset;
-	Elf64_Size      r_info;
+	Elf64_Xword     r_info;
 } Elf64_Rel;
 .Ed
 .Pp
@@ -1233,8 +1232,8 @@ typedef struct {
 .Bd -literal -offset indent
 typedef struct {
 	Elf64_Addr      r_offset;
-	Elf64_Size      r_info;
-	Elf64_Off       r_addend;
+	Elf64_Xword     r_info;
+	Elf64_Sxword    r_addend;
 } Elf64_Rela;
 .Ed
 .Pp
diff --git a/sys/alpha/alpha/elf_machdep.c b/sys/alpha/alpha/elf_machdep.c
index 6937e843386b..6a3c0607cc06 100644
--- a/sys/alpha/alpha/elf_machdep.c
+++ b/sys/alpha/alpha/elf_machdep.c
@@ -121,7 +121,7 @@ elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
 	Elf_Addr *where;
 	Elf_Addr addr;
 	Elf_Addr addend;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	const Elf_Rel *rel;
 	const Elf_Rela *rela;
 
diff --git a/sys/amd64/amd64/elf_machdep.c b/sys/amd64/amd64/elf_machdep.c
index 7396503a56ef..0c4a0cce7419 100644
--- a/sys/amd64/amd64/elf_machdep.c
+++ b/sys/amd64/amd64/elf_machdep.c
@@ -119,7 +119,7 @@ elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
 	Elf32_Addr *where32, val32;
 	Elf_Addr addr;
 	Elf_Addr addend;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	const Elf_Rel *rel;
 	const Elf_Rela *rela;
 
diff --git a/sys/boot/common/bootstrap.h b/sys/boot/common/bootstrap.h
index f84c8e3ebafe..d309c2b15e52 100644
--- a/sys/boot/common/bootstrap.h
+++ b/sys/boot/common/bootstrap.h
@@ -240,7 +240,7 @@ int  file_addmodule(struct preloaded_file *fp, char *modname, int version,
 #define ELF_RELOC_RELA	2
 
 struct elf_file;
-typedef Elf_Addr (symaddr_fn)(struct elf_file *ef, Elf_Word symidx);
+typedef Elf_Addr (symaddr_fn)(struct elf_file *ef, Elf_Size symidx);
 
 int	__elfN(loadfile)(char *filename, u_int64_t dest, struct preloaded_file **result);
 int	__elfN(obj_loadfile)(char *filename, u_int64_t dest,
diff --git a/sys/boot/common/load_elf.c b/sys/boot/common/load_elf.c
index a44145b5e520..2235ea82220a 100644
--- a/sys/boot/common/load_elf.c
+++ b/sys/boot/common/load_elf.c
@@ -744,7 +744,7 @@ __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef,
 }
 
 static Elf_Addr
-__elfN(symaddr)(struct elf_file *ef, Elf_Word symidx)
+__elfN(symaddr)(struct elf_file *ef, Elf_Size symidx)
 {
 
 	/* Symbol lookup by index not required here. */
diff --git a/sys/boot/common/load_elf_obj.c b/sys/boot/common/load_elf_obj.c
index 53b1317a0299..4b3aaeae7865 100644
--- a/sys/boot/common/load_elf_obj.c
+++ b/sys/boot/common/load_elf_obj.c
@@ -70,7 +70,7 @@ static int __elfN(obj_reloc_ptr)(struct preloaded_file *mp, elf_file_t ef,
     Elf_Addr p, void *val, size_t len);
 static int __elfN(obj_parse_modmetadata)(struct preloaded_file *mp,
     elf_file_t ef);
-static Elf_Addr __elfN(obj_symaddr)(struct elf_file *ef, Elf_Word symidx);
+static Elf_Addr __elfN(obj_symaddr)(struct elf_file *ef, Elf_Size symidx);
 
 const char	*__elfN(obj_kerneltype) = "elf kernel";
 const char	*__elfN(obj_moduletype) = "elf obj module";
@@ -495,7 +495,7 @@ __elfN(obj_reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, Elf_Addr p,
 
 /* Look up the address of a specified symbol. */
 static Elf_Addr
-__elfN(obj_symaddr)(struct elf_file *ef, Elf_Word symidx)
+__elfN(obj_symaddr)(struct elf_file *ef, Elf_Size symidx)
 {
 	Elf_Sym sym;
 	Elf_Addr base;
diff --git a/sys/boot/common/reloc_elf.c b/sys/boot/common/reloc_elf.c
index d6ff99944318..43b7cbfd51bd 100644
--- a/sys/boot/common/reloc_elf.c
+++ b/sys/boot/common/reloc_elf.c
@@ -54,7 +54,7 @@ __elfN(reloc)(struct elf_file *ef, symaddr_fn *symaddr, const void *reldata,
     int reltype, Elf_Addr relbase, Elf_Addr dataaddr, void *data, size_t len)
 {
 #ifdef __sparc__
-	Elf_Word w;
+	Elf_Size w;
 	const Elf_Rela *a;
 
 	switch (reltype) {
@@ -81,7 +81,7 @@ __elfN(reloc)(struct elf_file *ef, symaddr_fn *symaddr, const void *reldata,
 #elif defined(__i386__) && __ELF_WORD_SIZE == 64
 	Elf64_Addr *where, val;
 	Elf_Addr addend, addr;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	const Elf_Rel *rel;
 	const Elf_Rela *rela;
 
@@ -138,7 +138,7 @@ __elfN(reloc)(struct elf_file *ef, symaddr_fn *symaddr, const void *reldata,
 	return (0);
 #elif defined(__i386__) && __ELF_WORD_SIZE == 32
 	Elf_Addr addend, addr, *where, val;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	const Elf_Rel *rel;
 	const Elf_Rela *rela;
 
diff --git a/sys/ia64/ia64/elf_machdep.c b/sys/ia64/ia64/elf_machdep.c
index 51902ec4d42e..ccd50835694d 100644
--- a/sys/ia64/ia64/elf_machdep.c
+++ b/sys/ia64/ia64/elf_machdep.c
@@ -118,7 +118,7 @@ elf64_dump_thread(struct thread *td, void *dst, size_t *off __unused)
 
 
 static Elf_Addr
-lookup_fdesc(linker_file_t lf, Elf_Word symidx, elf_lookup_fn lookup)
+lookup_fdesc(linker_file_t lf, Elf_Size symidx, elf_lookup_fn lookup)
 {
 	linker_file_t top;
 	Elf_Addr addr;
@@ -171,7 +171,7 @@ elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
 {
 	Elf_Addr *where;
 	Elf_Addr addend, addr;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	const Elf_Rel *rel;
 	const Elf_Rela *rela;
 
diff --git a/sys/kern/link_elf.c b/sys/kern/link_elf.c
index 29b54e51d245..7b3f1abc1b08 100644
--- a/sys/kern/link_elf.c
+++ b/sys/kern/link_elf.c
@@ -120,7 +120,7 @@ static int	link_elf_each_function_name(linker_file_t,
 				int (*)(const char *, void *),
 				void *);
 static void	link_elf_reloc_local(linker_file_t);
-static Elf_Addr	elf_lookup(linker_file_t lf, Elf_Word symidx, int deps);
+static Elf_Addr	elf_lookup(linker_file_t lf, Elf_Size symidx, int deps);
 
 static kobj_method_t link_elf_methods[] = {
     KOBJMETHOD(linker_lookup_symbol,	link_elf_lookup_symbol),
@@ -909,7 +909,7 @@ link_elf_unload_preload(linker_file_t file)
 }
 
 static const char *
-symbol_name(elf_file_t ef, Elf_Word r_info)
+symbol_name(elf_file_t ef, Elf_Size r_info)
 {
     const Elf_Sym *ref;
 
@@ -1232,7 +1232,7 @@ link_elf_get_gp(linker_file_t lf)
 #endif
 
 const Elf_Sym *
-elf_get_sym(linker_file_t lf, Elf_Word symidx)
+elf_get_sym(linker_file_t lf, Elf_Size symidx)
 {
 	elf_file_t ef = (elf_file_t)lf;
 
@@ -1242,7 +1242,7 @@ elf_get_sym(linker_file_t lf, Elf_Word symidx)
 }
 
 const char *
-elf_get_symname(linker_file_t lf, Elf_Word symidx)
+elf_get_symname(linker_file_t lf, Elf_Size symidx)
 {
 	elf_file_t ef = (elf_file_t)lf;
 	const Elf_Sym *sym;
@@ -1261,7 +1261,7 @@ elf_get_symname(linker_file_t lf, Elf_Word symidx)
  * the case that the symbol can be found through the hash table.
  */
 static Elf_Addr
-elf_lookup(linker_file_t lf, Elf_Word symidx, int deps)
+elf_lookup(linker_file_t lf, Elf_Size symidx, int deps)
 {
 	elf_file_t ef = (elf_file_t)lf;
 	const Elf_Sym *sym;
diff --git a/sys/kern/link_elf_obj.c b/sys/kern/link_elf_obj.c
index a338610da77f..de43b7a43068 100644
--- a/sys/kern/link_elf_obj.c
+++ b/sys/kern/link_elf_obj.c
@@ -124,7 +124,7 @@ static int	link_elf_each_function_name(linker_file_t,
 		    int (*)(const char *, void *), void *);
 static void	link_elf_reloc_local(linker_file_t);
 
-static Elf_Addr elf_obj_lookup(linker_file_t lf, Elf_Word symidx, int deps);
+static Elf_Addr elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps);
 
 static kobj_method_t link_elf_methods[] = {
 	KOBJMETHOD(linker_lookup_symbol,	link_elf_lookup_symbol),
@@ -843,7 +843,7 @@ link_elf_unload_file(linker_file_t file)
 }
 
 static const char *
-symbol_name(elf_file_t ef, Elf_Word r_info)
+symbol_name(elf_file_t ef, Elf_Size r_info)
 {
 	const Elf_Sym *ref;
 
@@ -879,7 +879,7 @@ relocate_file(elf_file_t ef)
 	const char *symname;
 	const Elf_Sym *sym;
 	int i;
-	Elf_Word symidx;
+	Elf_Size symidx;
 	Elf_Addr base;
 
 
@@ -1069,7 +1069,7 @@ link_elf_each_function_name(linker_file_t file,
  * the case that the symbol can be found through the hash table.
  */
 static Elf_Addr
-elf_obj_lookup(linker_file_t lf, Elf_Word symidx, int deps)
+elf_obj_lookup(linker_file_t lf, Elf_Size symidx, int deps)
 {
 	elf_file_t ef = (elf_file_t)lf;
 	const Elf_Sym *sym;
@@ -1122,7 +1122,7 @@ link_elf_reloc_local(linker_file_t lf)
 	const Elf_Sym *sym;
 	Elf_Addr base;
 	int i;
-	Elf_Word symidx;
+	Elf_Size symidx;
 
 	/* Perform relocations without addend if there are any: */
 	for (i = 0; i < ef->nrel; i++) {
diff --git a/sys/sparc64/sparc64/elf_machdep.c b/sys/sparc64/sparc64/elf_machdep.c
index edc18ac0e195..b113afed7855 100644
--- a/sys/sparc64/sparc64/elf_machdep.c
+++ b/sys/sparc64/sparc64/elf_machdep.c
@@ -288,9 +288,9 @@ elf_reloc(linker_file_t lf, Elf_Addr relocbase, const void *data, int type,
     elf_lookup_fn lookup)
 {
 	const Elf_Rela *rela;
-	Elf_Half *where32;
+	Elf_Word *where32;
 	Elf_Addr *where;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	Elf_Addr value;
 	Elf_Addr mask;
 	Elf_Addr addr;
@@ -300,7 +300,7 @@ elf_reloc(linker_file_t lf, Elf_Addr relocbase, const void *data, int type,
 
 	rela = (const Elf_Rela *)data;
 	where = (Elf_Addr *)(relocbase + rela->r_offset);
-	where32 = (Elf_Half *)where;
+	where32 = (Elf_Word *)where;
 	rtype = ELF_R_TYPE(rela->r_info);
 	symidx = ELF_R_SYM(rela->r_info);
 
diff --git a/sys/sys/elf32.h b/sys/sys/elf32.h
index b0c083c3eb23..412db54f43f1 100644
--- a/sys/sys/elf32.h
+++ b/sys/sys/elf32.h
@@ -35,13 +35,17 @@
  * ELF definitions common to all 32-bit architectures.
  */
 
-typedef u_int32_t	Elf32_Addr;
-typedef u_int16_t	Elf32_Half;
-typedef u_int32_t	Elf32_Off;
+typedef uint32_t	Elf32_Addr;
+typedef uint16_t	Elf32_Half;
+typedef uint32_t	Elf32_Off;
 typedef int32_t		Elf32_Sword;
-typedef u_int32_t	Elf32_Word;
-typedef u_int32_t	Elf32_Size;
-typedef Elf32_Off	Elf32_Hashelt;
+typedef uint32_t	Elf32_Word;
+
+typedef Elf32_Word	Elf32_Hashelt;
+
+/* Non-standard class-dependent datatype used for abstraction. */
+typedef Elf32_Word	Elf32_Size;
+typedef Elf32_Sword	Elf32_Ssize;
 
 /*
  * ELF header.
@@ -75,11 +79,11 @@ typedef struct {
 	Elf32_Word	sh_flags;	/* Section flags. */
 	Elf32_Addr	sh_addr;	/* Address in memory image. */
 	Elf32_Off	sh_offset;	/* Offset in file. */
-	Elf32_Size	sh_size;	/* Size in bytes. */
+	Elf32_Word	sh_size;	/* Size in bytes. */
 	Elf32_Word	sh_link;	/* Index of a related section. */
 	Elf32_Word	sh_info;	/* Depends on section type. */
-	Elf32_Size	sh_addralign;	/* Alignment in bytes. */
-	Elf32_Size	sh_entsize;	/* Size of each entry in section. */
+	Elf32_Word	sh_addralign;	/* Alignment in bytes. */
+	Elf32_Word	sh_entsize;	/* Size of each entry in section. */
 } Elf32_Shdr;
 
 /*
@@ -91,10 +95,10 @@ typedef struct {
 	Elf32_Off	p_offset;	/* File offset of contents. */
 	Elf32_Addr	p_vaddr;	/* Virtual address in memory image. */
 	Elf32_Addr	p_paddr;	/* Physical address (not used). */
-	Elf32_Size	p_filesz;	/* Size of contents in file. */
-	Elf32_Size	p_memsz;	/* Size of contents in memory. */
+	Elf32_Word	p_filesz;	/* Size of contents in file. */
+	Elf32_Word	p_memsz;	/* Size of contents in memory. */
 	Elf32_Word	p_flags;	/* Access permission flags. */
-	Elf32_Size	p_align;	/* Alignment in memory and file. */
+	Elf32_Word	p_align;	/* Alignment in memory and file. */
 } Elf32_Phdr;
 
 /*
@@ -104,7 +108,7 @@ typedef struct {
 typedef struct {
 	Elf32_Sword	d_tag;		/* Entry type. */
 	union {
-		Elf32_Size	d_val;	/* Integer value. */
+		Elf32_Word	d_val;	/* Integer value. */
 		Elf32_Addr	d_ptr;	/* Address value. */
 	} d_un;
 } Elf32_Dyn;
@@ -140,7 +144,7 @@ typedef struct {
 typedef struct {
 	Elf32_Word	st_name;	/* String table index of name. */
 	Elf32_Addr	st_value;	/* Symbol value. */
-	Elf32_Size	st_size;	/* Size of associated object. */
+	Elf32_Word	st_size;	/* Size of associated object. */
 	unsigned char	st_info;	/* Type and binding information. */
 	unsigned char	st_other;	/* Reserved (not used). */
 	Elf32_Half	st_shndx;	/* Section index of symbol. */
diff --git a/sys/sys/elf64.h b/sys/sys/elf64.h
index 0f236e51486e..c39cd1382af2 100644
--- a/sys/sys/elf64.h
+++ b/sys/sys/elf64.h
@@ -35,13 +35,13 @@
  * ELF definitions common to all 64-bit architectures.
  */
 
-typedef u_int64_t	Elf64_Addr;
-typedef u_int32_t	Elf64_Half;
-typedef u_int64_t	Elf64_Off;
-typedef int64_t		Elf64_Sword;
-typedef u_int64_t	Elf64_Word;
-typedef u_int64_t	Elf64_Size;
-typedef u_int16_t	Elf64_Quarter;
+typedef uint64_t	Elf64_Addr;
+typedef uint16_t	Elf64_Half;
+typedef uint64_t	Elf64_Off;
+typedef int32_t		Elf64_Sword;
+typedef int64_t		Elf64_Sxword;
+typedef uint32_t	Elf64_Word;
+typedef uint64_t	Elf64_Xword;
 
 /*
  * Types of dynamic symbol hash table bucket and chain elements.
@@ -53,28 +53,32 @@ typedef u_int16_t	Elf64_Quarter;
 #ifdef __alpha__
 typedef Elf64_Off	Elf64_Hashelt;
 #else
-typedef Elf64_Half	Elf64_Hashelt;
+typedef Elf64_Word	Elf64_Hashelt;
 #endif
 
+/* Non-standard class-dependent datatype used for abstraction. */
+typedef Elf64_Xword	Elf64_Size;
+typedef Elf64_Sxword	Elf64_Ssize;
+
 /*
  * ELF header.
  */
 
 typedef struct {
 	unsigned char	e_ident[EI_NIDENT];	/* File identification. */
-	Elf64_Quarter	e_type;		/* File type. */
-	Elf64_Quarter	e_machine;	/* Machine architecture. */
-	Elf64_Half	e_version;	/* ELF format version. */
+	Elf64_Half	e_type;		/* File type. */
+	Elf64_Half	e_machine;	/* Machine architecture. */
+	Elf64_Word	e_version;	/* ELF format version. */
 	Elf64_Addr	e_entry;	/* Entry point. */
 	Elf64_Off	e_phoff;	/* Program header file offset. */
 	Elf64_Off	e_shoff;	/* Section header file offset. */
-	Elf64_Half	e_flags;	/* Architecture-specific flags. */
-	Elf64_Quarter	e_ehsize;	/* Size of ELF header in bytes. */
-	Elf64_Quarter	e_phentsize;	/* Size of program header entry. */
-	Elf64_Quarter	e_phnum;	/* Number of program header entries. */
-	Elf64_Quarter	e_shentsize;	/* Size of section header entry. */
-	Elf64_Quarter	e_shnum;	/* Number of section header entries. */
-	Elf64_Quarter	e_shstrndx;	/* Section name strings section. */
+	Elf64_Word	e_flags;	/* Architecture-specific flags. */
+	Elf64_Half	e_ehsize;	/* Size of ELF header in bytes. */
+	Elf64_Half	e_phentsize;	/* Size of program header entry. */
+	Elf64_Half	e_phnum;	/* Number of program header entries. */
+	Elf64_Half	e_shentsize;	/* Size of section header entry. */
+	Elf64_Half	e_shnum;	/* Number of section header entries. */
+	Elf64_Half	e_shstrndx;	/* Section name strings section. */
 } Elf64_Ehdr;
 
 /*
@@ -82,17 +86,17 @@ typedef struct {
  */
 
 typedef struct {
-	Elf64_Half	sh_name;	/* Section name (index into the
+	Elf64_Word	sh_name;	/* Section name (index into the
 					   section header string table). */
-	Elf64_Half	sh_type;	/* Section type. */
-	Elf64_Size	sh_flags;	/* Section flags. */
+	Elf64_Word	sh_type;	/* Section type. */
+	Elf64_Xword	sh_flags;	/* Section flags. */
 	Elf64_Addr	sh_addr;	/* Address in memory image. */
 	Elf64_Off	sh_offset;	/* Offset in file. */
-	Elf64_Size	sh_size;	/* Size in bytes. */
-	Elf64_Half	sh_link;	/* Index of a related section. */
-	Elf64_Half	sh_info;	/* Depends on section type. */
-	Elf64_Size	sh_addralign;	/* Alignment in bytes. */
-	Elf64_Size	sh_entsize;	/* Size of each entry in section. */
+	Elf64_Xword	sh_size;	/* Size in bytes. */
+	Elf64_Word	sh_link;	/* Index of a related section. */
+	Elf64_Word	sh_info;	/* Depends on section type. */
+	Elf64_Xword	sh_addralign;	/* Alignment in bytes. */
+	Elf64_Xword	sh_entsize;	/* Size of each entry in section. */
 } Elf64_Shdr;
 
 /*
@@ -100,14 +104,14 @@ typedef struct {
  */
 
 typedef struct {
-	Elf64_Half	p_type;		/* Entry type. */
-	Elf64_Half	p_flags;	/* Access permission flags. */
+	Elf64_Word	p_type;		/* Entry type. */
+	Elf64_Word	p_flags;	/* Access permission flags. */
 	Elf64_Off	p_offset;	/* File offset of contents. */
 	Elf64_Addr	p_vaddr;	/* Virtual address in memory image. */
 	Elf64_Addr	p_paddr;	/* Physical address (not used). */
-	Elf64_Size	p_filesz;	/* Size of contents in file. */
-	Elf64_Size	p_memsz;	/* Size of contents in memory. */
-	Elf64_Size	p_align;	/* Alignment in memory and file. */
+	Elf64_Xword	p_filesz;	/* Size of contents in file. */
+	Elf64_Xword	p_memsz;	/* Size of contents in memory. */
+	Elf64_Xword	p_align;	/* Alignment in memory and file. */
 } Elf64_Phdr;
 
 /*
@@ -115,9 +119,9 @@ typedef struct {
  */
 
 typedef struct {
-	Elf64_Size	d_tag;		/* Entry type. */
+	Elf64_Sxword	d_tag;		/* Entry type. */
 	union {
-		Elf64_Size	d_val;	/* Integer value. */
+		Elf64_Xword	d_val;	/* Integer value. */
 		Elf64_Addr	d_ptr;	/* Address value. */
 	} d_un;
 } Elf64_Dyn;
@@ -129,14 +133,14 @@ typedef struct {
 /* Relocations that don't need an addend field. */
 typedef struct {
 	Elf64_Addr	r_offset;	/* Location to be relocated. */
-	Elf64_Size	r_info;		/* Relocation type and symbol index. */
+	Elf64_Xword	r_info;		/* Relocation type and symbol index. */
 } Elf64_Rel;
 
 /* Relocations that need an addend field. */
 typedef struct {
 	Elf64_Addr	r_offset;	/* Location to be relocated. */
-	Elf64_Size	r_info;		/* Relocation type and symbol index. */
-	Elf64_Off	r_addend;	/* Addend. */
+	Elf64_Xword	r_info;		/* Relocation type and symbol index. */
+	Elf64_Sxword	r_addend;	/* Addend. */
 } Elf64_Rela;
 
 /* Macros for accessing the fields of r_info. */
@@ -151,12 +155,12 @@ typedef struct {
  */
 
 typedef struct {
-	Elf64_Half	st_name;	/* String table index of name. */
+	Elf64_Word	st_name;	/* String table index of name. */
 	unsigned char	st_info;	/* Type and binding information. */
 	unsigned char	st_other;	/* Reserved (not used). */
-	Elf64_Quarter	st_shndx;	/* Section index of symbol. */
+	Elf64_Half	st_shndx;	/* Section index of symbol. */
 	Elf64_Addr	st_value;	/* Symbol value. */
-	Elf64_Size	st_size;	/* Size of associated object. */
+	Elf64_Xword	st_size;	/* Size of associated object. */
 } Elf64_Sym;
 
 /* Macros for accessing the fields of st_info. */
diff --git a/sys/sys/elf_generic.h b/sys/sys/elf_generic.h
index cc0c471ad90c..c1e5a6639617 100644
--- a/sys/sys/elf_generic.h
+++ b/sys/sys/elf_generic.h
@@ -60,8 +60,6 @@ __ElfType(Half);
 __ElfType(Off);
 __ElfType(Sword);
 __ElfType(Word);
-__ElfType(Size);
-__ElfType(Hashelt);
 __ElfType(Ehdr);
 __ElfType(Shdr);
 __ElfType(Phdr);
@@ -70,6 +68,11 @@ __ElfType(Rel);
 __ElfType(Rela);
 __ElfType(Sym);
 
+/* Non-standard ELF types. */
+__ElfType(Hashelt);
+__ElfType(Size);
+__ElfType(Ssize);
+
 #define ELF_R_SYM	__ELFN(R_SYM)
 #define ELF_R_TYPE	__ELFN(R_TYPE)
 #define ELF_R_INFO	__ELFN(R_INFO)
diff --git a/sys/sys/imgact_elf.h b/sys/sys/imgact_elf.h
index 345478744fde..8bb4cc25a976 100644
--- a/sys/sys/imgact_elf.h
+++ b/sys/sys/imgact_elf.h
@@ -44,15 +44,15 @@ struct thread;
  * stack fixup routine.
  */
 typedef struct {
-	Elf_Sword	execfd;
-	Elf_Word	phdr;
-	Elf_Word	phent;
-	Elf_Word	phnum;
-	Elf_Word	pagesz;
-	Elf_Word	base;
-	Elf_Word	flags;
-	Elf_Word	entry;
-	Elf_Word	trace;
+	Elf_Ssize	execfd;
+	Elf_Size	phdr;
+	Elf_Size	phent;
+	Elf_Size	phnum;
+	Elf_Size	pagesz;
+	Elf_Size	base;
+	Elf_Size	flags;
+	Elf_Size	entry;
+	Elf_Size	trace;
 } __ElfN(Auxargs);
 
 typedef struct {
diff --git a/sys/sys/linker.h b/sys/sys/linker.h
index ba91af249aae..90ed2433405f 100644
--- a/sys/sys/linker.h
+++ b/sys/sys/linker.h
@@ -242,13 +242,13 @@ extern int kld_debug;
 
 #endif
 
-typedef Elf_Addr elf_lookup_fn(linker_file_t, Elf_Word, int);
+typedef Elf_Addr elf_lookup_fn(linker_file_t, Elf_Size, int);
 
 /* Support functions */
 int	elf_reloc(linker_file_t _lf, Elf_Addr base, const void *_rel, int _type, elf_lookup_fn _lu);
 int	elf_reloc_local(linker_file_t _lf, Elf_Addr base, const void *_rel, int _type, elf_lookup_fn _lu);
-const Elf_Sym *elf_get_sym(linker_file_t _lf, Elf_Word _symidx);
-const char *elf_get_symname(linker_file_t _lf, Elf_Word _symidx);
+const Elf_Sym *elf_get_sym(linker_file_t _lf, Elf_Size _symidx);
+const char *elf_get_symname(linker_file_t _lf, Elf_Size _symidx);
 
 int elf_cpu_load_file(linker_file_t);
 int elf_cpu_unload_file(linker_file_t);
diff --git a/usr.bin/elf2aout/elf2aout.c b/usr.bin/elf2aout/elf2aout.c
index 3abf8188fcaf..f4e6560e95f1 100644
--- a/usr.bin/elf2aout/elf2aout.c
+++ b/usr.bin/elf2aout/elf2aout.c
@@ -66,15 +66,15 @@ static void usage(void);
 int
 main(int ac, char **av)
 {
-	Elf64_Quarter phentsize;
-	Elf64_Quarter machine;
-	Elf64_Quarter phnum;
-	Elf64_Size filesz;
-	Elf64_Size memsz;
+	Elf64_Half phentsize;
+	Elf64_Half machine;
+	Elf64_Half phnum;
+	Elf64_Xword filesz;
+	Elf64_Xword memsz;
 	Elf64_Addr entry;
 	Elf64_Off offset;
 	Elf64_Off phoff;
-	Elf64_Half type;
+	Elf64_Word type;
 	unsigned char data;
 	struct stat sb;
 	struct exec a;
diff --git a/usr.sbin/crunch/crunchide/exec_elf32.c b/usr.sbin/crunch/crunchide/exec_elf32.c
index 5558b1c8088e..25207d2f680f 100644
--- a/usr.sbin/crunch/crunchide/exec_elf32.c
+++ b/usr.sbin/crunch/crunchide/exec_elf32.c
@@ -192,7 +192,7 @@ ELFNAMEEND(hide)(int fd, const char *fn)
 	Elf_Shdr *shdrp = NULL, *symtabshdr, *strtabshdr;
 	Elf_Sym *symtabp = NULL;
 	char *strtabp = NULL;
-	Elf_Word *symfwmap = NULL, *symrvmap = NULL, nsyms, nlocalsyms, ewi;
+	Elf_Size *symfwmap = NULL, *symrvmap = NULL, nsyms, nlocalsyms, ewi;
 	struct listelem *relalist = NULL, *rellist = NULL, *tmpl;
 	ssize_t shdrsize;
 	int rv, i, weird;
@@ -295,10 +295,10 @@ ELFNAMEEND(hide)(int fd, const char *fn)
 	/* Prepare data structures for symbol movement. */
 	nsyms = xewtoh(symtabshdr->sh_size) / xewtoh(symtabshdr->sh_entsize);
 	nlocalsyms = xe32toh(symtabshdr->sh_info);
-	if ((symfwmap = xmalloc(nsyms * sizeof (Elf_Word), fn,
+	if ((symfwmap = xmalloc(nsyms * sizeof (Elf_Size), fn,
 	    "symbol forward mapping table")) == NULL)
 		goto bad;
-	if ((symrvmap = xmalloc(nsyms * sizeof (Elf_Word), fn,
+	if ((symrvmap = xmalloc(nsyms * sizeof (Elf_Size), fn,
 	    "symbol reverse mapping table")) == NULL)
 		goto bad;
 
@@ -309,7 +309,7 @@ ELFNAMEEND(hide)(int fd, const char *fn)
 	/* move symbols, making them local */
 	for (ewi = nlocalsyms; ewi < nsyms; ewi++) {
 		Elf_Sym *sp, symswap;
-		Elf_Word mapswap;
+		Elf_Size mapswap;
 
 		sp = &symtabp[ewi];
 
diff --git a/usr.sbin/kldxref/ef.c b/usr.sbin/kldxref/ef.c
index c6751c9d7a19..276771d1985b 100644
--- a/usr.sbin/kldxref/ef.c
+++ b/usr.sbin/kldxref/ef.c
@@ -92,7 +92,7 @@ static int ef_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
     void **ptr);
 static int ef_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len,
     void **ptr);
-static Elf_Addr ef_symaddr(elf_file_t ef, Elf_Word symidx);
+static Elf_Addr ef_symaddr(elf_file_t ef, Elf_Size symidx);
 static int ef_lookup_set(elf_file_t ef, const char *name, long *startp,
     long *stopp, long *countp);
 static int ef_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym);
@@ -246,7 +246,7 @@ ef_lookup_set(elf_file_t ef, const char *name, long *startp, long *stopp,
 }
 
 static Elf_Addr
-ef_symaddr(elf_file_t ef, Elf_Word symidx)
+ef_symaddr(elf_file_t ef, Elf_Size symidx)
 {
 	const Elf_Sym *sym;
 
diff --git a/usr.sbin/kldxref/ef.h b/usr.sbin/kldxref/ef.h
index 3843ebebbaef..5bb19857507a 100644
--- a/usr.sbin/kldxref/ef.h
+++ b/usr.sbin/kldxref/ef.h
@@ -48,7 +48,7 @@ struct elf_file_ops {
 	    void**ptr);
 	int (*seg_read_entry_rel)(elf_file_t ef, Elf_Off offset, size_t len,
 	    void**ptr);
-	Elf_Addr (*symaddr)(elf_file_t ef, Elf_Word symidx);
+	Elf_Addr (*symaddr)(elf_file_t ef, Elf_Size symidx);
 	int (*lookup_set)(elf_file_t ef, const char *name, long *startp,
 	    long *stopp, long *countp);
 	int (*lookup_symbol)(elf_file_t ef, const char* name, Elf_Sym** sym);
diff --git a/usr.sbin/kldxref/ef_amd64.c b/usr.sbin/kldxref/ef_amd64.c
index 445640ae27af..5a1d192a3def 100644
--- a/usr.sbin/kldxref/ef_amd64.c
+++ b/usr.sbin/kldxref/ef_amd64.c
@@ -48,7 +48,7 @@ ef_reloc(struct elf_file *ef, const void *reldata, int reltype, Elf_Off relbase,
 	Elf64_Addr *where, val;
 	Elf32_Addr *where32, val32;
 	Elf_Addr addend, addr;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	const Elf_Rel *rel;
 	const Elf_Rela *rela;
 
diff --git a/usr.sbin/kldxref/ef_i386.c b/usr.sbin/kldxref/ef_i386.c
index 0fc726af7ca6..49173543ae40 100644
--- a/usr.sbin/kldxref/ef_i386.c
+++ b/usr.sbin/kldxref/ef_i386.c
@@ -46,7 +46,7 @@ ef_reloc(struct elf_file *ef, const void *reldata, int reltype, Elf_Off relbase,
     Elf_Off dataoff, size_t len, void *dest)
 {
 	Elf_Addr *where, addr, addend;
-	Elf_Word rtype, symidx;
+	Elf_Size rtype, symidx;
 	const Elf_Rel *rel;
 	const Elf_Rela *rela;
 
diff --git a/usr.sbin/kldxref/ef_obj.c b/usr.sbin/kldxref/ef_obj.c
index 3ed4e40561b6..b35337b956d3 100644
--- a/usr.sbin/kldxref/ef_obj.c
+++ b/usr.sbin/kldxref/ef_obj.c
@@ -113,7 +113,7 @@ static int ef_obj_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
     void **ptr);
 static int ef_obj_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len,
     void **ptr);
-static Elf_Addr ef_obj_symaddr(elf_file_t ef, Elf_Word symidx);
+static Elf_Addr ef_obj_symaddr(elf_file_t ef, Elf_Size symidx);
 static int ef_obj_lookup_set(elf_file_t ef, const char *name, long *startp,
     long *stopp, long *countp);
 static int ef_obj_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym);
@@ -176,7 +176,7 @@ ef_obj_lookup_set(elf_file_t ef, const char *name, long *startp, long *stopp,
 }
 
 static Elf_Addr
-ef_obj_symaddr(elf_file_t ef, Elf_Word symidx)
+ef_obj_symaddr(elf_file_t ef, Elf_Size symidx)
 {
 	const Elf_Sym *sym;
 
diff --git a/usr.sbin/kldxref/ef_powerpc.c b/usr.sbin/kldxref/ef_powerpc.c
index aafd9c34b84e..a96a727a3eba 100644
--- a/usr.sbin/kldxref/ef_powerpc.c
+++ b/usr.sbin/kldxref/ef_powerpc.c
@@ -48,7 +48,7 @@ ef_reloc(struct elf_file *ef, const void *reldata, int reltype, Elf_Off relbase,
     Elf_Off dataoff, size_t len, void *dest)
 {
         Elf_Addr *where, addend;
-        Elf_Word rtype, symidx;
+        Elf_Size rtype, symidx;
         const Elf_Rela *rela;
 
 	if (reltype != EF_RELOC_RELA)
diff --git a/usr.sbin/kldxref/ef_sparc64.c b/usr.sbin/kldxref/ef_sparc64.c
index dae648839dc1..7ba2a43ba7ce 100644
--- a/usr.sbin/kldxref/ef_sparc64.c
+++ b/usr.sbin/kldxref/ef_sparc64.c
@@ -44,7 +44,7 @@ ef_reloc(struct elf_file *ef, const void *reldata, int reltype, Elf_Off relbase,
     Elf_Off dataoff, size_t len, void *dest)
 {
 	const Elf_Rela *a;
-	Elf_Word w;
+	Elf_Size w;
 
 	switch (reltype) {
 	case EF_RELOC_RELA: