diff --git a/util/cbfstool/Makefile b/util/cbfstool/Makefile
index a0de08d2f7..5c8008b47b 100644
--- a/util/cbfstool/Makefile
+++ b/util/cbfstool/Makefile
@@ -1,8 +1,11 @@
 obj ?= $(shell pwd)
 
-HOSTCC   ?= gcc
-CFLAGS   ?= -g -Wall -Werror
-CFLAGS   += -D_7ZIP_ST
+HOSTCC ?= gcc
+CFLAGS ?= -g
+CFLAGS += -D_7ZIP_ST
+CFLAGS += -Wall -Wundef -Wstrict-prototypes -Wmissing-prototypes
+CFLAGS += -Wwrite-strings -Wredundant-decls -Wno-trigraphs
+CFLAGS += -Wstrict-aliasing -Wshadow -Werror
 
 BINARY:=$(obj)/cbfstool
 
diff --git a/util/cbfstool/cbfs.h b/util/cbfstool/cbfs.h
index 1890a33401..82cbfb3e44 100644
--- a/util/cbfstool/cbfs.h
+++ b/util/cbfstool/cbfs.h
@@ -107,10 +107,7 @@ struct cbfs_payload {
  */
 #define CBFS_COMPONENT_NULL 0xFFFFFFFF
 
-int cbfs_file_header(unsigned long physaddr);
 #define CBFS_NAME(_c) (((char *) (_c)) + sizeof(struct cbfs_file))
 #define CBFS_SUBHEADER(_p) ( (void *) ((((uint8_t *) (_p)) + ntohl((_p)->offset))) )
 
-struct cbfs_file *cbfs_create_empty_file(uint32_t physaddr, uint32_t size);
-
 #endif
diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c
index 44a9fe8c48..f3124606a8 100644
--- a/util/cbfstool/cbfs_image.c
+++ b/util/cbfstool/cbfs_image.c
@@ -69,18 +69,8 @@ static uint32_t align_up(uint32_t value, uint32_t align)
 	return value;
 }
 
-uint32_t lookup_type_by_name(const struct typedesc_t *desc, const char *name,
-			     uint32_t default_value)
-{
-	int i;
-	for (i = 0; desc[i].name; i++)
-		if (strcmp(desc[i].name, name) == 0)
-			return desc[i].type;
-	return default_value;
-}
-
-const char *lookup_name_by_type(const struct typedesc_t *desc, uint32_t type,
-				const char *default_value)
+static const char *lookup_name_by_type(const struct typedesc_t *desc,
+				uint32_t type, const char *default_value)
 {
 	int i;
 	for (i = 0; desc[i].name; i++)
@@ -89,21 +79,11 @@ const char *lookup_name_by_type(const struct typedesc_t *desc, uint32_t type,
 	return default_value;
 }
 
-uint32_t get_cbfs_entry_type(const char *name, uint32_t default_value)
-{
-	return lookup_type_by_name(types_cbfs_entry, name, default_value);
-}
-
-const char *get_cbfs_entry_type_name(uint32_t type)
+static const char *get_cbfs_entry_type_name(uint32_t type)
 {
 	return lookup_name_by_type(types_cbfs_entry, type, "(unknown)");
 }
 
-uint32_t get_cbfs_compression(const char *name, uint32_t unknown)
-{
-	return lookup_type_by_name(types_cbfs_compression, name, unknown);
-}
-
 /* CBFS image */
 
 static int cbfs_calculate_file_header_size(const char *name)
@@ -139,7 +119,7 @@ static int cbfs_fix_legacy_size(struct cbfs_image *image)
 }
 
 int cbfs_image_create(struct cbfs_image *image,
-		      uint32_t arch,
+		      uint32_t architecture,
 		      size_t size,
 		      uint32_t align,
 		      struct buffer *bootblock,
@@ -206,7 +186,7 @@ int cbfs_image_create(struct cbfs_image *image,
 	header->bootblocksize = htonl(bootblock->size);
 	header->align = htonl(align);
 	header->offset = htonl(entries_offset);
-	header->architecture = htonl(arch);
+	header->architecture = htonl(architecture);
 
 	// Prepare entries
 	if (align_up(entries_offset, align) != entries_offset) {
@@ -474,7 +454,7 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name,
 
 	buffer.data = CBFS_SUBHEADER(entry);
 	buffer.size = ntohl(entry->len);
-	buffer.name = "(cbfs_export_entry)";
+	buffer.name = (char *)"(cbfs_export_entry)";
 	if (buffer_write_file(&buffer, filename) != 0) {
 		ERROR("Failed to write %s into %s.\n",
 		      entry_name, filename);
@@ -779,16 +759,6 @@ int cbfs_is_valid_entry(struct cbfs_image *image, struct cbfs_file *entry)
 		       sizeof(entry->magic)) == 0);
 }
 
-int cbfs_init_entry(struct cbfs_file *entry,
-		    struct buffer *buffer)
-{
-	memset(entry, 0, sizeof(*entry));
-	memcpy(entry->magic, CBFS_FILE_MAGIC, sizeof(entry->magic));
-	entry->len = htonl(buffer->size);
-	entry->offset = htonl(sizeof(*entry) + strlen(buffer->name) + 1);
-	return 0;
-}
-
 int cbfs_create_empty_entry(struct cbfs_image *image, struct cbfs_file *entry,
 		      size_t len, const char *name)
 {
diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c
index 3f84ac35e8..074dc5412b 100644
--- a/util/cbfstool/cbfstool.c
+++ b/util/cbfstool/cbfstool.c
@@ -68,7 +68,8 @@ static int cbfs_add_component(const char *cbfs_name,
 			      const char *name,
 			      uint32_t type,
 			      uint32_t offset,
-			      convert_buffer_t convert) {
+			      convert_buffer_t convert)
+{
 	struct cbfs_image image;
 	struct buffer buffer;
 
@@ -129,7 +130,8 @@ static int cbfs_add_component(const char *cbfs_name,
 	return 0;
 }
 
-static int cbfstool_convert_mkstage(struct buffer *buffer, uint32_t *offset) {
+static int cbfstool_convert_mkstage(struct buffer *buffer, uint32_t *offset)
+{
 	struct buffer output;
 	if (parse_elf_to_stage(buffer, &output, param.algo, offset) != 0)
 		return -1;
@@ -139,7 +141,9 @@ static int cbfstool_convert_mkstage(struct buffer *buffer, uint32_t *offset) {
 	return 0;
 }
 
-static int cbfstool_convert_mkpayload(struct buffer *buffer, uint32_t *offset) {
+static int cbfstool_convert_mkpayload(struct buffer *buffer,
+						unused uint32_t *offset)
+{
 	struct buffer output;
 	int ret;
 	/* per default, try and see if payload is an ELF binary */
@@ -162,7 +166,8 @@ static int cbfstool_convert_mkpayload(struct buffer *buffer, uint32_t *offset) {
 }
 
 static int cbfstool_convert_mkflatpayload(struct buffer *buffer,
-					  uint32_t *offset) {
+					  unused uint32_t *offset)
+{
 	struct buffer output;
 	if (parse_flat_binary_to_payload(buffer, &output,
 					 param.loadaddress,
diff --git a/util/cbfstool/common.c b/util/cbfstool/common.c
index beca0689db..10faffd335 100644
--- a/util/cbfstool/common.c
+++ b/util/cbfstool/common.c
@@ -42,7 +42,8 @@ int is_big_endian(void)
 
 /* Buffer and file I/O */
 
-int buffer_create(struct buffer *buffer, size_t size, const char *name) {
+int buffer_create(struct buffer *buffer, size_t size, const char *name)
+{
 	buffer->name = strdup(name);
 	buffer->size = size;
 	buffer->data = (char *)malloc(buffer->size);
@@ -53,7 +54,8 @@ int buffer_create(struct buffer *buffer, size_t size, const char *name) {
 	return (buffer->data == NULL);
 }
 
-int buffer_from_file(struct buffer *buffer, const char *filename) {
+int buffer_from_file(struct buffer *buffer, const char *filename)
+{
 	FILE *fp = fopen(filename, "rb");
 	if (!fp) {
 		perror(filename);
@@ -74,7 +76,8 @@ int buffer_from_file(struct buffer *buffer, const char *filename) {
 	return 0;
 }
 
-int buffer_write_file(struct buffer *buffer, const char *filename) {
+int buffer_write_file(struct buffer *buffer, const char *filename)
+{
 	FILE *fp = fopen(filename, "wb");
 	if (!fp) {
 		perror(filename);
@@ -90,7 +93,8 @@ int buffer_write_file(struct buffer *buffer, const char *filename) {
 	return 0;
 }
 
-void buffer_delete(struct buffer *buffer) {
+void buffer_delete(struct buffer *buffer)
+{
 	assert(buffer);
 	if (buffer->name) {
 		free(buffer->name);
@@ -103,51 +107,6 @@ void buffer_delete(struct buffer *buffer) {
 	buffer->size = 0;
 }
 
-size_t getfilesize(const char *filename)
-{
-	size_t size;
-	FILE *file = fopen(filename, "rb");
-	if (file == NULL)
-		return -1;
-
-	fseek(file, 0, SEEK_END);
-	size = ftell(file);
-	fclose(file);
-	return size;
-}
-
-void *loadfile(const char *filename, uint32_t * romsize_p, void *content,
-	       int place)
-{
-	FILE *file = fopen(filename, "rb");
-	if (file == NULL)
-		return NULL;
-
-	fseek(file, 0, SEEK_END);
-	*romsize_p = ftell(file);
-	fseek(file, 0, SEEK_SET);
-	if (!content) {
-		content = malloc(*romsize_p);
-		if (!content) {
-			ERROR("Could not get %d bytes for file %s\n",
-			      *romsize_p, filename);
-			exit(1);
-		}
-	} else if (place == SEEK_END)
-		content -= *romsize_p;
-
-	if (!fread(content, *romsize_p, 1, file)) {
-		ERROR("Failed to read %s\n", filename);
-		return NULL;
-	}
-	fclose(file);
-	return content;
-}
-
-static struct cbfs_header *master_header;
-static uint32_t phys_start, phys_end, align;
-uint32_t romsize;
-void *offset;
 uint32_t arch = CBFS_ARCHITECTURE_UNKNOWN;
 
 static struct {
@@ -190,115 +149,13 @@ const char *arch_to_string(uint32_t a)
 
 }
 
-int find_master_header(void *romarea, size_t size)
-{
-	size_t offset;
-
-	if (master_header)
-		return 0;
-
-	for (offset = 0; offset < size - sizeof(struct cbfs_header); offset++) {
-		struct cbfs_header *tmp = romarea + offset;
-
-		if (tmp->magic == ntohl(CBFS_HEADER_MAGIC)) {
-			master_header = tmp;
-			break;
-		}
-	}
-
-	return master_header ? 0 : 1;
-}
-
-void recalculate_rom_geometry(void *romarea)
-{
-	if (find_master_header(romarea, romsize)) {
-		ERROR("Cannot find master header\n");
-		exit(1);
-	}
-
-	/* Update old headers */
-	if (master_header->version == CBFS_HEADER_VERSION1 &&
-	    ntohl(master_header->architecture) == CBFS_ARCHITECTURE_UNKNOWN) {
-		DEBUG("Updating CBFS master header to version 2\n");
-		master_header->architecture = htonl(CBFS_ARCHITECTURE_X86);
-	}
-
-	arch = ntohl(master_header->architecture);
-
-	switch (arch) {
-	case CBFS_ARCHITECTURE_ARM:
-		offset = romarea;
-		phys_start = (0 + ntohl(master_header->offset)) & 0xffffffff;
-		phys_end = romsize & 0xffffffff;
-		break;
-	case CBFS_ARCHITECTURE_X86:
-		offset = romarea + romsize - 0x100000000ULL;
-		phys_start = (0 - romsize + ntohl(master_header->offset)) &
-				0xffffffff;
-		phys_end = (0 - ntohl(master_header->bootblocksize) -
-		     sizeof(struct cbfs_header)) & 0xffffffff;
-		break;
-	default:
-		ERROR("Unknown architecture\n");
-		exit(1);
-	}
-
-	align = ntohl(master_header->align);
-}
-
-void *loadrom(const char *filename)
-{
-	void *romarea = loadfile(filename, &romsize, 0, SEEK_SET);
-	if (romarea == NULL)
-		return NULL;
-	recalculate_rom_geometry(romarea);
-	return romarea;
-}
-
-int writerom(const char *filename, void *start, uint32_t size)
-{
-	FILE *file = fopen(filename, "wb");
-	if (!file) {
-		ERROR("Could not open '%s' for writing: ", filename);
-		perror("");
-		return 1;
-	}
-
-	if (fwrite(start, size, 1, file) != 1) {
-		ERROR("Could not write to '%s': ", filename);
-		perror("");
-		return 1;
-	}
-
-	fclose(file);
-	return 0;
-}
-
-int cbfs_file_header(unsigned long physaddr)
-{
-	/* maybe improve this test */
-	return (strncmp(phys_to_virt(physaddr), "LARCHIVE", 8) == 0);
-}
-
-struct cbfs_file *cbfs_create_empty_file(uint32_t physaddr, uint32_t size)
-{
-	struct cbfs_file *nextfile = (struct cbfs_file *)phys_to_virt(physaddr);
-	strncpy((char *)(nextfile->magic), "LARCHIVE", 8);
-	nextfile->len = htonl(size);
-	nextfile->type = htonl(0xffffffff);
-	nextfile->checksum = 0;	// FIXME?
-	nextfile->offset = htonl(sizeof(struct cbfs_file) + 16);
-	memset(((void *)nextfile) + sizeof(struct cbfs_file), 0, 16);
-	return nextfile;
-}
-
 int iself(unsigned char *input)
 {
 	Elf32_Ehdr *ehdr = (Elf32_Ehdr *) input;
 	return !memcmp(ehdr->e_ident, ELFMAG, 4);
 }
 
-static struct filetypes_t {
+static const struct filetypes_t {
 	uint32_t type;
 	const char *name;
 } filetypes[] = {
@@ -327,15 +184,6 @@ void print_supported_filetypes(void)
 	}
 }
 
-const char *strfiletype(uint32_t number)
-{
-	size_t i;
-	for (i = 0; i < (sizeof(filetypes) / sizeof(struct filetypes_t)); i++)
-		if (filetypes[i].type == number)
-			return filetypes[i].name;
-	return "unknown";
-}
-
 uint64_t intfiletype(const char *name)
 {
 	size_t i;
@@ -345,514 +193,3 @@ uint64_t intfiletype(const char *name)
 	return -1;
 }
 
-void print_cbfs_directory(const char *filename)
-{
-	char *name = strdup(filename);
-	printf
-		("%s: %d kB, bootblocksize %d, romsize %d, offset 0x%x\n"
-		 "alignment: %d bytes, architecture: %s\n\n",
-		 basename(name), romsize / 1024, ntohl(master_header->bootblocksize),
-		 romsize, ntohl(master_header->offset), align, arch_to_string(arch));
-	free(name);
-	printf("%-30s %-10s %-12s Size\n", "Name", "Offset", "Type");
-	uint32_t current = phys_start;
-	while (current < phys_end) {
-		if (!cbfs_file_header(current)) {
-			current += align;
-			continue;
-		}
-		struct cbfs_file *thisfile =
-			(struct cbfs_file *)phys_to_virt(current);
-		uint32_t length = ntohl(thisfile->len);
-		char *fname = (char *)(phys_to_virt(current) + sizeof(struct cbfs_file));
-		if (strlen(fname) == 0)
-			fname = "(empty)";
-
-		printf("%-30s 0x%-8x %-12s %d\n", fname,
-		       current - phys_start + ntohl(master_header->offset),
-		       strfiletype(ntohl(thisfile->type)), length);
-
-		/* note the components of the subheader are in host order ... */
-		switch (ntohl(thisfile->type)) {
-		case CBFS_COMPONENT_STAGE:
-		{
-			struct cbfs_stage *stage = CBFS_SUBHEADER(thisfile);
-			INFO("    %s compression, entry: 0x%llx, load: 0x%llx, length: %d/%d\n",
-			       stage->compression == CBFS_COMPRESS_LZMA ? "LZMA" : "no",
-			       (unsigned long long)stage->entry,
-			       (unsigned long long)stage->load,
-			       stage->len,
-			       stage->memlen);
-			break;
-		}
-		case CBFS_COMPONENT_PAYLOAD:
-		{
-			struct cbfs_payload_segment *payload = CBFS_SUBHEADER(thisfile);
-			while(payload) {
-				switch(payload->type) {
-				case PAYLOAD_SEGMENT_CODE:
-				case PAYLOAD_SEGMENT_DATA:
-					INFO("    %s (%s compression, offset: 0x%x, load: 0x%llx, length: %d/%d)\n",
-						payload->type == PAYLOAD_SEGMENT_CODE ? "code " : "data" ,
-						payload->compression == CBFS_COMPRESS_LZMA ? "LZMA" : "no",
-						ntohl(payload->offset),
-						(unsigned long long)ntohll(payload->load_addr),
-						ntohl(payload->len), ntohl(payload->mem_len));
-					break;
-				case PAYLOAD_SEGMENT_ENTRY:
-					INFO("    entry (0x%llx)\n", (unsigned long long)ntohll(payload->load_addr));
-					break;
-				case PAYLOAD_SEGMENT_BSS:
-					INFO("    BSS (address 0x%016llx, length 0x%x)\n", (unsigned long long)ntohll(payload->load_addr), ntohl(payload->len));
-					break;
-				case PAYLOAD_SEGMENT_PARAMS:
-					INFO("    parameters\n");
-					break;
-				default:
-					INFO("    %x (%s compression, offset: 0x%x, load: 0x%llx, length: %d/%d\n",
-						payload->type,
-						payload->compression == CBFS_COMPRESS_LZMA ? "LZMA" : "no",
-						ntohl(payload->offset),
-						(unsigned long long)ntohll(payload->load_addr),
-						ntohl(payload->len),
-						ntohl(payload->mem_len));
-					break;
-				}
-
-				if(payload->type == PAYLOAD_SEGMENT_ENTRY)
-					payload=NULL;
-				else
-					payload++;
-			}
-			break;
-		}
-		default:
-			break;
-		}
-		current =
-		    ALIGN(current + ntohl(thisfile->len) +
-			  ntohl(thisfile->offset), align);
-	}
-}
-
-int extract_file_from_cbfs(const char *filename, const char *payloadname, const char *outpath)
-{
-	FILE *outfile = NULL;
-	uint32_t current = phys_start;
-	while (current < phys_end) {
-		if (!cbfs_file_header(current)) {
-			current += align;
-			continue;
-		}
-
-		// Locate the file start struct
-		struct cbfs_file *thisfile =
-		    (struct cbfs_file *)phys_to_virt(current);
-		// And its length
-		uint32_t length = ntohl(thisfile->len);
-		// Locate the file name
-		char *fname = (char *)(phys_to_virt(current) + sizeof(struct cbfs_file));
-
-		// It's not the file we are looking for..
-		if (strcmp(fname, payloadname) != 0)
-		{
-			current =
-			   ALIGN(current + ntohl(thisfile->len) +
-				  ntohl(thisfile->offset), align);
-			continue;
-		}
-
-		// Else, it's our file.
-		LOG("Found file %.30s at 0x%x, type %.12s, size %d\n", fname,
-		       current - phys_start, strfiletype(ntohl(thisfile->type)),
-		       length);
-
-		// If we are not dumping to stdout, open the out file.
-		outfile = fopen(outpath, "wb");
-		if (!outfile)
-		{
-			ERROR("Could not open the file %s for writing.\n", outpath);
-			return 1;
-		}
-
-		if (ntohl(thisfile->type) != CBFS_COMPONENT_RAW)
-		{
-			WARN("Only 'raw' files are safe to extract.\n");
-		}
-
-		fwrite(((char *)thisfile)
-				+ ntohl(thisfile->offset), length, 1, outfile);
-
-		fclose(outfile);
-		LOG("Successfully dumped the file.\n");
-
-		// We'll only dump one file.
-		return 0;
-	}
-	ERROR("File %s not found.\n", payloadname);
-	return 1;
-}
-
-
-int add_file_to_cbfs(void *content, uint32_t contentsize, uint32_t location)
-{
-	uint32_t current = phys_start;
-	while (current < phys_end) {
-		if (!cbfs_file_header(current)) {
-			current += align;
-			continue;
-		}
-		struct cbfs_file *thisfile =
-		    (struct cbfs_file *)phys_to_virt(current);
-		uint32_t length = ntohl(thisfile->len);
-
-		DEBUG("at %x, %x bytes\n", current, length);
-		/* Is this a free chunk? */
-		if ((thisfile->type == CBFS_COMPONENT_DELETED)
-		    || (thisfile->type == CBFS_COMPONENT_NULL)) {
-			DEBUG("null||deleted at %x, %x bytes\n", current,
-				length);
-			/* if this is the right size, and if specified, the right location, use it */
-			if ((contentsize <= length)
-			    && ((location == 0) || (current == location))) {
-				if (contentsize < length) {
-					DEBUG("this chunk is %x bytes, we need %x. create a new chunk at %x with %x bytes\n",
-					     length, contentsize,
-					     ALIGN(current + contentsize,
-						   align),
-					     length - contentsize);
-					uint32_t start =
-					    ALIGN(current + contentsize, align);
-					uint32_t size =
-					    current + ntohl(thisfile->offset)
-					    + length - start - 16 -
-					    sizeof(struct cbfs_file);
-					cbfs_create_empty_file(start, size);
-				}
-				DEBUG("copying data\n");
-				memcpy(phys_to_virt(current), content,
-				       contentsize);
-				return 0;
-			}
-			if (location != 0) {
-				/* CBFS has the constraint that the chain always moves up in memory. so once
-				   we're past the place we seek, we don't need to look any further */
-				if (current > location) {
-					ERROR("The requested space is not available\n");
-					return 1;
-				}
-
-				/* Is the requested location inside the current chunk? */
-				if ((current < location)
-				    && ((location + contentsize) <=
-					(current + length))) {
-					/* Split it up. In the next iteration the code will be at the right place. */
-					DEBUG("split up. new length: %x\n",
-						location - current -
-						ntohl(thisfile->offset));
-					thisfile->len =
-					    htonl(location - current -
-						  ntohl(thisfile->offset));
-					cbfs_create_empty_file(location,
-								   length -
-								   (location -
-								    current));
-				}
-			}
-		}
-		current =
-		    ALIGN(current + ntohl(thisfile->len) +
-			  ntohl(thisfile->offset), align);
-	}
-	ERROR("Could not add the file to CBFS, it's probably too big.\n");
-	ERROR("File size: %d bytes (%d KB).\n", contentsize, contentsize/1024);
-	return 1;
-}
-
-
-static struct cbfs_file *merge_adjacent_files(struct cbfs_file *first,
-					      struct cbfs_file *second)
-{
-	uint32_t new_length =
-	    ntohl(first->len) + ntohl(second->len) + ntohl(second->offset);
-	first->len = htonl(new_length);
-	first->checksum = 0; // FIXME?
-	return first;
-}
-
-static struct cbfs_file *next_file(struct cbfs_file *prev)
-{
-	uint32_t pos = (prev == NULL) ? phys_start :
-	    ALIGN(virt_to_phys(prev) + ntohl(prev->len) + ntohl(prev->offset),
-		  align);
-
-	for (; pos < phys_end; pos += align) {
-		if (cbfs_file_header(pos))
-			return (struct cbfs_file *)phys_to_virt(pos);
-	}
-	return NULL;
-}
-
-
-int remove_file_from_cbfs(const char *filename)
-{
-	struct cbfs_file *prev = NULL;
-	struct cbfs_file *cur = next_file(prev);
-	struct cbfs_file *next = next_file(cur);
-	for (; cur; prev = cur, cur = next, next = next_file(next)) {
-
-		/* Check if this is the file to remove. */
-		char *name = (char *)cur + sizeof(*cur);
-		if (strcmp(name, filename))
-			continue;
-
-		/* Mark the file as free space and erase its name. */
-		cur->type = CBFS_COMPONENT_NULL;
-		name[0] = '\0';
-
-		/* Merge it with the previous file if possible. */
-		if (prev && prev->type == CBFS_COMPONENT_NULL)
-			cur = merge_adjacent_files(prev, cur);
-
-		/* Merge it with the next file if possible. */
-		if (next && next->type == CBFS_COMPONENT_NULL)
-			merge_adjacent_files(cur, next);
-
-		return 0;
-	}
-	ERROR("CBFS file %s not found.\n", filename);
-	return 1;
-}
-
-
-/* returns new data block with cbfs_file header, suitable to dump into the ROM. location returns
-   the new location that points to the cbfs_file header */
-void *create_cbfs_file(const char *filename, void *data, uint32_t * datasize,
-		       uint32_t type, uint32_t * location)
-{
-	uint32_t filename_len = ALIGN(strlen(filename) + 1, 16);
-	uint32_t headersize = sizeof(struct cbfs_file) + filename_len;
-	if ((location != 0) && (*location != 0)) {
-		uint32_t offset = *location % align;
-		/* If offset >= (headersize % align), we can stuff the header into the offset.
-		   Otherwise the header has to be aligned itself, and put before the offset data */
-		if (offset >= (headersize % align)) {
-			offset -= (headersize % align);
-		} else {
-			offset += align - (headersize % align);
-		}
-		headersize += offset;
-		*location -= headersize;
-	}
-	void *newdata = malloc(*datasize + headersize);
-	if (!newdata) {
-		ERROR("Could not get %d bytes for CBFS file.\n", *datasize +
-		       headersize);
-		exit(1);
-	}
-	memset(newdata, 0xff, *datasize + headersize);
-	struct cbfs_file *nextfile = (struct cbfs_file *)newdata;
-	strncpy((char *)(nextfile->magic), "LARCHIVE", 8);
-	nextfile->len = htonl(*datasize);
-	nextfile->type = htonl(type);
-	nextfile->checksum = 0;	// FIXME?
-	nextfile->offset = htonl(headersize);
-	strcpy(newdata + sizeof(struct cbfs_file), filename);
-	memcpy(newdata + headersize, data, *datasize);
-	*datasize += headersize;
-	return newdata;
-}
-
-int create_cbfs_image(const char *romfile, uint32_t _romsize,
-		const char *bootblock, uint32_t align, uint32_t offs)
-{
-	uint32_t bootblocksize = 0;
-	struct cbfs_header *master_header;
-	unsigned char *romarea, *bootblk;
-
-	romsize = _romsize;
-	romarea = malloc(romsize);
-	if (!romarea) {
-		ERROR("Could not get %d bytes of memory"
-			" for CBFS image.\n", romsize);
-		exit(1);
-	}
-	memset(romarea, 0xff, romsize);
-
-	if (align == 0)
-		align = 64;
-
-	bootblk = loadfile(bootblock, &bootblocksize,
-				romarea + romsize, SEEK_END);
-	if (!bootblk) {
-		ERROR("Could not load bootblock %s.\n",
-			bootblock);
-		free(romarea);
-		return 1;
-	}
-
-	// TODO(hungte) Replace magic numbers by named constants.
-	switch (arch) {
-	case CBFS_ARCHITECTURE_ARM:
-		/* Set up physical/virtual mapping */
-		offset = romarea;
-
-		/*
-		 * The initial jump instruction and bootblock will be placed
-		 * before and after the master header, respectively. The
-		 * bootblock image must contain a blank, aligned region large
-		 * enough for the master header to fit.
-		 *
-		 * An anchor string must be left such that when cbfstool is run
-		 * we can find it and insert the master header at the next
-		 * aligned boundary.
-		 */
-		loadfile(bootblock, &bootblocksize, romarea + offs, SEEK_SET);
-
-		unsigned char *p = romarea + offs;
-		while (1) {
-			/* FIXME: assumes little endian... */
-			if (*(uint32_t *)p == 0xdeadbeef)
-				break;
-			if (p >= (romarea + _romsize)) {
-				ERROR("Could not determine CBFS "
-				      "header location.\n");
-				return 1;
-			}
-			p += (sizeof(unsigned int));
-		}
-		unsigned int u = ALIGN((unsigned int)(p - romarea), align);
-		master_header = (struct cbfs_header *)(romarea + u);
-
-		master_header->magic = ntohl(CBFS_HEADER_MAGIC);
-		master_header->version = ntohl(CBFS_HEADER_VERSION);
-		master_header->romsize = htonl(romsize);
-		master_header->bootblocksize = htonl(bootblocksize);
-		master_header->align = htonl(align);
-		master_header->offset = htonl(
-				ALIGN((0x40 + bootblocksize), align));
-		master_header->architecture = htonl(CBFS_ARCHITECTURE_ARM);
-
-		((uint32_t *) phys_to_virt(0x4 + offs))[0] =
-				virt_to_phys(master_header);
-
-		recalculate_rom_geometry(romarea);
-
-		cbfs_create_empty_file(
-				offs + ALIGN((0x40 + bootblocksize), align),
-				romsize - offs - sizeof(struct cbfs_file) -
-				ALIGN((bootblocksize + 0x40), align));
-		break;
-
-	case CBFS_ARCHITECTURE_X86:
-		// Set up physical/virtual mapping
-		offset = romarea + romsize - 0x100000000ULL;
-
-		loadfile(bootblock, &bootblocksize, romarea + romsize,
-			 SEEK_END);
-		master_header = (struct cbfs_header *)(romarea + romsize -
-				  bootblocksize - sizeof(struct cbfs_header));
-
-		master_header->magic = ntohl(CBFS_HEADER_MAGIC);
-		master_header->version = ntohl(CBFS_HEADER_VERSION);
-		master_header->romsize = htonl(romsize);
-		master_header->bootblocksize = htonl(bootblocksize);
-		master_header->align = htonl(align);
-		master_header->offset = htonl(offs);
-		master_header->architecture = htonl(CBFS_ARCHITECTURE_X86);
-
-		((uint32_t *) phys_to_virt(CBFS_HEADPTR_ADDR_X86))[0] =
-		    virt_to_phys(master_header);
-
-		recalculate_rom_geometry(romarea);
-
-		cbfs_create_empty_file((0 - romsize + offs) & 0xffffffff,
-				       romsize - offs - bootblocksize -
-				       sizeof(struct cbfs_header) -
-				       sizeof(struct cbfs_file) - 16);
-		break;
-
-	default:
-		// Should not happen.
-		ERROR("You found a bug in cbfstool.\n");
-		exit(1);
-	}
-
-	writerom(romfile, romarea, romsize);
-	free(romarea);
-	return 0;
-}
-
-static int in_segment(int addr, int size, int gran)
-{
-	return ((addr & ~(gran - 1)) == ((addr + size) & ~(gran - 1)));
-}
-
-uint32_t cbfs_find_location(const char *romfile, uint32_t filesize,
-			    const char *filename, uint32_t alignment)
-{
-	void *rom;
-	size_t filename_size, headersize, totalsize;
-	int ret = 0;
-	uint32_t current;
-
-	rom = loadrom(romfile);
-	if (rom == NULL) {
-		ERROR("Could not load ROM image '%s'.\n", romfile);
-		return 0;
-	}
-
-	filename_size = strlen(filename);
-	headersize = sizeof(struct cbfs_file) + ALIGN(filename_size + 1, 16) +
-			sizeof(struct cbfs_stage);
-	totalsize = headersize + filesize;
-
-	current = phys_start;
-	while (current < phys_end) {
-		uint32_t top;
-		struct cbfs_file *thisfile;
-
-		if (!cbfs_file_header(current)) {
-			current += align;
-			continue;
-		}
-
-		thisfile = (struct cbfs_file *)phys_to_virt(current);
-
-		top = current + ntohl(thisfile->len) + ntohl(thisfile->offset);
-
-		if (((ntohl(thisfile->type) == 0x0)
-		     || (ntohl(thisfile->type) == 0xffffffff))
-		    && (ntohl(thisfile->len) + ntohl(thisfile->offset) >=
-			totalsize)) {
-			if (in_segment
-			    (current + headersize, filesize, alignment)) {
-				ret = current + headersize;
-				break;
-			}
-			if ((ALIGN(current, alignment) + filesize < top)
-			    && (ALIGN(current, alignment) - headersize >
-				current)
-			    && in_segment(ALIGN(current, alignment), filesize,
-					  alignment)) {
-				ret = ALIGN(current, alignment);
-				break;
-			}
-			if ((ALIGN(current, alignment) + alignment + filesize <
-			     top)
-			    && (ALIGN(current, alignment) + alignment -
-				headersize > current)
-			    && in_segment(ALIGN(current, alignment) + alignment,
-					  filesize, alignment)) {
-				ret = ALIGN(current, alignment) + alignment;
-				break;
-			}
-		}
-		current =
-		    ALIGN(current + ntohl(thisfile->len) +
-			  ntohl(thisfile->offset), align);
-	}
-
-	free(rom);
-	return ret;
-}
diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h
index e197143bc7..f6a417e4c7 100644
--- a/util/cbfstool/common.h
+++ b/util/cbfstool/common.h
@@ -31,7 +31,7 @@
 #endif
 #define ntohll(x)	(is_big_endian() ? (x) : swab64(x))
 #define htonll(x)	(is_big_endian() ? (x) : swab64(x))
-extern int is_big_endian(void);
+int is_big_endian(void);
 
 /* Message output */
 extern int verbose;
@@ -41,6 +41,12 @@ extern int verbose;
 #define INFO(x...) { if (verbose > 0) fprintf(stderr, "INFO: " x); }
 #define DEBUG(x...) { if (verbose > 1) fprintf(stderr, "DEBUG: " x); }
 
+/* Helpers */
+#define ARRAY_SIZE(a) (int)(sizeof(a) / sizeof((a)[0]))
+#define ALIGN(val, by) (((val) + (by)-1)&~((by)-1))
+
+#define unused __attribute__((unused))
+
 /* Buffer and file I/O */
 struct buffer {
 	char *name;
@@ -62,32 +68,12 @@ int buffer_write_file(struct buffer *buffer, const char *filename);
 /* Destroys a memory buffer. */
 void buffer_delete(struct buffer *buffer);
 
-extern void *offset;
-extern uint32_t romsize;
-extern int host_bigendian;
+/* Architecture handling */
 extern uint32_t arch;
 
 const char *arch_to_string(uint32_t a);
 uint32_t string_to_arch(const char *arch_string);
 
-static inline void *phys_to_virt(uint32_t addr)
-{
-	return offset + addr;
-}
-
-static inline uint32_t virt_to_phys(void *addr)
-{
-	return (unsigned long)(addr - offset) & 0xffffffff;
-}
-
-#define ALIGN(val, by) (((val) + (by)-1)&~((by)-1))
-
-size_t getfilesize(const char *filename);
-void *loadfile(const char *filename, uint32_t * romsize_p, void *content,
-	       int place);
-void *loadrom(const char *filename);
-int writerom(const char *filename, void *start, uint32_t size);
-
 int iself(unsigned char *input);
 
 typedef void (*comp_func_ptr) (char *, int, char *, int *);
@@ -96,6 +82,7 @@ typedef enum { CBFS_COMPRESS_NONE = 0, CBFS_COMPRESS_LZMA = 1 } comp_algo;
 comp_func_ptr compression_function(comp_algo algo);
 
 uint64_t intfiletype(const char *name);
+void print_supported_filetypes(void);
 
 /* cbfs-mkpayload.c */
 int parse_elf_to_payload(const struct buffer *input,
@@ -111,23 +98,9 @@ int parse_flat_binary_to_payload(const struct buffer *input,
 int parse_elf_to_stage(const struct buffer *input, struct buffer *output,
 		       comp_algo algo, uint32_t *location);
 
-void *create_cbfs_file(const char *filename, void *data, uint32_t * datasize,
-		       uint32_t type, uint32_t * location);
 
-int create_cbfs_image(const char *romfile, uint32_t romsize,
-		      const char *bootblock, uint32_t align, uint32_t offs);
-
-int add_file_to_cbfs(void *content, uint32_t contentsize, uint32_t location);
-int remove_file_from_cbfs(const char *filename);
-void print_cbfs_directory(const char *filename);
-int extract_file_from_cbfs(const char *filename, const char *payloadname, const char *outpath);
-int remove_file_from_cbfs(const char *filename);
-
-uint32_t cbfs_find_location(const char *romfile, uint32_t filesize,
-			    const char *filename, uint32_t align);
-
-void print_supported_filetypes(void);
-
-#define ARRAY_SIZE(a) (int)(sizeof(a) / sizeof((a)[0]))
+/* lzma/lzma.c */
+void do_lzma_compress(char *in, int in_len, char *out, int *out_len);
+void do_lzma_uncompress(char *dst, int dst_len, char *src, int src_len);
 
 #endif
diff --git a/util/cbfstool/compress.c b/util/cbfstool/compress.c
index 9ea1487ff9..38fa03dbed 100644
--- a/util/cbfstool/compress.c
+++ b/util/cbfstool/compress.c
@@ -26,8 +26,6 @@
 #include <stdio.h>
 #include "common.h"
 
-void do_lzma_compress(char *in, int in_len, char *out, int *out_len);
-
 static void lzma_compress(char *in, int in_len, char *out, int *out_len)
 {
 	do_lzma_compress(in, in_len, out, out_len);
diff --git a/util/cbfstool/lzma/C/LzmaEnc.c b/util/cbfstool/lzma/C/LzmaEnc.c
index aca097dae0..ea8b5ca4bb 100644
--- a/util/cbfstool/lzma/C/LzmaEnc.c
+++ b/util/cbfstool/lzma/C/LzmaEnc.c
@@ -88,7 +88,7 @@ UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
 
 #define kDicLogSizeMaxCompress 30
 
-#define BSR2_RET(pos, res) { unsigned long i; _BitScanReverse(&i, (pos)); res = (i + i) + ((pos >> (i - 1)) & 1); }
+#define BSR2_RET(pos, res) { unsigned long _i; _BitScanReverse(&_i, (pos)); res = (_i + _i) + ((pos >> (_i - 1)) & 1); }
 
 UInt32 GetPosSlot1(UInt32 pos)
 {
@@ -119,9 +119,9 @@ static void LzmaEnc_FastPosInit(Byte *g_FastPos)
   }
 }
 
-#define BSR2_RET(pos, res) { UInt32 i = 6 + ((kNumLogBits - 1) & \
+#define BSR2_RET(pos, res) { UInt32 _i = 6 + ((kNumLogBits - 1) & \
   (0 - (((((UInt32)1 << (kNumLogBits + 6)) - 1) - pos) >> 31))); \
-  res = p->g_FastPos[pos >> i] + (i * 2); }
+  res = p->g_FastPos[pos >> _i] + (_i * 2); }
 /*
 #define BSR2_RET(pos, res) { res = (pos < (1 << (kNumLogBits + 6))) ? \
   p->g_FastPos[pos >> 6] + 12 : \
@@ -1123,11 +1123,9 @@ static UInt32 GetOptimum(CLzmaEnc *p, UInt32 position, UInt32 *backRes)
 
   for (;;)
   {
-    UInt32 numAvailFull, newLen, numPairs, posPrev, state, posState, startLen;
-    UInt32 curPrice, curAnd1Price, matchPrice, repMatchPrice;
+    UInt32 numAvailFull, newLen, posPrev, state, startLen;
+    UInt32 curPrice, curAnd1Price;
     Bool nextIsChar;
-    Byte curByte, matchByte;
-    const Byte *data;
     COptimal *curOpt;
     COptimal *nextOpt;
 
@@ -1190,7 +1188,6 @@ static UInt32 GetOptimum(CLzmaEnc *p, UInt32 position, UInt32 *backRes)
       prevOpt = &p->opt[posPrev];
       if (pos < LZMA_NUM_REPS)
       {
-        UInt32 i;
         reps[0] = prevOpt->backs[pos];
         for (i = 1; i <= pos; i++)
           reps[i] = prevOpt->backs[i - 1];
@@ -1199,7 +1196,6 @@ static UInt32 GetOptimum(CLzmaEnc *p, UInt32 position, UInt32 *backRes)
       }
       else
       {
-        UInt32 i;
         reps[0] = (pos - LZMA_NUM_REPS);
         for (i = 1; i < LZMA_NUM_REPS; i++)
           reps[i] = prevOpt->backs[i - 1];
@@ -1396,7 +1392,7 @@ static UInt32 GetOptimum(CLzmaEnc *p, UInt32 position, UInt32 *backRes)
     }
     if (newLen >= startLen)
     {
-      UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);
+      normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);
       UInt32 offs, curBack, posSlot;
       UInt32 lenTest;
       while (lenEnd < cur + newLen)
@@ -1454,8 +1450,6 @@ static UInt32 GetOptimum(CLzmaEnc *p, UInt32 position, UInt32 *backRes)
             /* for (; lenTest2 >= 2; lenTest2--) */
             {
               UInt32 offset = cur + lenTest + 1 + lenTest2;
-              UInt32 curAndLenPrice;
-              COptimal *opt;
               while (lenEnd < offset)
                 p->opt[++lenEnd].price = kInfinityPrice;
               curAndLenPrice = nextRepMatchPrice + GetRepPrice(p, 0, lenTest2, state2, posStateNext);
@@ -1663,7 +1657,6 @@ static void FillDistancesPrices(CLzmaEnc *p)
 
     {
       UInt32 *distancesPrices = p->distancesPrices[lenToPosState];
-      UInt32 i;
       for (i = 0; i < kStartPosModelIndex; i++)
         distancesPrices[i] = posSlotPrices[i];
       for (; i < kNumFullDistances; i++)
diff --git a/util/cbfstool/lzma/lzma.c b/util/cbfstool/lzma/lzma.c
index 579784eae0..330e42cd6b 100644
--- a/util/cbfstool/lzma/lzma.c
+++ b/util/cbfstool/lzma/lzma.c
@@ -47,12 +47,12 @@ static void put_64(void *p, uint64_t value)
 
 /* Memory Allocation API */
 
-static void *SzAlloc(void *unused, size_t size)
+static void *SzAlloc(unused void *u, size_t size)
 {
 	return malloc(size);
 }
 
-static void SzFree(void *unused, void *address)
+static void SzFree(unused void *u, void *address)
 {
 	free(address);
 }
@@ -69,7 +69,7 @@ typedef struct {
 
 static vector_t instream, outstream;
 
-static SRes Read(void *unused, void *buf, size_t *size)
+static SRes Read(unused void *u, void *buf, size_t *size)
 {
 	if ((instream.size - instream.pos) < *size)
 		*size = instream.size - instream.pos;
@@ -78,7 +78,7 @@ static SRes Read(void *unused, void *buf, size_t *size)
 	return SZ_OK;
 }
 
-static size_t Write(void *unused, const void *buf, size_t size)
+static size_t Write(unused void *u, const void *buf, size_t size)
 {
 	if(outstream.size - outstream.pos < size)
 		size = outstream.size - outstream.pos;