kldxref: improve style(9)

Address style issues including some previously raised in D13923.

- Use designated initializers for structs
- Always use bracketed return style
- No initialization in declarations
- Align function prototype names
- Remove old commented code/unused includes

Submitted by:	Mitchell Horne <mhorne063@gmail.com>
Reviewed by:	kib
Sponsored by:	The FreeBSD Foundation
Differential Revision:	https://reviews.freebsd.org/D13943

5 files changed, 228 insertions, 226 deletions

diff --git a/usr.sbin/kldxref/ef.c b/usr.sbin/kldxref/ef.c
index 7a3955bbf5ec..3d5e7713ab11 100644
--- a/usr.sbin/kldxref/ef.c
+++ b/usr.sbin/kldxref/ef.c
@@ -36,84 +36,89 @@
 
 #include <sys/param.h>
 #include <sys/linker.h>
-#include <string.h>
+
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
 #include <machine/elf.h>
 #define FREEBSD_ELF
 
-#include <err.h>
-
 #include "ef.h"
 
 #define	MAXSEGS 3
 struct ef_file {
-	char*		ef_name;
+	char		*ef_name;
 	struct elf_file *ef_efile;
-	Elf_Phdr *	ef_ph;
+	Elf_Phdr	*ef_ph;
 	int		ef_fd;
 	int		ef_type;
 	Elf_Ehdr	ef_hdr;
-	void*		ef_fpage;		/* First block of the file */
+	void		*ef_fpage;		/* First block of the file */
 	int		ef_fplen;		/* length of first block */
-	Elf_Dyn*	ef_dyn;			/* Symbol table etc. */
+	Elf_Dyn		*ef_dyn;		/* Symbol table etc. */
 	Elf_Hashelt	ef_nbuckets;
 	Elf_Hashelt	ef_nchains;
-	Elf_Hashelt*	ef_buckets;
-	Elf_Hashelt*	ef_chains;
-	Elf_Hashelt*	ef_hashtab;
+	Elf_Hashelt	*ef_buckets;
+	Elf_Hashelt	*ef_chains;
+	Elf_Hashelt	*ef_hashtab;
 	Elf_Off		ef_stroff;
 	caddr_t		ef_strtab;
 	int		ef_strsz;
 	Elf_Off		ef_symoff;
-	Elf_Sym*	ef_symtab;
+	Elf_Sym		*ef_symtab;
 	int		ef_nsegs;
-	Elf_Phdr *	ef_segs[MAXSEGS];
+	Elf_Phdr	*ef_segs[MAXSEGS];
 	int		ef_verbose;
-	Elf_Rel *	ef_rel;			/* relocation table */
+	Elf_Rel		*ef_rel;		/* relocation table */
 	int		ef_relsz;		/* number of entries */
-	Elf_Rela *	ef_rela;		/* relocation table */
+	Elf_Rela	*ef_rela;		/* relocation table */
 	int		ef_relasz;		/* number of entries */
 };
 
-static void ef_print_phdr(Elf_Phdr *);
-static u_long ef_get_offset(elf_file_t, Elf_Off);
-static int ef_parse_dynamic(elf_file_t);
-
-static int ef_get_type(elf_file_t ef);
-static int ef_close(elf_file_t ef);
-static int ef_read(elf_file_t ef, Elf_Off offset, size_t len, void* dest);
-static int ef_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void **ptr);
-static int ef_seg_read(elf_file_t ef, Elf_Off offset, size_t len, void *dest);
-static int ef_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len,
-    void *dest);
-static int ef_seg_read_string(elf_file_t ef, Elf_Off offset, size_t len,
-    char *dest);
-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_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);
+static void	ef_print_phdr(Elf_Phdr *);
+static u_long	ef_get_offset(elf_file_t, Elf_Off);
+static int	ef_parse_dynamic(elf_file_t);
+
+static int	ef_get_type(elf_file_t ef);
+static int	ef_close(elf_file_t ef);
+static int	ef_read(elf_file_t ef, Elf_Off offset, size_t len, void* dest);
+static int	ef_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
+		    void **ptr);
+
+static int	ef_seg_read(elf_file_t ef, Elf_Off offset, size_t len,
+		    void *dest);
+static int	ef_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len,
+		    void *dest);
+static int	ef_seg_read_string(elf_file_t ef, Elf_Off offset, size_t len,
+		    char *dest);
+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_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);
 
 static struct elf_file_ops ef_file_ops = {
-	ef_get_type,
-	ef_close,
-	ef_read,
-	ef_read_entry,
-	ef_seg_read,
-	ef_seg_read_rel,
-	ef_seg_read_string,
-	ef_seg_read_entry,
-	ef_seg_read_entry_rel,
-	ef_symaddr,
-	ef_lookup_set,
-	ef_lookup_symbol
+	.get_type		= ef_get_type,
+	.close			= ef_close,
+	.read			= ef_read,
+	.read_entry		= ef_read_entry,
+	.seg_read		= ef_seg_read,
+	.seg_read_rel		= ef_seg_read_rel,
+	.seg_read_string	= ef_seg_read_string,
+	.seg_read_entry		= ef_seg_read_entry,
+	.seg_read_entry_rel	= ef_seg_read_entry_rel,
+	.symaddr		= ef_symaddr,
+	.lookup_set		= ef_lookup_set,
+	.lookup_symbol		= ef_lookup_symbol
 };
 
 static void
@@ -139,10 +144,10 @@ ef_get_offset(elf_file_t ef, Elf_Off off)
 	for (i = 0; i < ef->ef_nsegs; i++) {
 		ph = ef->ef_segs[i];
 		if (off >= ph->p_vaddr && off < ph->p_vaddr + ph->p_memsz) {
-			return ph->p_offset + (off - ph->p_vaddr);
+			return (ph->p_offset + (off - ph->p_vaddr));
 		}
 	}
-	return 0;
+	return (0);
 }
 
 static int
@@ -158,26 +163,26 @@ ef_get_type(elf_file_t ef)
 static unsigned long
 elf_hash(const char *name)
 {
-	const unsigned char *p = (const unsigned char *) name;
-	unsigned long h = 0;
-	unsigned long g;
+	unsigned long h, g;
+	const unsigned char *p;
 
+	h = 0;
+	p = (const unsigned char *)name;
 	while (*p != '\0') {
 		h = (h << 4) + *p++;
 		if ((g = h & 0xf0000000) != 0)
 			h ^= g >> 24;
 		h &= ~g;
 	}
-	return h;
+	return (h);
 }
 
 static int
 ef_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym)
 {
-	unsigned long symnum;
-	Elf_Sym* symp;
+	unsigned long hash, symnum;
+	Elf_Sym *symp;
 	char *strp;
-	unsigned long hash;
 
 	/* First, search hashed global symbols */
 	hash = elf_hash(name);
@@ -187,14 +192,14 @@ ef_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym)
 		if (symnum >= ef->ef_nchains) {
 			warnx("ef_lookup_symbol: file %s have corrupted symbol table\n",
 			    ef->ef_name);
-			return ENOENT;
+			return (ENOENT);
 		}
 
 		symp = ef->ef_symtab + symnum;
 		if (symp->st_name == 0) {
 			warnx("ef_lookup_symbol: file %s have corrupted symbol table\n",
 			    ef->ef_name);
-			return ENOENT;
+			return (ENOENT);
 		}
 
 		strp = ef->ef_strtab + symp->st_name;
@@ -204,15 +209,15 @@ ef_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym)
 			    (symp->st_value != 0 &&
 				ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
 				*sym = symp;
-				return 0;
+				return (0);
 			} else
-				return ENOENT;
+				return (ENOENT);
 		}
 
 		symnum = ef->ef_chains[symnum];
 	}
 
-	return ENOENT;
+	return (ENOENT);
 }
 
 static int
@@ -226,19 +231,19 @@ ef_lookup_set(elf_file_t ef, const char *name, long *startp, long *stopp,
 	len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */
 	setsym = malloc(len);
 	if (setsym == NULL)
-		return (ENOMEM);
+		return (errno);
 
 	/* get address of first entry */
 	snprintf(setsym, len, "%s%s", "__start_set_", name);
 	error = ef_lookup_symbol(ef, setsym, &sym);
-	if (error)
+	if (error != 0)
 		goto out;
 	*startp = sym->st_value;
 
 	/* get address of last entry */
 	snprintf(setsym, len, "%s%s", "__stop_set_", name);
 	error = ef_lookup_symbol(ef, setsym, &sym);
-	if (error)
+	if (error != 0)
 		goto out;
 	*stopp = sym->st_value;
 
@@ -270,7 +275,6 @@ ef_parse_dynamic(elf_file_t ef)
 {
 	Elf_Dyn *dp;
 	Elf_Hashelt hashhdr[2];
-/*	int plttype = DT_REL;*/
 	int error;
 	Elf_Off rel_off;
 	Elf_Off rela_off;
@@ -287,19 +291,19 @@ ef_parse_dynamic(elf_file_t ef)
 		case DT_HASH:
 			error = ef_read(ef, ef_get_offset(ef, dp->d_un.d_ptr),
 			    sizeof(hashhdr),  hashhdr);
-			if (error) {
+			if (error != 0) {
 				warnx("can't read hash header (%lx)",
 				    ef_get_offset(ef, dp->d_un.d_ptr));
-				return error;
+				return (error);
 			}
 			ef->ef_nbuckets = hashhdr[0];
 			ef->ef_nchains = hashhdr[1];
 			error = ef_read_entry(ef, -1, 
 			    (hashhdr[0] + hashhdr[1]) * sizeof(Elf_Hashelt),
 			    (void**)&ef->ef_hashtab);
-			if (error) {
+			if (error != 0) {
 				warnx("can't read hash table");
-				return error;
+				return (error);
 			}
 			ef->ef_buckets = ef->ef_hashtab;
 			ef->ef_chains = ef->ef_buckets + ef->ef_nbuckets;
@@ -315,7 +319,7 @@ ef_parse_dynamic(elf_file_t ef)
 			break;
 		case DT_SYMENT:
 			if (dp->d_un.d_val != sizeof(Elf_Sym))
-				return EFTYPE;
+				return (EFTYPE);
 			break;
 		case DT_REL:
 			if (rel_off != 0)
@@ -351,11 +355,11 @@ ef_parse_dynamic(elf_file_t ef)
 	}
 	if (ef->ef_symoff == 0) {
 		warnx("%s: no .dynsym section found\n", ef->ef_name);
-		return EFTYPE;
+		return (EFTYPE);
 	}
 	if (ef->ef_stroff == 0) {
 		warnx("%s: no .dynstr section found\n", ef->ef_name);
-		return EFTYPE;
+		return (EFTYPE);
 	}
 	if (ef_read_entry(ef, ef_get_offset(ef, ef->ef_symoff),
 	    ef->ef_nchains * sizeof(Elf_Sym),
@@ -363,12 +367,12 @@ ef_parse_dynamic(elf_file_t ef)
 		if (ef->ef_verbose)
 			warnx("%s: can't load .dynsym section (0x%lx)",
 			    ef->ef_name, (long)ef->ef_symoff);
-		return EIO;
+		return (EIO);
 	}
 	if (ef_read_entry(ef, ef_get_offset(ef, ef->ef_stroff), ef->ef_strsz,
 		(void**)&ef->ef_strtab) != 0) {
 		warnx("can't load .dynstr section");
-		return EIO;
+		return (EIO);
 	}
 	if (rel_off != 0) {
 		if (rel_entry == 0) {
@@ -420,7 +424,7 @@ ef_parse_dynamic(elf_file_t ef)
 			warnx("%s: %d RELA entries", ef->ef_name,
 			    ef->ef_relasz);
 	}
-	return 0;
+	return (0);
 }
 
 static int
@@ -430,14 +434,14 @@ ef_read(elf_file_t ef, Elf_Off offset, size_t len, void*dest)
 
 	if (offset != (Elf_Off)-1) {
 		if (lseek(ef->ef_fd, offset, SEEK_SET) == -1)
-			return EIO;
+			return (EIO);
 	}
 
 	r = read(ef->ef_fd, dest, len);
 	if (r != -1 && (size_t)r == len)
-		return 0;
+		return (0);
 	else
-		return EIO;
+		return (EIO);
 }
 
 static int
@@ -447,23 +451,24 @@ ef_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void**ptr)
 
 	*ptr = malloc(len);
 	if (*ptr == NULL)
-		return ENOMEM;
+		return (errno);
 	error = ef_read(ef, offset, len, *ptr);
-	if (error)
+	if (error != 0)
 		free(*ptr);
-	return error;
+	return (error);
 }
 
 static int
 ef_seg_read(elf_file_t ef, Elf_Off offset, size_t len, void*dest)
 {
-	u_long ofs = ef_get_offset(ef, offset);
+	u_long ofs;
 
+	ofs = ef_get_offset(ef, offset);
 	if (ofs == 0) {
 		if (ef->ef_verbose)
 			warnx("ef_seg_read(%s): zero offset (%lx:%ld)",
 			    ef->ef_name, (long)offset, ofs);
-		return EFAULT;
+		return (EFAULT);
 	}
 	return ef_read(ef, ofs, len, dest);
 }
@@ -471,16 +476,17 @@ ef_seg_read(elf_file_t ef, Elf_Off offset, size_t len, void*dest)
 static int
 ef_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len, void*dest)
 {
-	u_long ofs = ef_get_offset(ef, offset);
+	u_long ofs;
 	const Elf_Rela *a;
 	const Elf_Rel *r;
 	int error;
 
+	ofs = ef_get_offset(ef, offset);
 	if (ofs == 0) {
 		if (ef->ef_verbose)
 			warnx("ef_seg_read_rel(%s): zero offset (%lx:%ld)",
 			    ef->ef_name, (long)offset, ofs);
-		return EFAULT;
+		return (EFAULT);
 	}
 	if ((error = ef_read(ef, ofs, len, dest)) != 0)
 		return (error);
@@ -503,9 +509,10 @@ ef_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len, void*dest)
 static int
 ef_seg_read_string(elf_file_t ef, Elf_Off offset, size_t len, char *dest)
 {
-	u_long ofs = ef_get_offset(ef, offset);
+	u_long ofs;
 	ssize_t r;
 
+	ofs = ef_get_offset(ef, offset);
 	if (ofs == 0 || ofs == (Elf_Off)-1) {
 		if (ef->ef_verbose)
 			warnx("ef_seg_read_string(%s): bad offset (%lx:%ld)",
@@ -529,11 +536,11 @@ ef_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void**ptr)
 
 	*ptr = malloc(len);
 	if (*ptr == NULL)
-		return ENOMEM;
+		return (errno);
 	error = ef_seg_read(ef, offset, len, *ptr);
-	if (error)
+	if (error != 0)
 		free(*ptr);
-	return error;
+	return (error);
 }
 
 static int
@@ -543,11 +550,11 @@ ef_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len, void**ptr)
 
 	*ptr = malloc(len);
 	if (*ptr == NULL)
-		return ENOMEM;
+		return (errno);
 	error = ef_seg_read_rel(ef, offset, len, *ptr);
-	if (error)
+	if (error != 0)
 		free(*ptr);
-	return error;
+	return (error);
 }
 
 int
@@ -562,14 +569,14 @@ ef_open(const char *filename, struct elf_file *efile, int verbose)
 	Elf_Phdr *phdr, *phdyn, *phlimit;
 
 	if (filename == NULL)
-		return EFTYPE;
+		return (EINVAL);
 	if ((fd = open(filename, O_RDONLY)) == -1)
-		return errno;
+		return (errno);
 
 	ef = malloc(sizeof(*ef));
 	if (ef == NULL) {
 		close(fd);
-		return (ENOMEM);
+		return (errno);
 	}
 
 	efile->ef_ef = ef;
@@ -637,38 +644,31 @@ ef_open(const char *filename, struct elf_file *efile, int verbose)
 			break;
 		}
 		error = ef_parse_dynamic(ef);
-		if (error)
+		if (error != 0)
 			break;
 		if (hdr->e_type == ET_DYN) {
 			ef->ef_type = EFT_KLD;
-/*			pad = (u_int)dest & PAGE_MASK;
-			if (pad)
-				dest += PAGE_SIZE - pad;*/
 			error = 0;
 		} else if (hdr->e_type == ET_EXEC) {
-/*			dest = hdr->e_entry;
-			if (dest == 0)
-				break;*/
 			ef->ef_type = EFT_KERNEL;
 			error = 0;
 		} else
 			break;
 	} while(0);
-	if (error)
+	if (error != 0)
 		ef_close(ef);
-	return error;
+	return (error);
 }
 
 static int
 ef_close(elf_file_t ef)
 {
+
 	close(ef->ef_fd);
-/*	if (ef->ef_fpage)
-		free(ef->ef_fpage);*/
 	if (ef->ef_name)
 		free(ef->ef_name);
 	ef->ef_efile->ef_ops = NULL;
 	ef->ef_efile->ef_ef = NULL;
 	free(ef);
-	return 0;
+	return (0);
 }
diff --git a/usr.sbin/kldxref/ef_aarch64.c b/usr.sbin/kldxref/ef_aarch64.c
index cc55ed103be3..17a9274e27a3 100644
--- a/usr.sbin/kldxref/ef_aarch64.c
+++ b/usr.sbin/kldxref/ef_aarch64.c
@@ -36,8 +36,6 @@
 
 #include "ef.h"
 
-#include <stdio.h>
-
 /*
  * Apply relocations to the values obtained from the file. `relbase' is the
  * target relocation address of the section, and `dataoff/len' is the region
@@ -47,9 +45,9 @@ int
 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_Size rtype, symidx;
-        const Elf_Rela *rela;
+	Elf_Addr *where, addend;
+	Elf_Size rtype;
+	const Elf_Rela *rela;
 
 	if (reltype != EF_RELOC_RELA)
 		return (EINVAL);
@@ -58,10 +56,9 @@ ef_reloc(struct elf_file *ef, const void *reldata, int reltype, Elf_Off relbase,
 	where = (Elf_Addr *) ((Elf_Off)dest - dataoff + rela->r_offset);
 	addend = rela->r_addend;
 	rtype = ELF_R_TYPE(rela->r_info);
-	symidx = ELF_R_SYM(rela->r_info);
 
 	if ((char *)where < (char *)dest || (char *)where >= (char *)dest + len)
-                return (0);
+		return (0);
 
 	switch(rtype) {
 	case R_AARCH64_RELATIVE:
diff --git a/usr.sbin/kldxref/ef_obj.c b/usr.sbin/kldxref/ef_obj.c
index ba9c37ea6474..e1684bf810d9 100644
--- a/usr.sbin/kldxref/ef_obj.c
+++ b/usr.sbin/kldxref/ef_obj.c
@@ -38,17 +38,17 @@
 
 #include <sys/param.h>
 #include <sys/linker.h>
-#include <string.h>
+
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
 #include <machine/elf.h>
 #define FREEBSD_ELF
 
-#include <err.h>
-
 #include "ef.h"
 
 typedef struct {
@@ -101,39 +101,41 @@ struct ef_file {
 	int		ef_verbose;
 };
 
-static int ef_obj_get_type(elf_file_t ef);
-static int ef_obj_close(elf_file_t ef);
-static int ef_obj_read(elf_file_t ef, Elf_Off offset, size_t len, void* dest);
-static int ef_obj_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
-    void **ptr);
-static int ef_obj_seg_read(elf_file_t ef, Elf_Off offset, size_t len,
-    void *dest);
-static int ef_obj_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len,
-    void *dest);
-static int ef_obj_seg_read_string(elf_file_t ef, Elf_Off offset, size_t len,
-    char *dest);
-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_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);
+static int	ef_obj_get_type(elf_file_t ef);
+static int	ef_obj_close(elf_file_t ef);
+static int	ef_obj_read(elf_file_t ef, Elf_Off offset, size_t len,
+		    void* dest);
+static int	ef_obj_read_entry(elf_file_t ef, Elf_Off offset, size_t len,
+		    void **ptr);
+static int	ef_obj_seg_read(elf_file_t ef, Elf_Off offset, size_t len,
+		    void *dest);
+static int	ef_obj_seg_read_rel(elf_file_t ef, Elf_Off offset, size_t len,
+		    void *dest);
+static int	ef_obj_seg_read_string(elf_file_t ef, Elf_Off offset,
+		    size_t len, char *dest);
+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_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);
 
 static struct elf_file_ops ef_obj_file_ops = {
-	ef_obj_get_type,
-	ef_obj_close,
-	ef_obj_read,
-	ef_obj_read_entry,
-	ef_obj_seg_read,
-	ef_obj_seg_read_rel,
-	ef_obj_seg_read_string,
-	ef_obj_seg_read_entry,
-	ef_obj_seg_read_entry_rel,
-	ef_obj_symaddr,
-	ef_obj_lookup_set,
-	ef_obj_lookup_symbol
+	.get_type		= ef_obj_get_type,
+	.close			= ef_obj_close,
+	.read			= ef_obj_read,
+	.read_entry		= ef_obj_read_entry,
+	.seg_read		= ef_obj_seg_read,
+	.seg_read_rel		= ef_obj_seg_read_rel,
+	.seg_read_string	= ef_obj_seg_read_string,
+	.seg_read_entry		= ef_obj_seg_read_entry,
+	.seg_read_entry_rel	= ef_obj_seg_read_entry_rel,
+	.symaddr		= ef_obj_symaddr,
+	.lookup_set		= ef_obj_lookup_set,
+	.lookup_symbol		= ef_obj_lookup_symbol
 };
 
 static int
@@ -154,10 +156,10 @@ ef_obj_lookup_symbol(elf_file_t ef, const char* name, Elf_Sym** sym)
 		strp = ef->ddbstrtab + symp->st_name;
 		if (symp->st_shndx != SHN_UNDEF && strcmp(name, strp) == 0) {
 			*sym = symp;
-			return 0;
+			return (0);
 		}
 	}
-	return ENOENT;
+	return (ENOENT);
 }
 
 static int
@@ -200,14 +202,14 @@ ef_obj_read(elf_file_t ef, Elf_Off offset, size_t len, void *dest)
 
 	if (offset != (Elf_Off)-1) {
 		if (lseek(ef->ef_fd, offset, SEEK_SET) == -1)
-			return EIO;
+			return (EIO);
 	}
 
 	r = read(ef->ef_fd, dest, len);
 	if (r != -1 && (size_t)r == len)
-		return 0;
+		return (0);
 	else
-		return EIO;
+		return (EIO);
 }
 
 static int
@@ -217,11 +219,11 @@ ef_obj_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void **ptr)
 
 	*ptr = malloc(len);
 	if (*ptr == NULL)
-		return ENOMEM;
+		return (errno);
 	error = ef_obj_read(ef, offset, len, *ptr);
-	if (error)
+	if (error != 0)
 		free(*ptr);
-	return error;
+	return (error);
 }
 
 static int
@@ -329,11 +331,11 @@ ef_obj_seg_read_entry(elf_file_t ef, Elf_Off offset, size_t len, void **ptr)
 
 	*ptr = malloc(len);
 	if (*ptr == NULL)
-		return ENOMEM;
+		return (errno);
 	error = ef_obj_seg_read(ef, offset, len, *ptr);
-	if (error)
+	if (error != 0)
 		free(*ptr);
-	return error;
+	return (error);
 }
 
 static int
@@ -344,11 +346,11 @@ ef_obj_seg_read_entry_rel(elf_file_t ef, Elf_Off offset, size_t len,
 
 	*ptr = malloc(len);
 	if (*ptr == NULL)
-		return ENOMEM;
+		return (errno);
 	error = ef_obj_seg_read_rel(ef, offset, len, *ptr);
-	if (error)
+	if (error != 0)
 		free(*ptr);
-	return error;
+	return (error);
 }
 
 int
@@ -365,14 +367,14 @@ ef_obj_open(const char *filename, struct elf_file *efile, int verbose)
 	int i, j, nbytes, nsym, shstrindex, symstrindex, symtabindex;
 
 	if (filename == NULL)
-		return EFTYPE;
+		return (EINVAL);
 	if ((fd = open(filename, O_RDONLY)) == -1)
-		return errno;
+		return (errno);
 
 	ef = calloc(1, sizeof(*ef));
 	if (ef == NULL) {
 		close(fd);
-		return (ENOMEM);
+		return (errno);
 	}
 
 	efile->ef_ef = ef;
@@ -587,9 +589,9 @@ ef_obj_open(const char *filename, struct elf_file *efile, int verbose)
 	}
 	error = 0;
 out:
-	if (error)
+	if (error != 0)
 		ef_obj_close(ef);
-	return error;
+	return (error);
 }
 
 static int
@@ -628,5 +630,5 @@ ef_obj_close(elf_file_t ef)
 	ef->ef_efile->ef_ef = NULL;
 	free(ef);
 
-	return 0;
+	return (0);
 }
diff --git a/usr.sbin/kldxref/ef_powerpc.c b/usr.sbin/kldxref/ef_powerpc.c
index 9bc3b5e00813..6d8c16fc77d1 100644
--- a/usr.sbin/kldxref/ef_powerpc.c
+++ b/usr.sbin/kldxref/ef_powerpc.c
@@ -38,8 +38,6 @@
 
 #include "ef.h"
 
-#include <stdio.h>
-
 /*
  * Apply relocations to the values obtained from the file. `relbase' is the
  * target relocation address of the section, and `dataoff/len' is the region
@@ -49,9 +47,9 @@ int
 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_Size rtype, symidx;
-        const Elf_Rela *rela;
+	Elf_Addr *where, addend;
+	Elf_Size rtype;
+	const Elf_Rela *rela;
 
 	if (reltype != EF_RELOC_RELA)
 		return (EINVAL);
@@ -60,17 +58,16 @@ ef_reloc(struct elf_file *ef, const void *reldata, int reltype, Elf_Off relbase,
 	where = (Elf_Addr *) ((Elf_Off)dest - dataoff + rela->r_offset);
 	addend = rela->r_addend;
 	rtype = ELF_R_TYPE(rela->r_info);
-	symidx = ELF_R_SYM(rela->r_info);
 
 	 if ((char *)where < (char *)dest || (char *)where >= (char *)dest + len)
-                return (0);
+		return (0);
 
 	switch(rtype) {
 	case R_PPC_RELATIVE: /* word32 B + A */
 		*where = relbase + addend;
 		break;
 	default:
-		warnx("unhandled relocation type %d", rtype);
+		warnx("unhandled relocation type %lu", rtype);
 	}
 	return (0);
 }
diff --git a/usr.sbin/kldxref/kldxref.c b/usr.sbin/kldxref/kldxref.c
index 2eccef4e3f13..dc0547a52ed4 100644
--- a/usr.sbin/kldxref/kldxref.c
+++ b/usr.sbin/kldxref/kldxref.c
@@ -45,21 +45,23 @@
 #include <sys/stat.h>
 #include <sys/module.h>
 #define FREEBSD_ELF
+
 #include <err.h>
+#include <errno.h>
 #include <fts.h>
-#include <string.h>
-#include <machine/elf.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
-#include <errno.h>
+#include <machine/elf.h>
 
 #include "ef.h"
 
 #define	MAXRECSIZE	(64 << 10)	/* 64k */
 #define check(val)	if ((error = (val)) != 0) break
 
-static int dflag;	/* do not create a hint file, only write on stdout */
+static bool dflag;	/* do not create a hint file, only write on stdout */
 static int verbose;
 
 static FILE *fxref;	/* current hints file */
@@ -76,12 +78,14 @@ static int reccnt;	/* total record written to this file so far */
 static void
 intalign(void)
 {
+
 	recpos = roundup2(recpos, sizeof(int));
 }
 
 static void
 record_start(void)
 {
+
 	recpos = 0;
 	memset(recbuf, 0, MAXRECSIZE);
 }
@@ -89,22 +93,24 @@ record_start(void)
 static int
 record_end(void)
 {
+
 	if (recpos == 0)
-		return 0;
+		return (0);
 	reccnt++;
 	intalign();
 	fwrite(&recpos, sizeof(recpos), 1, fxref);
-	return fwrite(recbuf, recpos, 1, fxref) != 1 ? errno : 0;
+	return (fwrite(recbuf, recpos, 1, fxref) != 1 ? errno : 0);
 }
 
 static int
-record_buf(const void *buf, int size)
+record_buf(const void *buf, size_t size)
 {
+
 	if (MAXRECSIZE - recpos < size)
 		errx(1, "record buffer overflow");
 	memcpy(recbuf + recpos, buf, size);
 	recpos += size;
-	return 0;
+	return (0);
 }
 
 /*
@@ -113,8 +119,9 @@ record_buf(const void *buf, int size)
 static int
 record_int(int val)
 {
+
 	intalign();
-	return record_buf(&val, sizeof(val));
+	return (record_buf(&val, sizeof(val)));
 }
 
 /*
@@ -123,18 +130,19 @@ record_int(int val)
 static int
 record_string(const char *str)
 {
-	int len, error;
+	int error;
+	size_t len;
 	u_char val;
 	
 	if (dflag)
-		return 0;
+		return (0);
 	val = len = strlen(str);
 	if (len > 255)
 		errx(1, "string %s too long", str);
 	error = record_buf(&val, sizeof(val));
-	if (error)
-		return error;
-	return record_buf(str, len);
+	if (error != 0)
+		return (error);
+	return (record_buf(str, len));
 }
 
 /* From sys/isa/pnp.c */
@@ -155,7 +163,7 @@ pnp_eisaformat(uint32_t id)
 	idbuf[5] = hextoascii[(data[3] >> 4)];
 	idbuf[6] = hextoascii[(data[3] & 0xf)];
 	idbuf[7] = 0;
-	return(idbuf);
+	return (idbuf);
 }
 
 struct pnp_elt
@@ -223,13 +231,15 @@ typedef TAILQ_HEAD(pnp_head, pnp_elt) pnp_list;
 static int
 parse_pnp_list(const char *desc, char **new_desc, pnp_list *list)
 {
-	const char *walker = desc, *ep = desc + strlen(desc);
+	const char *walker, *ep;
 	const char *colon, *semi;
 	struct pnp_elt *elt;
 	char *nd;
 	char type[8], key[32];
 	int off;
 
+	walker = desc;
+	ep = desc + strlen(desc);
 	off = 0;
 	nd = *new_desc = malloc(strlen(desc) + 1);
 	if (verbose > 1)
@@ -243,7 +253,7 @@ parse_pnp_list(const char *desc, char **new_desc, pnp_list *list)
 			goto err;
 		strncpy(type, walker, colon - walker);
 		type[colon - walker] = '\0';
-		if (semi) {
+		if (semi != NULL) {
 			if (semi - colon >= sizeof(key))
 				goto err;
 			strncpy(key, colon + 1, semi - colon - 1);
@@ -358,7 +368,7 @@ parse_pnp_list(const char *desc, char **new_desc, pnp_list *list)
 		}
 	}
 	*nd++ = '\0';
-	return 0;
+	return (0);
 err:
 	errx(1, "Parse error of description string %s", desc);
 }
@@ -371,11 +381,14 @@ parse_entry(struct mod_metadata *md, const char *cval,
 	struct mod_version mdv;
 	struct mod_pnp_match_info pnp;
 	char descr[1024];
-	Elf_Off data = (Elf_Off)md->md_data;
-	int error = 0, i, len;
+	Elf_Off data;
+	int error, i;
+	size_t len;
 	char *walker;
 	void *table;
 
+	data = (Elf_Off)md->md_data;
+	error = 0;
 	record_start();
 	switch (md->md_type) {
 	case MDT_DEPEND:
@@ -524,7 +537,7 @@ parse_entry(struct mod_metadata *md, const char *cval,
 	}
 	if (!error)
 		record_end();
-	return error;
+	return (error);
 }
 
 static int
@@ -533,33 +546,25 @@ read_kld(char *filename, char *kldname)
 	struct mod_metadata md;
 	struct elf_file ef;
 	void **p, **orgp;
-	int error, eftype, nmlen;
+	int error, eftype;
 	long start, finish, entries;
-	char kldmodname[MAXMODNAME + 1], cval[MAXMODNAME + 1], *cp;
+	char cval[MAXMODNAME + 1];
 
 	if (verbose || dflag)
 		printf("%s\n", filename);
 	error = ef_open(filename, &ef, verbose);
-	if (error) {
+	if (error != 0) {
 		error = ef_obj_open(filename, &ef, verbose);
-		if (error) {
+		if (error != 0) {
 			if (verbose)
 				warnc(error, "elf_open(%s)", filename);
-			return error;
+			return (error);
 		}
 	}
 	eftype = EF_GET_TYPE(&ef);
 	if (eftype != EFT_KLD && eftype != EFT_KERNEL)  {
 		EF_CLOSE(&ef);
-		return 0;
-	}
-	if (!dflag) {
-		cp = strrchr(kldname, '.');
-		nmlen = (cp != NULL) ? cp - kldname : (int)strlen(kldname);
-		if (nmlen > MAXMODNAME)
-			nmlen = MAXMODNAME;
-		strlcpy(kldmodname, kldname, nmlen);
-/*		fprintf(fxref, "%s:%s:%d\n", kldmodname, kldname, 0);*/
+		return (0);
 	}
 	do {
 		check(EF_LOOKUP_SET(&ef, MDT_SETNAME, &start, &finish,
@@ -575,12 +580,12 @@ read_kld(char *filename, char *kldname)
 			    sizeof(cval), cval));
 			parse_entry(&md, cval, &ef, kldname);
 		}
-		if (error)
+		if (error != 0)
 			warnc(error, "error while reading %s", filename);
 		free(orgp);
 	} while(0);
 	EF_CLOSE(&ef);
-	return error;
+	return (error);
 }
 
 /*
@@ -598,14 +603,14 @@ maketempfile(char *dest, const char *root)
 	if (snprintf(dest, MAXPATHLEN, "%.*slhint.XXXXXX", n, root) >=
 	    MAXPATHLEN) {
 		errno = ENAMETOOLONG;
-		return NULL;
+		return (NULL);
 	}
 
 	fd = mkstemp(dest);
 	if (fd < 0)
-		return NULL;
+		return (NULL);
 	fchmod(fd, 0644);	/* nothing secret in the file */
-	return fdopen(fd, "w+");
+	return (fdopen(fd, "w+"));
 }
 
 static char xrefname[MAXPATHLEN], tempname[MAXPATHLEN];
@@ -623,11 +628,12 @@ usage(void)
 static int
 compare(const FTSENT *const *a, const FTSENT *const *b)
 {
+
 	if ((*a)->fts_info == FTS_D && (*b)->fts_info != FTS_D)
-		return 1;
+		return (1);
 	if ((*a)->fts_info != FTS_D && (*b)->fts_info == FTS_D)
-		return -1;
-	return strcmp((*a)->fts_name, (*b)->fts_name);
+		return (-1);
+	return (strcmp((*a)->fts_name, (*b)->fts_name));
 }
 
 int
@@ -643,7 +649,7 @@ main(int argc, char *argv[])
 	while ((opt = getopt(argc, argv, "Rdf:v")) != -1) {
 		switch (opt) {
 		case 'd':	/* no hint file, only print on stdout */
-			dflag = 1;
+			dflag = true;
 			break;
 		case 'f':	/* use this name instead of linker.hints */
 			xref_file = optarg;
@@ -681,7 +687,7 @@ main(int argc, char *argv[])
 			/* close and rename the current hint file */
 			fclose(fxref);
 			fxref = NULL;
-			if (reccnt) {
+			if (reccnt != 0) {
 				rename(tempname, xrefname);
 			} else {
 				/* didn't find any entry, ignore this file */
@@ -714,5 +720,5 @@ main(int argc, char *argv[])
 		read_kld(p->fts_path, p->fts_name);
 	}
 	fts_close(ftsp);
-	return 0;
+	return (0);
 }