	@@ -1,13 +1,15 @@		@@ -1,13 +1,15 @@
		1	/* $NetBSD: data.c,v 1.3 2017/06/08 16:00:40 skrll Exp $ */
		2
1	/*	3	/*
2	* (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.	4	* (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.
3	*	5	*
4	*	6	*
5	* This program is free software; you can redistribute it and/or	7	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License as	8	* modify it under the terms of the GNU General Public License as
7	* published by the Free Software Foundation; either version 2 of the	9	* published by the Free Software Foundation; either version 2 of the
8	* License, or (at your option) any later version.	10	* License, or (at your option) any later version.
9	*	11	*
10	* This program is distributed in the hope that it will be useful,	12	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	* General Public License for more details.	15	* General Public License for more details.
	@@ -161,60 +163,60 @@ struct data data_merge(struct data d1, s		@@ -161,60 +163,60 @@ struct data data_merge(struct data d1, s
161	/* Adjust for the length of d1 */	163	/* Adjust for the length of d1 */
162	for_each_marker(m2)	164	for_each_marker(m2)
163	m2->offset += d1.len;	165	m2->offset += d1.len;
164		166
165	d2.markers = NULL; /* So data_free() doesn't clobber them */	167	d2.markers = NULL; /* So data_free() doesn't clobber them */
166	data_free(d2);	168	data_free(d2);
167		169
168	return d;	170	return d;
169	}	171	}
170		172
171	struct data data_append_integer(struct data d, uint64_t value, int bits)	173	struct data data_append_integer(struct data d, uint64_t value, int bits)
172	{	174	{
173	uint8_t value_8;	175	uint8_t value_8;
174	uint16_t value_16;	176	fdt16_t value_16;
175	uint32_t value_32;	177	fdt32_t value_32;
176	uint64_t value_64;	178	fdt64_t value_64;
177		179
178	switch (bits) {	180	switch (bits) {
179	case 8:	181	case 8:
180	value_8 = value;	182	value_8 = value;
181	return data_append_data(d, &value_8, 1);	183	return data_append_data(d, &value_8, 1);
182		184
183	case 16:	185	case 16:
184	value_16 = cpu_to_fdt16(value);	186	value_16 = cpu_to_fdt16(value);
185	return data_append_data(d, &value_16, 2);	187	return data_append_data(d, &value_16, 2);
186		188
187	case 32:	189	case 32:
188	value_32 = cpu_to_fdt32(value);	190	value_32 = cpu_to_fdt32(value);
189	return data_append_data(d, &value_32, 4);	191	return data_append_data(d, &value_32, 4);
190		192
191	case 64:	193	case 64:
192	value_64 = cpu_to_fdt64(value);	194	value_64 = cpu_to_fdt64(value);
193	return data_append_data(d, &value_64, 8);	195	return data_append_data(d, &value_64, 8);
194		196
195	default:	197	default:
196	die("Invalid literal size (%d)\n", bits);	198	die("Invalid literal size (%d)\n", bits);
197	}	199	}
198	}	200	}
199		201
200	struct data data_append_re(struct data d, const struct fdt_reserve_entry *re)	202	struct data data_append_re(struct data d, uint64_t address, uint64_t size)
201	{	203	{
202	struct fdt_reserve_entry bere;	204	struct fdt_reserve_entry re;
203		205
204	bere.address = cpu_to_fdt64(re->address);	206	re.address = cpu_to_fdt64(address);
205	bere.size = cpu_to_fdt64(re->size);	207	re.size = cpu_to_fdt64(size);
206		208
207	return data_append_data(d, &bere, sizeof(bere));	209	return data_append_data(d, &re, sizeof(re));
208	}	210	}
209		211
210	struct data data_append_cell(struct data d, cell_t word)	212	struct data data_append_cell(struct data d, cell_t word)
211	{	213	{
212	return data_append_integer(d, word, sizeof(word) * 8);	214	return data_append_integer(d, word, sizeof(word) * 8);
213	}	215	}
214		216
215	struct data data_append_addr(struct data d, uint64_t addr)	217	struct data data_append_addr(struct data d, uint64_t addr)
216	{	218	{
217	return data_append_integer(d, addr, sizeof(addr) * 8);	219	return data_append_integer(d, addr, sizeof(addr) * 8);
218	}	220	}
219		221
220	struct data data_append_byte(struct data d, uint8_t byte)	222	struct data data_append_byte(struct data d, uint8_t byte)

 @@ -1,13 +1,15 @@
 /*	$NetBSD: dtc-lexer.l,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
+ *
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  General Public License for more details.
 @@ -52,77 +54,91 @@ extern bool treesource_error;
 #ifdef LEXDEBUG
 #define DPRINT(fmt, ...)	fprintf(stderr, fmt, ##__VA_ARGS__)
 #else
 #define DPRINT(fmt, ...)	do { } while (0)
 #endif
 static int dts_version = 1;
 #define BEGIN_DEFAULT()		DPRINT("<V1>\n"); \
 				BEGIN(V1); \
 static void push_input_file(const char *filename);
 static bool pop_input_file(void);
-static void lexical_error(const char *fmt, ...);
+static void PRINTF(1, 2) lexical_error(const char *fmt, ...);
 %}
 %%
 <*>"/include/"{WS}*{STRING} {
 			char *name = strchr(yytext, '\"') + 1;
 			yytext[yyleng-1] = '\0';
 			push_input_file(name);
+		}
 <*>^"#"(line)?[ \t]+[0-9]+[ \t]+{STRING}([ \t]+[0-9]+)? {
-			char *line, *tmp, *fn;
+			char *line, *fnstart, *fnend;
 			struct data fn;
 			/* skip text before line # */
 			line = yytext;
 			while (!isdigit((unsigned char)*line))
 				line++;
 			/* skip digits in line # */
-			tmp = line;
+			/* regexp ensures that first and list "
-			while (!isspace((unsigned char)*tmp))
+			 * in the whole yytext are those at
-				tmp++;
+			 * beginning and end of the filename string */
-			/* "NULL"-terminate line # */
+			fnstart = memchr(yytext, '"', yyleng);
-			*tmp = '\0';
+			for (fnend = yytext + yyleng - 1;
-			/* start of filename */
+			     *fnend != '"'; fnend--)
 			fn = strchr(tmp + 1, '"') + 1;
-			/* strip trailing " from filename */
+			assert(fnstart && fnend && (fnend > fnstart));
 			tmp = strchr(fn, '"');
-			*tmp = 0;
+			fn = data_copy_escape_string(fnstart + 1,
 						     fnend - fnstart - 1);
 			/* Don't allow nuls in filenames */
 			if (memchr(fn.val, '\0', fn.len - 1))
 				lexical_error("nul in line number directive");
 			/* -1 since #line is the number of the next line */
-			srcpos_set_line(xstrdup(fn), atoi(line) - 1);
+			srcpos_set_line(xstrdup(fn.val), atoi(line) - 1);
 			data_free(fn);
+		}
 <*><<EOF>>		{
 			if (!pop_input_file()) {
 				yyterminate();
+			}
+		}
 <*>{STRING}	{
 			DPRINT("String: %s\n", yytext);
 			yylval.data = data_copy_escape_string(yytext+1,
 					yyleng-2);
 			return DT_STRING;
+		}
 <*>"/dts-v1/"	{
 			DPRINT("Keyword: /dts-v1/\n");
 			dts_version = 1;
 			BEGIN_DEFAULT();
 			return DT_V1;
+		}
 <*>"/plugin/"	{
 			DPRINT("Keyword: /plugin/\n");
 			return DT_PLUGIN;
+		}
 <*>"/memreserve/"	{
 			DPRINT("Keyword: /memreserve/\n");
 			BEGIN_DEFAULT();
 			return DT_MEMRESERVE;
+		}
 <*>"/bits/"	{
 			DPRINT("Keyword: /bits/\n");
 			BEGIN_DEFAULT();
 			return DT_BITS;
+		}
 <*>"/delete-property/"	{
 @@ -143,56 +159,59 @@ static void lexical_error(const char *fm
 			DPRINT("Label: %s\n", yytext);
 			yylval.labelref = xstrdup(yytext);
 			yylval.labelref[yyleng-1] = '\0';
 			return DT_LABEL;
+		}
 <V1>([0-9]+|0[xX][0-9a-fA-F]+)(U|L|UL|LL|ULL)? {
 			char *e;
 			DPRINT("Integer Literal: '%s'\n", yytext);
 			errno = 0;
 			yylval.integer = strtoull(yytext, &e, 0);
-			assert(!(*e) || !e[strspn(e, "UL")]);
+			if (*e && e[strspn(e, "UL")]) {
 				lexical_error("Bad integer literal '%s'",
 					      yytext);
+			}
 			if (errno == ERANGE)
 				lexical_error("Integer literal '%s' out of range",
 					      yytext);
 			else
 				/* ERANGE is the only strtoull error triggerable
 				 *  by strings matching the pattern */
 				assert(errno == 0);
 			return DT_LITERAL;
+		}
 <*>{CHAR_LITERAL}	{
 			struct data d;
 			DPRINT("Character literal: %s\n", yytext);
 			d = data_copy_escape_string(yytext+1, yyleng-2);
 			if (d.len == 1) {
 				lexical_error("Empty character literal");
 				yylval.integer = 0;
-				return DT_CHAR_LITERAL;
+			} else {
 				yylval.integer = (unsigned char)d.val[0];
-			yylval.integer = (unsigned char)d.val[0];
+				if (d.len > 2)
 					lexical_error("Character literal has %d"
-			if (d.len > 2)
+						      " characters instead of 1",
-				lexical_error("Character literal has %d"
+						      d.len - 1);
 					      " characters instead of 1",
 					      d.len - 1);
 			data_free(d);
 			return DT_CHAR_LITERAL;
+		}
 <*>\&{LABEL}	{	/* label reference */
 			DPRINT("Ref: %s\n", yytext+1);
 			yylval.labelref = xstrdup(yytext+1);
 			return DT_REF;
+		}
 <*>"&{/"{PATHCHAR}*\}	{	/* new-style path reference */
 			yytext[yyleng-1] = '\0';
 			DPRINT("Ref: %s\n", yytext+2);
 			yylval.labelref = xstrdup(yytext+2);

 @@ -1,90 +1,97 @@
 /*	$NetBSD: dtc-parser.y,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
+ *
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  *                                                                   USA
  */
 %{
 #include <stdio.h>
 #include <inttypes.h>
 #include "dtc.h"
 #include "srcpos.h"
 extern int yylex(void);
 #ifndef YYBYACC
 extern void yyerror(char const *s);
 #else
 #include "dtc-parser.h"
 #endif
 #define ERROR(loc, ...) \
 	do { \
 		srcpos_error((loc), "Error", __VA_ARGS__); \
 		treesource_error = true; \
 	} while (0)
-extern struct boot_info *the_boot_info;
+extern struct dt_info *parser_output;
 extern bool treesource_error;
 %}
 %union {
 	char *propnodename;
 	char *labelref;
 	uint8_t byte;
 	struct data data;
 	struct {
 		struct data	data;
 		int		bits;
 	} array;
 	struct property *prop;
 	struct property *proplist;
 	struct node *node;
 	struct node *nodelist;
 	struct reserve_info *re;
 	uint64_t integer;
 	unsigned int flags;
+}
 %token DT_V1
 %token DT_PLUGIN
 %token DT_MEMRESERVE
 %token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
 %token DT_BITS
 %token DT_DEL_PROP
 %token DT_DEL_NODE
 %token <propnodename> DT_PROPNODENAME
 %token <integer> DT_LITERAL
 %token <integer> DT_CHAR_LITERAL
 %token <byte> DT_BYTE
 %token <data> DT_STRING
 %token <labelref> DT_LABEL
 %token <labelref> DT_REF
 %token DT_INCBIN
 %type <data> propdata
 %type <data> propdataprefix
 %type <flags> header
 %type <flags> headers
 %type <re> memreserve
 %type <re> memreserves
 %type <array> arrayprefix
 %type <data> bytestring
 %type <prop> propdef
 %type <proplist> proplist
 %type <node> devicetree
 %type <node> nodedef
 %type <node> subnode
 %type <nodelist> subnodes
 %type <integer> integer_prim
 @@ -95,30 +102,51 @@ extern bool treesource_error;
 %type <integer> integer_rela
 %type <integer> integer_eq
 %type <integer> integer_bitand
 %type <integer> integer_bitxor
 %type <integer> integer_bitor
 %type <integer> integer_and
 %type <integer> integer_or
 %type <integer> integer_trinary
 %type <integer> integer_expr
 %%
 sourcefile:
-	  DT_V1 ';' memreserves devicetree
+	  headers memreserves devicetree
+		{
 			parser_output = build_dt_info($1, $2, $3,
 			                              guess_boot_cpuid($3));
+		}
+	;
 header:
 	  DT_V1 ';'
+		{
 			$$ = DTSF_V1;
+		}
 	| DT_V1 ';' DT_PLUGIN ';'
+		{
 			$$ = DTSF_V1 | DTSF_PLUGIN;
+		}
+	;
 headers:
 	  header
 	| header headers
+		{
-			the_boot_info = build_boot_info($3, $4,
+			if ($2 != $1)
-							guess_boot_cpuid($4));
+				ERROR(&@2, "Header flags don't match earlier ones");
 			$$ = $1;
+		}
+	;
 memreserves:
 	  /* empty */
+		{
 			$$ = NULL;
+		}
 	| memreserve memreserves
+		{
 			$$ = chain_reserve_entry($1, $2);
+		}
+	;
 @@ -139,30 +167,30 @@ devicetree:
 	  '/' nodedef
+		{
 			$$ = name_node($2, "");
+		}
 	| devicetree '/' nodedef
+		{
 			$$ = merge_nodes($1, $3);
+		}
 	| devicetree DT_LABEL DT_REF nodedef
+		{
 			struct node *target = get_node_by_ref($1, $3);
-			add_label(&target->labels, $2);
+			if (target) {
-			if (target)
+				add_label(&target->labels, $2);
 				merge_nodes(target, $4);
-			else
+			} else
 				ERROR(&@3, "Label or path %s not found", $3);
 			$$ = $1;
+		}
 	| devicetree DT_REF nodedef
+		{
 			struct node *target = get_node_by_ref($1, $2);
 			if (target)
 				merge_nodes(target, $3);
 			else
 				ERROR(&@2, "Label or path %s not found", $2);
 			$$ = $1;
+		}
 @@ -404,28 +432,44 @@ integer_shift:
 	  integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
 	| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
 	| integer_add
+	;
 integer_add:
 	  integer_add '+' integer_mul { $$ = $1 + $3; }
 	| integer_add '-' integer_mul { $$ = $1 - $3; }
 	| integer_mul
+	;
 integer_mul:
 	  integer_mul '*' integer_unary { $$ = $1 * $3; }
-	| integer_mul '/' integer_unary { $$ = $1 / $3; }
+	| integer_mul '/' integer_unary
 	| integer_mul '%' integer_unary { $$ = $1 % $3; }
 			if ($3 != 0) {
 				$$ = $1 / $3;
 			} else {
 				ERROR(&@$, "Division by zero");
 				$$ = 0;
+			}
+		}
 	| integer_mul '%' integer_unary
+		{
 			if ($3 != 0) {
 				$$ = $1 % $3;
 			} else {
 				ERROR(&@$, "Division by zero");
 				$$ = 0;
+			}
+		}
 	| integer_unary
+	;
 integer_unary:
 	  integer_prim
 	| '-' integer_unary { $$ = -$2; }
 	| '~' integer_unary { $$ = ~$2; }
 	| '!' integer_unary { $$ = !$2; }
+	;
 bytestring:
 	  /* empty */
+		{

 @@ -1,13 +1,15 @@
 /*	$NetBSD: dtc.h,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 #ifndef _DTC_H
 #define _DTC_H
 /*
  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
+ *
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
+ *
  *  This program is distributed in the hope that it will be useful,
 @@ -33,37 +35,40 @@
 #include <unistd.h>
 #include <libfdt_env.h>
 #include <fdt.h>
 #include "util.h"
 #ifdef DEBUG
 #define debug(...)	printf(__VA_ARGS__)
 #else
 #define debug(...)
 #endif
 #define DEFAULT_FDT_VERSION	17
 /*
  * Command line options
  */
 extern int quiet;		/* Level of quietness */
 extern int reservenum;		/* Number of memory reservation slots */
 extern int minsize;		/* Minimum blob size */
 extern int padsize;		/* Additional padding to blob */
 extern int alignsize;		/* Additional padding to blob accroding to the alignsize */
 extern int phandle_format;	/* Use linux,phandle or phandle properties */
 extern int generate_symbols;	/* generate symbols for nodes with labels */
 extern int generate_fixups;	/* generate fixups */
 extern int auto_label_aliases;	/* auto generate labels -> aliases */
 #define PHANDLE_LEGACY	0x1
 #define PHANDLE_EPAPR	0x2
 #define PHANDLE_BOTH	0x3
 typedef uint32_t cell_t;
 #define streq(a, b)	(strcmp((a), (b)) == 0)
 #define strneq(a, b, n)	(strncmp((a), (b), (n)) == 0)
 /* Data blobs */
 enum markertype {
 @@ -98,27 +103,27 @@ void data_free(struct data d);
 struct data data_grow_for(struct data d, int xlen);
 struct data data_copy_mem(const char *mem, int len);
 struct data data_copy_escape_string(const char *s, int len);
 struct data data_copy_file(FILE *f, size_t len);
 struct data data_append_data(struct data d, const void *p, int len);
 struct data data_insert_at_marker(struct data d, struct marker *m,
 				  const void *p, int len);
 struct data data_merge(struct data d1, struct data d2);
 struct data data_append_cell(struct data d, cell_t word);
 struct data data_append_integer(struct data d, uint64_t word, int bits);
-struct data data_append_re(struct data d, const struct fdt_reserve_entry *re);
+struct data data_append_re(struct data d, uint64_t address, uint64_t size);
 struct data data_append_addr(struct data d, uint64_t addr);
 struct data data_append_byte(struct data d, uint8_t byte);
 struct data data_append_zeroes(struct data d, int len);
 struct data data_append_align(struct data d, int align);
 struct data data_add_marker(struct data d, enum markertype type, char *ref);
 bool data_is_one_string(struct data d);
 /* DT constraints */
 #define MAX_PROPNAME_LEN	31
 #define MAX_NODENAME_LEN	31
 @@ -189,79 +194,91 @@ struct property *reverse_properties(stru
 struct node *build_node(struct property *proplist, struct node *children);
 struct node *build_node_delete(void);
 struct node *name_node(struct node *node, char *name);
 struct node *chain_node(struct node *first, struct node *list);
 struct node *merge_nodes(struct node *old_node, struct node *new_node);
 void add_property(struct node *node, struct property *prop);
 void delete_property_by_name(struct node *node, char *name);
 void delete_property(struct property *prop);
 void add_child(struct node *parent, struct node *child);
 void delete_node_by_name(struct node *parent, char *name);
 void delete_node(struct node *node);
 void append_to_property(struct node *node,
 			char *name, const void *data, int len);
 const char *get_unitname(struct node *node);
 struct property *get_property(struct node *node, const char *propname);
 cell_t propval_cell(struct property *prop);
 struct property *get_property_by_label(struct node *tree, const char *label,
 				       struct node **node);
 struct marker *get_marker_label(struct node *tree, const char *label,
 				struct node **node, struct property **prop);
 struct node *get_subnode(struct node *node, const char *nodename);
 struct node *get_node_by_path(struct node *tree, const char *path);
 struct node *get_node_by_label(struct node *tree, const char *label);
 struct node *get_node_by_phandle(struct node *tree, cell_t phandle);
 struct node *get_node_by_ref(struct node *tree, const char *ref);
 cell_t get_node_phandle(struct node *root, struct node *node);
 uint32_t guess_boot_cpuid(struct node *tree);
 /* Boot info (tree plus memreserve information */
 struct reserve_info {
-	struct fdt_reserve_entry re;
+	uint64_t address, size;
 	struct reserve_info *next;
 	struct label *labels;
 };
 struct reserve_info *build_reserve_entry(uint64_t start, uint64_t len);
 struct reserve_info *chain_reserve_entry(struct reserve_info *first,
 					 struct reserve_info *list);
 struct reserve_info *add_reserve_entry(struct reserve_info *list,
 				       struct reserve_info *new);
-struct boot_info {
+struct dt_info {
 	unsigned int dtsflags;
 	struct reserve_info *reservelist;
 	struct node *dt;		/* the device tree */
 	uint32_t boot_cpuid_phys;
 	struct node *dt;		/* the device tree */
 	const char *outname;		/* filename being written to, "-" for stdout */
 };
-struct boot_info *build_boot_info(struct reserve_info *reservelist,
+/* DTS version flags definitions */
-				  struct node *tree, uint32_t boot_cpuid_phys);
+#define DTSF_V1		0x0001	/* /dts-v1/ */
-void sort_tree(struct boot_info *bi);
+#define DTSF_PLUGIN	0x0002	/* /plugin/ */
 struct dt_info *build_dt_info(unsigned int dtsflags,
 			      struct reserve_info *reservelist,
 			      struct node *tree, uint32_t boot_cpuid_phys);
 void sort_tree(struct dt_info *dti);
 void generate_label_tree(struct dt_info *dti, char *name, bool allocph);
 void generate_fixups_tree(struct dt_info *dti, char *name);
 void generate_local_fixups_tree(struct dt_info *dti, char *name);
 /* Checks */
 void parse_checks_option(bool warn, bool error, const char *arg);
-void process_checks(bool force, struct boot_info *bi);
+void process_checks(bool force, struct dt_info *dti);
 /* Flattened trees */
-void dt_to_blob(FILE *f, struct boot_info *bi, int version);
+void dt_to_blob(FILE *f, struct dt_info *dti, int version);
-void dt_to_asm(FILE *f, struct boot_info *bi, int version);
+void dt_to_asm(FILE *f, struct dt_info *dti, int version);
-struct boot_info *dt_from_blob(const char *fname);
+struct dt_info *dt_from_blob(const char *fname);
 /* Tree source */
-void dt_to_source(FILE *f, struct boot_info *bi);
+void dt_to_source(FILE *f, struct dt_info *dti);
-struct boot_info *dt_from_source(const char *f);
+struct dt_info *dt_from_source(const char *f);
 /* FS trees */
-struct boot_info *dt_from_fs(const char *dirname);
+struct dt_info *dt_from_fs(const char *dirname);
 #endif /* _DTC_H */

 @@ -1,31 +1,36 @@
 /*	$NetBSD: fdtdump.c,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * fdtdump.c - Contributed by Pantelis Antoniou <pantelis.antoniou AT gmail.com>
  */
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <libfdt.h>
 #include <libfdt_env.h>
 #include <fdt.h>
 #include "util.h"
-#define GET_CELL(p)	(p += 4, *((const uint32_t *)(p-4)))
+#define FDT_MAGIC_SIZE	4
 #define MAX_VERSION 17
 #define GET_CELL(p)	(p += 4, *((const fdt32_t *)(p-4)))
 static const char *tagname(uint32_t tag)
+{
 	static const char * const names[] = {
 #define TN(t) [t] = #t
 		TN(FDT_BEGIN_NODE),
 		TN(FDT_END_NODE),
 		TN(FDT_PROP),
 		TN(FDT_NOP),
 		TN(FDT_END),
 #undef TN
 	};
 	if (tag < ARRAY_SIZE(names))
 @@ -145,26 +150,40 @@ static void dump_blob(void *blob, bool d
 static const char usage_synopsis[] = "fdtdump [options] <file>";
 static const char usage_short_opts[] = "ds" USAGE_COMMON_SHORT_OPTS;
 static struct option const usage_long_opts[] = {
 	{"debug",            no_argument, NULL, 'd'},
 	{"scan",             no_argument, NULL, 's'},
 	USAGE_COMMON_LONG_OPTS
 };
 static const char * const usage_opts_help[] = {
 	"Dump debug information while decoding the file",
 	"Scan for an embedded fdt in file",
 	USAGE_COMMON_OPTS_HELP
 };
 static bool valid_header(char *p, off_t len)
+{
 	if (len < sizeof(struct fdt_header) ||
 	    fdt_magic(p) != FDT_MAGIC ||
 	    fdt_version(p) > MAX_VERSION ||
 	    fdt_last_comp_version(p) >= MAX_VERSION ||
 	    fdt_totalsize(p) >= len ||
 	    fdt_off_dt_struct(p) >= len ||
 	    fdt_off_dt_strings(p) >= len)
 		return 0;
 	else
 		return 1;
+}
 int main(int argc, char *argv[])
+{
 	int opt;
 	const char *file;
 	char *buf;
 	bool debug = false;
 	bool scan = false;
 	off_t len;
 	while ((opt = util_getopt_long()) != EOF) {
 		switch (opt) {
 		case_USAGE_COMMON_FLAGS
 @@ -176,50 +195,46 @@ int main(int argc, char *argv[])
 			break;
+		}
+	}
 	if (optind != argc - 1)
 		usage("missing input filename");
 	file = argv[optind];
 	buf = utilfdt_read_len(file, &len);
 	if (!buf)
 		die("could not read: %s\n", file);
 	/* try and locate an embedded fdt in a bigger blob */
 	if (scan) {
-		unsigned char smagic[4];
+		unsigned char smagic[FDT_MAGIC_SIZE];
 		char *p = buf;
 		char *endp = buf + len;
 		fdt_set_magic(smagic, FDT_MAGIC);
 		/* poor man's memmem */
-		while (true) {
+		while ((endp - p) >= FDT_MAGIC_SIZE) {
-			p = memchr(p, smagic[0], endp - p - 4);
+			p = memchr(p, smagic[0], endp - p - FDT_MAGIC_SIZE);
 			if (!p)
 				break;
 			if (fdt_magic(p) == FDT_MAGIC) {
 				/* try and validate the main struct */
 				off_t this_len = endp - p;
-				fdt32_t max_version = 17;
+				if (valid_header(p, this_len))
 				if (fdt_version(p) <= max_version &&
 				    fdt_last_comp_version(p) < max_version &&
 				    fdt_totalsize(p) < this_len &&
 				    fdt_off_dt_struct(p) < this_len &&
 					fdt_off_dt_strings(p) < this_len)
 					break;
 				if (debug)
 					printf("%s: skipping fdt magic at offset %#zx\n",
 						file, p - buf);
+			}
 			++p;
+		}
-		if (!p)
+		if (!p || endp - p < sizeof(struct fdt_header))
 			die("%s: could not locate fdt magic\n", file);
 		printf("%s: found fdt at offset %#zx\n", file, p - buf);
 		buf = p;
 	} else if (!valid_header(buf, len))
 		die("%s: header is not valid\n", file);
 	dump_blob(buf, debug);
 	return 0;
+}

 @@ -1,13 +1,15 @@
 /*	$NetBSD: fdtput.c,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
 @@ -57,27 +59,27 @@ static void report_error(const char *nam
 	if (namelen == -1)
 		namelen = strlen(name);
 	fprintf(stderr, "Error at '%1.*s': %s\n", namelen, name,
 		fdt_strerror(err));
+}
 /**
  * Encode a series of arguments in a property value.
+ *
  * @param disp		Display information / options
  * @param arg		List of arguments from command line
  * @param arg_count	Number of arguments (may be 0)
  * @param valuep	Returns buffer containing value
- * @param *value_len	Returns length of value encoded
+ * @param value_len	Returns length of value encoded
  */
 static int encode_value(struct display_info *disp, char **arg, int arg_count,
 			char **valuep, int *value_len)
+{
 	char *value = NULL;	/* holding area for value */
 	int value_size = 0;	/* size of holding area */
 	char *ptr;		/* pointer to current value position */
 	int len;		/* length of this cell/string/byte */
 	int ival;
 	int upto;	/* the number of bytes we have written to buf */
 	char fmt[3];
 	upto = 0;
 @@ -97,27 +99,27 @@ static int encode_value(struct display_i
 		/* enlarge our value buffer by a suitable margin if needed */
 		if (upto + len > value_size) {
 			value_size = (upto + len) + 500;
 			value = xrealloc(value, value_size);
+		}
 		ptr = value + upto;
 		if (disp->type == 's') {
 			memcpy(ptr, *arg, len);
 			if (disp->verbose)
 				fprintf(stderr, "\tstring: '%s'\n", ptr);
 		} else {
-			int *iptr = (int *)ptr;
+			fdt32_t *iptr = (fdt32_t *)ptr;
 			sscanf(*arg, fmt, &ival);
 			if (len == 4)
 				*iptr = cpu_to_fdt32(ival);
 			else
 				*ptr = (uint8_t)ival;
 			if (disp->verbose) {
 				fprintf(stderr, "\t%s: %d\n",
 					disp->size == 1 ? "byte" :
 					disp->size == 2 ? "short" : "int",
 					ival);
+			}
+		}
+	}
 @@ -318,27 +320,27 @@ static int delete_node(char *blob, const
 	node = fdt_del_node(blob, node);
 	if (node < 0) {
 		report_error(node_name, -1, node);
 		return -1;
+	}
 	return 0;
+}
 static int do_fdtput(struct display_info *disp, const char *filename,
 		    char **arg, int arg_count)
+{
-	char *value;
+	char *value = NULL;
 	char *blob;
 	char *node;
 	int len, ret = 0;
 	blob = utilfdt_read(filename);
 	if (!blob)
 		return -1;
 	switch (disp->oper) {
 	case OPER_WRITE_PROP:
 		/*
 		 * Convert the arguments into a single binary value, then
 		 * store them into the property.
 @@ -364,26 +366,31 @@ static int do_fdtput(struct display_info
 		break;
 	case OPER_DELETE_PROP:
 		node = *arg;
 		for (arg++; ret >= 0 && arg_count-- > 1; arg++)
 			ret = delete_prop(blob, node, *arg);
 		break;
+	}
 	if (ret >= 0) {
 		fdt_pack(blob);
 		ret = utilfdt_write(filename, blob);
+	}
 	free(blob);
 	if (value) {
 		free(value);
+	}
 	return ret;
+}
 /* Usage related data. */
 static const char usage_synopsis[] =
 	"write a property value to a device tree\n"
 	"	fdtput <options> <dt file> <node> <property> [<value>...]\n"
 	"	fdtput -c <options> <dt file> [<node>...]\n"
 	"	fdtput -r <options> <dt file> [<node>...]\n"
 	"	fdtput -d <options> <dt file> <node> [<property>...]\n"
 	"\n"
 	"The command line arguments are joined together into a single value.\n"
 	USAGE_TYPE_MSG;

 @@ -1,13 +1,15 @@
 /*	$NetBSD: flattree.c,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
+ *
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  General Public License for more details.
 @@ -39,42 +41,42 @@ static struct version_info {
 	 FTF_FULLPATH|FTF_VARALIGN|FTF_NAMEPROPS},
 	{2, 1, FDT_V2_SIZE,
 	 FTF_FULLPATH|FTF_VARALIGN|FTF_NAMEPROPS|FTF_BOOTCPUID},
 	{3, 1, FDT_V3_SIZE,
 	 FTF_FULLPATH|FTF_VARALIGN|FTF_NAMEPROPS|FTF_BOOTCPUID|FTF_STRTABSIZE},
 	{16, 16, FDT_V3_SIZE,
 	 FTF_BOOTCPUID|FTF_STRTABSIZE|FTF_NOPS},
 	{17, 16, FDT_V17_SIZE,
 	 FTF_BOOTCPUID|FTF_STRTABSIZE|FTF_STRUCTSIZE|FTF_NOPS},
 };
 struct emitter {
 	void (*cell)(void *, cell_t);
-	void (*string)(void *, char *, int);
+	void (*string)(void *, const char *, int);
 	void (*align)(void *, int);
 	void (*data)(void *, struct data);
 	void (*beginnode)(void *, struct label *labels);
 	void (*endnode)(void *, struct label *labels);
 	void (*property)(void *, struct label *labels);
 };
 static void bin_emit_cell(void *e, cell_t val)
+{
 	struct data *dtbuf = e;
 	*dtbuf = data_append_cell(*dtbuf, val);
+}
-static void bin_emit_string(void *e, char *str, int len)
+static void bin_emit_string(void *e, const char *str, int len)
+{
 	struct data *dtbuf = e;
 	if (len == 0)
 		len = strlen(str);
 	*dtbuf = data_append_data(*dtbuf, str, len);
 	*dtbuf = data_append_byte(*dtbuf, '\0');
+}
 static void bin_emit_align(void *e, int a)
+{
 	struct data *dtbuf = e;
 @@ -134,62 +136,54 @@ static void emit_offset_label(FILE *f, c
 		fprintf((f), "\t.byte\t((" fmt ") >> 8) & 0xff\n", __VA_ARGS__); \
 		fprintf((f), "\t.byte\t(" fmt ") & 0xff\n", __VA_ARGS__); \
+	}
 static void asm_emit_cell(void *e, cell_t val)
+{
 	FILE *f = e;
 	fprintf(f, "\t.byte 0x%02x; .byte 0x%02x; .byte 0x%02x; .byte 0x%02x\n",
 		(val >> 24) & 0xff, (val >> 16) & 0xff,
 		(val >> 8) & 0xff, val & 0xff);
+}
-static void asm_emit_string(void *e, char *str, int len)
+static void asm_emit_string(void *e, const char *str, int len)
+{
 	FILE *f = e;
 	char c = 0;
 	if (len != 0) {
 		/* XXX: ewww */
 		c = str[len];
 		str[len] = '\0';
-	fprintf(f, "\t.string\t\"%s\"\n", str);
+	if (len != 0)
 		fprintf(f, "\t.string\t\"%.*s\"\n", len, str);
-	if (len != 0) {
+	else
-		str[len] = c;
+		fprintf(f, "\t.string\t\"%s\"\n", str);
+}
 static void asm_emit_align(void *e, int a)
+{
 	FILE *f = e;
 	fprintf(f, "\t.balign\t%d, 0\n", a);
+}
 static void asm_emit_data(void *e, struct data d)
+{
 	FILE *f = e;
 	int off = 0;
 	struct marker *m = d.markers;
 	for_each_marker_of_type(m, LABEL)
 		emit_offset_label(f, m->ref, m->offset);
 	while ((d.len - off) >= sizeof(uint32_t)) {
-		asm_emit_cell(e, fdt32_to_cpu(*((uint32_t *)(d.val+off))));
+		asm_emit_cell(e, fdt32_to_cpu(*((fdt32_t *)(d.val+off))));
 		off += sizeof(uint32_t);
+	}
 	while ((d.len - off) >= 1) {
 		fprintf(f, "\t.byte\t0x%hhx\n", d.val[off]);
 		off += 1;
+	}
 	assert(off == d.len);
+}
 static void asm_emit_beginnode(void *e, struct label *labels)
+{
 @@ -308,37 +302,36 @@ static void flatten_tree(struct node *tr
 	for_each_child(tree, child) {
 		flatten_tree(child, emit, etarget, strbuf, vi);
+	}
 	emit->endnode(etarget, tree->labels);
+}
 static struct data flatten_reserve_list(struct reserve_info *reservelist,
 				 struct version_info *vi)
+{
 	struct reserve_info *re;
 	struct data d = empty_data;
 	static struct fdt_reserve_entry null_re = {0,0};
 	int    j;
 	for (re = reservelist; re; re = re->next) {
-		d = data_append_re(d, &re->re);
+		d = data_append_re(d, re->address, re->size);
+	}
 	/*
 	 * Add additional reserved slots if the user asked for them.
 	 */
 	for (j = 0; j < reservenum; j++) {
-		d = data_append_re(d, &null_re);
+		d = data_append_re(d, 0, 0);
+	}
 	return d;
+}
 static void make_fdt_header(struct fdt_header *fdt,
 			    struct version_info *vi,
 			    int reservesize, int dtsize, int strsize,
 			    int boot_cpuid_phys)
+{
 	int reserve_off;
 	reservesize += sizeof(struct fdt_reserve_entry);
 @@ -356,67 +349,74 @@ static void make_fdt_header(struct fdt_h
 	fdt->off_dt_struct = cpu_to_fdt32(reserve_off + reservesize);
 	fdt->off_dt_strings = cpu_to_fdt32(reserve_off + reservesize
 					  + dtsize);
 	fdt->totalsize = cpu_to_fdt32(reserve_off + reservesize + dtsize + strsize);
 	if (vi->flags & FTF_BOOTCPUID)
 		fdt->boot_cpuid_phys = cpu_to_fdt32(boot_cpuid_phys);
 	if (vi->flags & FTF_STRTABSIZE)
 		fdt->size_dt_strings = cpu_to_fdt32(strsize);
 	if (vi->flags & FTF_STRUCTSIZE)
 		fdt->size_dt_struct = cpu_to_fdt32(dtsize);
+}
-void dt_to_blob(FILE *f, struct boot_info *bi, int version)
+void dt_to_blob(FILE *f, struct dt_info *dti, int version)
+{
 	struct version_info *vi = NULL;
 	int i;
 	struct data blob       = empty_data;
 	struct data reservebuf = empty_data;
 	struct data dtbuf      = empty_data;
 	struct data strbuf     = empty_data;
 	struct fdt_header fdt;
 	int padlen = 0;
 	for (i = 0; i < ARRAY_SIZE(version_table); i++) {
 		if (version_table[i].version == version)
 			vi = &version_table[i];
+	}
 	if (!vi)
 		die("Unknown device tree blob version %d\n", version);
-	flatten_tree(bi->dt, &bin_emitter, &dtbuf, &strbuf, vi);
+	flatten_tree(dti->dt, &bin_emitter, &dtbuf, &strbuf, vi);
 	bin_emit_cell(&dtbuf, FDT_END);
-	reservebuf = flatten_reserve_list(bi->reservelist, vi);
+	reservebuf = flatten_reserve_list(dti->reservelist, vi);
 	/* Make header */
 	make_fdt_header(&fdt, vi, reservebuf.len, dtbuf.len, strbuf.len,
-			bi->boot_cpuid_phys);
+			dti->boot_cpuid_phys);
 	/*
 	 * If the user asked for more space than is used, adjust the totalsize.
 	 */
 	if (minsize > 0) {
 		padlen = minsize - fdt32_to_cpu(fdt.totalsize);
-		if ((padlen < 0) && (quiet < 1))
+		if (padlen < 0) {
-			fprintf(stderr,
+			padlen = 0;
-				"Warning: blob size %d >= minimum size %d\n",
+			if (quiet < 1)
-				fdt32_to_cpu(fdt.totalsize), minsize);
+				fprintf(stderr,
 					"Warning: blob size %d >= minimum size %d\n",
 					fdt32_to_cpu(fdt.totalsize), minsize);
+		}
+	}
 	if (padsize > 0)
 		padlen = padsize;
 	if (alignsize > 0)
 		padlen = ALIGN(fdt32_to_cpu(fdt.totalsize) + padlen, alignsize)
 			- fdt32_to_cpu(fdt.totalsize);
 	if (padlen > 0) {
 		int tsize = fdt32_to_cpu(fdt.totalsize);
 		tsize += padlen;
 		fdt.totalsize = cpu_to_fdt32(tsize);
+	}
 	/*
 	 * Assemble the blob: start with the header, add with alignment
 	 * the reserve buffer, add the reserve map terminating zeroes,
 	 * the device tree itself, and finally the strings.
 	 */
 	blob = data_append_data(blob, &fdt, vi->hdr_size);
 	blob = data_append_align(blob, 8);
 @@ -450,27 +450,27 @@ static void dump_stringtable_asm(FILE *f
+{
 	const char *p;
 	int len;
 	p = strbuf.val;
 	while (p < (strbuf.val + strbuf.len)) {
 		len = strlen(p);
 		fprintf(f, "\t.string \"%s\"\n", p);
 		p += len+1;
+	}
+}
-void dt_to_asm(FILE *f, struct boot_info *bi, int version)
+void dt_to_asm(FILE *f, struct dt_info *dti, int version)
+{
 	struct version_info *vi = NULL;
 	int i;
 	struct data strbuf = empty_data;
 	struct reserve_info *re;
 	const char *symprefix = "dt";
 	for (i = 0; i < ARRAY_SIZE(version_table); i++) {
 		if (version_table[i].version == version)
 			vi = &version_table[i];
+	}
 	if (!vi)
 		die("Unknown device tree blob version %d\n", version);
 @@ -490,27 +490,27 @@ void dt_to_asm(FILE *f, struct boot_info
 	fprintf(f, "\t/* off_dt_strings */\n");
 	ASM_EMIT_BELONG(f, "_%s_strings_start - _%s_blob_start",
 		symprefix, symprefix);
 	fprintf(f, "\t/* off_mem_rsvmap */\n");
 	ASM_EMIT_BELONG(f, "_%s_reserve_map - _%s_blob_start",
 		symprefix, symprefix);
 	fprintf(f, "\t/* version */\n");
 	asm_emit_cell(f, vi->version);
 	fprintf(f, "\t/* last_comp_version */\n");
 	asm_emit_cell(f, vi->last_comp_version);
 	if (vi->flags & FTF_BOOTCPUID) {
 		fprintf(f, "\t/* boot_cpuid_phys */\n");
-		asm_emit_cell(f, bi->boot_cpuid_phys);
+		asm_emit_cell(f, dti->boot_cpuid_phys);
+	}
 	if (vi->flags & FTF_STRTABSIZE) {
 		fprintf(f, "\t/* size_dt_strings */\n");
 		ASM_EMIT_BELONG(f, "_%s_strings_end - _%s_strings_start",
 				symprefix, symprefix);
+	}
 	if (vi->flags & FTF_STRUCTSIZE) {
 		fprintf(f, "\t/* size_dt_struct */\n");
 		ASM_EMIT_BELONG(f, "_%s_struct_end - _%s_struct_start",
 			symprefix, symprefix);
+	}
 @@ -520,68 +520,70 @@ void dt_to_asm(FILE *f, struct boot_info
 	 * Align the reserve map to a doubleword boundary.
 	 * Each entry is an (address, size) pair of u64 values.
 	 * Always supply a zero-sized temination entry.
 	 */
 	asm_emit_align(f, 8);
 	emit_label(f, symprefix, "reserve_map");
 	fprintf(f, "/* Memory reserve map from source file */\n");
 	/*
 	 * Use .long on high and low halfs of u64s to avoid .quad
 	 * as it appears .quad isn't available in some assemblers.
 	 */
-	for (re = bi->reservelist; re; re = re->next) {
+	for (re = dti->reservelist; re; re = re->next) {
 		struct label *l;
 		for_each_label(re->labels, l) {
 			fprintf(f, "\t.globl\t%s\n", l->label);
 			fprintf(f, "%s:\n", l->label);
+		}
-		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->re.address >> 32));
+		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->address >> 32));
 		ASM_EMIT_BELONG(f, "0x%08x",
-				(unsigned int)(re->re.address & 0xffffffff));
+				(unsigned int)(re->address & 0xffffffff));
-		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->re.size >> 32));
+		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->size >> 32));
-		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->re.size & 0xffffffff));
+		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->size & 0xffffffff));
+	}
 	for (i = 0; i < reservenum; i++) {
 		fprintf(f, "\t.long\t0, 0\n\t.long\t0, 0\n");
+	}
 	fprintf(f, "\t.long\t0, 0\n\t.long\t0, 0\n");
 	emit_label(f, symprefix, "struct_start");
-	flatten_tree(bi->dt, &asm_emitter, f, &strbuf, vi);
+	flatten_tree(dti->dt, &asm_emitter, f, &strbuf, vi);
 	fprintf(f, "\t/* FDT_END */\n");
 	asm_emit_cell(f, FDT_END);
 	emit_label(f, symprefix, "struct_end");
 	emit_label(f, symprefix, "strings_start");
 	dump_stringtable_asm(f, strbuf);
 	emit_label(f, symprefix, "strings_end");
 	emit_label(f, symprefix, "blob_end");
 	/*
 	 * If the user asked for more space than is used, pad it out.
 	 */
 	if (minsize > 0) {
 		fprintf(f, "\t.space\t%d - (_%s_blob_end - _%s_blob_start), 0\n",
 			minsize, symprefix, symprefix);
+	}
 	if (padsize > 0) {
 		fprintf(f, "\t.space\t%d, 0\n", padsize);
+	}
 	if (alignsize > 0)
 		asm_emit_align(f, alignsize);
 	emit_label(f, symprefix, "blob_abs_end");
 	data_free(strbuf);
+}
 struct inbuf {
 	char *base, *limit, *ptr;
 };
 static void inbuf_init(struct inbuf *inb, void *base, void *limit)
+{
 	inb->base = base;
 	inb->limit = limit;
 @@ -590,27 +592,27 @@ static void inbuf_init(struct inbuf *inb
 static void flat_read_chunk(struct inbuf *inb, void *p, int len)
+{
 	if ((inb->ptr + len) > inb->limit)
 		die("Premature end of data parsing flat device tree\n");
 	memcpy(p, inb->ptr, len);
 	inb->ptr += len;
+}
 static uint32_t flat_read_word(struct inbuf *inb)
+{
-	uint32_t val;
+	fdt32_t val;
 	assert(((inb->ptr - inb->base) % sizeof(val)) == 0);
 	flat_read_chunk(inb, &val, sizeof(val));
 	return fdt32_to_cpu(val);
+}
 static void flat_realign(struct inbuf *inb, int align)
+{
 	int off = inb->ptr - inb->base;
 	inb->ptr = inb->base + FDTALIGN2(off, align);
 @@ -699,33 +701,35 @@ static struct property *flat_read_proper
 static struct reserve_info *flat_read_mem_reserve(struct inbuf *inb)
+{
 	struct reserve_info *reservelist = NULL;
 	struct reserve_info *new;
 	struct fdt_reserve_entry re;
 	/*
 	 * Each entry is a pair of u64 (addr, size) values for 4 cell_t's.
 	 * List terminates at an entry with size equal to zero.
+	 *
 	 * First pass, count entries.
 	 */
 	while (1) {
 		uint64_t address, size;
 		flat_read_chunk(inb, &re, sizeof(re));
-		re.address  = fdt64_to_cpu(re.address);
+		address  = fdt64_to_cpu(re.address);
-		re.size = fdt64_to_cpu(re.size);
+		size = fdt64_to_cpu(re.size);
-		if (re.size == 0)
+		if (size == 0)
 			break;
-		new = build_reserve_entry(re.address, re.size);
+		new = build_reserve_entry(address, size);
 		reservelist = add_reserve_entry(reservelist, new);
+	}
 	return reservelist;
+}
 static char *nodename_from_path(const char *ppath, const char *cpath)
+{
 	int plen;
 	plen = strlen(ppath);
 @@ -787,75 +791,80 @@ static struct node *unflatten_tree(struc
 			if (!(flags & FTF_NOPS))
 				fprintf(stderr, "Warning: NOP tag found in flat tree"
 					" version <16\n");
 			/* Ignore */
 			break;
 		default:
 			die("Invalid opcode word %08x in device tree blob\n",
 			    val);
+		}
 	} while (val != FDT_END_NODE);
 	if (node->name != flatname) {
 		free(flatname);
+	}
 	return node;
+}
-struct boot_info *dt_from_blob(const char *fname)
+struct dt_info *dt_from_blob(const char *fname)
+{
 	FILE *f;
 	fdt32_t magic_buf, totalsize_buf;
 	uint32_t magic, totalsize, version, size_dt, boot_cpuid_phys;
 	uint32_t off_dt, off_str, off_mem_rsvmap;
 	int rc;
 	char *blob;
 	struct fdt_header *fdt;
 	char *p;
 	struct inbuf dtbuf, strbuf;
 	struct inbuf memresvbuf;
 	int sizeleft;
 	struct reserve_info *reservelist;
 	struct node *tree;
 	uint32_t val;
 	int flags = 0;
 	f = srcfile_relative_open(fname, NULL);
-	rc = fread(&magic, sizeof(magic), 1, f);
+	rc = fread(&magic_buf, sizeof(magic_buf), 1, f);
 	if (ferror(f))
 		die("Error reading DT blob magic number: %s\n",
 		    strerror(errno));
 	if (rc < 1) {
 		if (feof(f))
 			die("EOF reading DT blob magic number\n");
 		else
 			die("Mysterious short read reading magic number\n");
+	}
-	magic = fdt32_to_cpu(magic);
+	magic = fdt32_to_cpu(magic_buf);
 	if (magic != FDT_MAGIC)
 		die("Blob has incorrect magic number\n");
-	rc = fread(&totalsize, sizeof(totalsize), 1, f);
+	rc = fread(&totalsize_buf, sizeof(totalsize_buf), 1, f);
 	if (ferror(f))
 		die("Error reading DT blob size: %s\n", strerror(errno));
 	if (rc < 1) {
 		if (feof(f))
 			die("EOF reading DT blob size\n");
 		else
 			die("Mysterious short read reading blob size\n");
+	}
-	totalsize = fdt32_to_cpu(totalsize);
+	totalsize = fdt32_to_cpu(totalsize_buf);
 	if (totalsize < FDT_V1_SIZE)
 		die("DT blob size (%d) is too small\n", totalsize);
 	blob = xmalloc(totalsize);
 	fdt = (struct fdt_header *)blob;
 	fdt->magic = cpu_to_fdt32(magic);
 	fdt->totalsize = cpu_to_fdt32(totalsize);
 	sizeleft = totalsize - sizeof(magic) - sizeof(totalsize);
 	p = blob + sizeof(magic)  + sizeof(totalsize);
 	while (sizeleft) {
 @@ -879,36 +888,36 @@ struct boot_info *dt_from_blob(const cha
 	boot_cpuid_phys = fdt32_to_cpu(fdt->boot_cpuid_phys);
 	if (off_mem_rsvmap >= totalsize)
 		die("Mem Reserve structure offset exceeds total size\n");
 	if (off_dt >= totalsize)
 		die("DT structure offset exceeds total size\n");
 	if (off_str > totalsize)
 		die("String table offset exceeds total size\n");
 	if (version >= 3) {
 		uint32_t size_str = fdt32_to_cpu(fdt->size_dt_strings);
-		if (off_str+size_str > totalsize)
+		if ((off_str+size_str < off_str) || (off_str+size_str > totalsize))
 			die("String table extends past total size\n");
 		inbuf_init(&strbuf, blob + off_str, blob + off_str + size_str);
 	} else {
 		inbuf_init(&strbuf, blob + off_str, blob + totalsize);
+	}
 	if (version >= 17) {
 		size_dt = fdt32_to_cpu(fdt->size_dt_struct);
-		if (off_dt+size_dt > totalsize)
+		if ((off_dt+size_dt < off_dt) || (off_dt+size_dt > totalsize))
 			die("Structure block extends past total size\n");
+	}
 	if (version < 16) {
 		flags |= FTF_FULLPATH | FTF_NAMEPROPS | FTF_VARALIGN;
 	} else {
 		flags |= FTF_NOPS;
+	}
 	inbuf_init(&memresvbuf,
 		   blob + off_mem_rsvmap, blob + totalsize);
 	inbuf_init(&dtbuf, blob + off_dt, blob + totalsize);
 @@ -919,15 +928,15 @@ struct boot_info *dt_from_blob(const cha
 	if (val != FDT_BEGIN_NODE)
 		die("Device tree blob doesn't begin with FDT_BEGIN_NODE (begins with 0x%08x)\n", val);
 	tree = unflatten_tree(&dtbuf, &strbuf, "", flags);
 	val = flat_read_word(&dtbuf);
 	if (val != FDT_END)
 		die("Device tree blob doesn't end with FDT_END\n");
 	free(blob);
 	fclose(f);
-	return build_boot_info(reservelist, tree, boot_cpuid_phys);
+	return build_dt_info(DTSF_V1, reservelist, tree, boot_cpuid_phys);
+}

 @@ -1,13 +1,15 @@
 /*	$NetBSD: srcpos.c,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * Copyright 2007 Jon Loeliger, Freescale Semiconductor, Inc.
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  General Public License for more details.
+ *
 @@ -236,66 +238,47 @@ void srcpos_update(struct srcpos *pos, c
+}
 struct srcpos *
 srcpos_copy(struct srcpos *pos)
+{
 	struct srcpos *pos_new;
 	pos_new = xmalloc(sizeof(struct srcpos));
 	memcpy(pos_new, pos, sizeof(struct srcpos));
 	return pos_new;
+}
 void
 srcpos_dump(struct srcpos *pos)
 	printf("file        : \"%s\"\n",
 	       pos->file ? (char *) pos->file : "<no file>");
 	printf("first_line  : %d\n", pos->first_line);
 	printf("first_column: %d\n", pos->first_column);
 	printf("last_line   : %d\n", pos->last_line);
 	printf("last_column : %d\n", pos->last_column);
 	printf("file        : %s\n", pos->file->name);
 char *
 srcpos_string(struct srcpos *pos)
+{
 	const char *fname = "<no-file>";
 	char *pos_str;
 	int rc;
-	if (pos)
+	if (pos->file && pos->file->name)
 		fname = pos->file->name;
 	if (pos->first_line != pos->last_line)
-		rc = asprintf(&pos_str, "%s:%d.%d-%d.%d", fname,
+		xasprintf(&pos_str, "%s:%d.%d-%d.%d", fname,
-			      pos->first_line, pos->first_column,
+			  pos->first_line, pos->first_column,
-			      pos->last_line, pos->last_column);
+			  pos->last_line, pos->last_column);
 	else if (pos->first_column != pos->last_column)
-		rc = asprintf(&pos_str, "%s:%d.%d-%d", fname,
+		xasprintf(&pos_str, "%s:%d.%d-%d", fname,
-			      pos->first_line, pos->first_column,
+			  pos->first_line, pos->first_column,
-			      pos->last_column);
+			  pos->last_column);
 	else
-		rc = asprintf(&pos_str, "%s:%d.%d", fname,
+		xasprintf(&pos_str, "%s:%d.%d", fname,
-			      pos->first_line, pos->first_column);
+			  pos->first_line, pos->first_column);
 	if (rc == -1)
 		die("Couldn't allocate in srcpos string");
 	return pos_str;
+}
 void srcpos_verror(struct srcpos *pos, const char *prefix,
 		   const char *fmt, va_list va)
+{
 	char *srcstr;
 	srcstr = srcpos_string(pos);
 	fprintf(stderr, "%s: %s ", prefix, srcstr);
 	vfprintf(stderr, fmt, va);

 @@ -1,13 +1,15 @@
 /*	$NetBSD: util.h,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 #ifndef _UTIL_H
 #define _UTIL_H
 #include <stdarg.h>
 #include <stdbool.h>
 #include <getopt.h>
 /*
  * Copyright 2011 The Chromium Authors, All Rights Reserved.
  * Copyright 2008 Jon Loeliger, Freescale Semiconductor, Inc.
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
 @@ -15,62 +17,72 @@
  * License, or (at your option) any later version.
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  *                                                                   USA
  */
 #ifdef __GNUC__
 #define PRINTF(i, j)	__attribute__((format (printf, i, j)))
 #define NORETURN	__attribute__((noreturn))
 #else
 #define PRINTF(i, j)
 #define NORETURN
 #endif
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 #define FDTALIGN2(x, a)	(((x) + (a) - 1) & ~((a) - 1))
 #define PALIGN(p, a)	((void *)(FDTALIGN2((unsigned long)(p), (a))))
-static inline void __attribute__((noreturn)) die(const char *str, ...)
+static inline void NORETURN PRINTF(1, 2) die(const char *str, ...)
+{
 	va_list ap;
 	va_start(ap, str);
 	fprintf(stderr, "FATAL ERROR: ");
 	vfprintf(stderr, str, ap);
 	va_end(ap);
 	exit(1);
+}
 static inline void *xmalloc(size_t len)
+{
 	void *new = malloc(len);
 	if (!new)
 		die("malloc() failed\n");
 	return new;
+}
 static inline void *xrealloc(void *p, size_t len)
+{
 	void *new = realloc(p, len);
 	if (!new)
-		die("realloc() failed (len=%d)\n", len);
+		die("realloc() failed (len=%zd)\n", len);
 	return new;
+}
 extern char *xstrdup(const char *s);
 extern int PRINTF(2, 3) xasprintf(char **strp, const char *fmt, ...);
 extern char *join_path(const char *path, const char *name);
 /**
  * Check a property of a given length to see if it is all printable and
  * has a valid terminator. The property can contain either a single string,
  * or multiple strings each of non-zero length.
+ *
  * @param data	The string to check
  * @param len	The string length including terminator
  * @return 1 if a valid printable string, 0 if not
  */
 bool util_is_printable_string(const void *data, int len);
 @@ -179,43 +191,44 @@ int utilfdt_decode_type(const char *fmt,
  * the data will be displayed either as cells (if len is a multiple of 4
  * bytes) or bytes.
+ *
  * If len is 0 then this function does nothing.
+ *
  * @param data	Pointers to property data
  * @param len	Length of property data
  */
 void utilfdt_print_data(const char *data, int len);
 /**
  * Show source version and exit
  */
-void util_version(void) __attribute__((noreturn));
+void NORETURN util_version(void);
 /**
  * Show usage and exit
+ *
  * This helps standardize the output of various utils.  You most likely want
  * to use the usage() helper below rather than call this.
+ *
  * @param errmsg	If non-NULL, an error message to display
  * @param synopsis	The initial example usage text (and possible examples)
  * @param short_opts	The string of short options
  * @param long_opts	The structure of long options
  * @param opts_help	An array of help strings (should align with long_opts)
  */
-void util_usage(const char *errmsg, const char *synopsis,
+void NORETURN util_usage(const char *errmsg, const char *synopsis,
-		const char *short_opts, struct option const long_opts[],
+			 const char *short_opts,
-		const char * const opts_help[]) __attribute__((noreturn));
+			 struct option const long_opts[],
 			 const char * const opts_help[]);
 /**
  * Show usage and exit
+ *
  * If you name all your usage variables with usage_xxx, then you can call this
  * help macro rather than expanding all arguments yourself.
+ *
  * @param errmsg	If non-NULL, an error message to display
  */
 #define usage(errmsg) \
 	util_usage(errmsg, usage_synopsis, usage_short_opts, \
 		   usage_long_opts, usage_opts_help)

 @@ -1,13 +1,15 @@
 /*	$NetBSD: mangle-layout.c,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * libfdt - Flat Device Tree manipulation
  *	Testcase/tool for rearranging blocks of a dtb
  * Copyright (C) 2006 David Gibson, IBM Corporation.
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
+ *
  * This library is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 @@ -1,13 +1,15 @@
 /*	$NetBSD: move_and_save.c,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 /*
  * libfdt - Flat Device Tree manipulation
  *	Basic testcase for read-only access
  * Copyright (C) 2006 David Gibson, IBM Corporation.
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
+ *
  * This library is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 @@ -1,13 +1,15 @@
 /*	$NetBSD: tests.h,v 1.3 2017/06/08 16:00:40 skrll Exp $	*/
 #ifndef _TESTS_H
 #define _TESTS_H
 /*
  * libfdt - Flat Device Tree manipulation
  *	Testcase definitions
  * Copyright (C) 2006 David Gibson, IBM Corporation.
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
+ *
  * This library is distributed in the hope that it will be useful, but
 @@ -89,41 +91,41 @@ void cleanup(void);
 #define TEST_BUG(fmt, ...)				\
 	do {						\
 		cleanup();				\
 		printf("BUG in testsuite: " fmt "\n", ##__VA_ARGS__);	\
 		exit(RC_BUG);				\
 	} while (0)
 void check_mem_rsv(void *fdt, int n, uint64_t addr, uint64_t size);
 void check_property(void *fdt, int nodeoffset, const char *name,
 		    int len, const void *val);
 #define check_property_cell(fdt, nodeoffset, name, val) \
 	({ \
-		uint32_t x = cpu_to_fdt32(val);			      \
+		fdt32_t x = cpu_to_fdt32(val);			      \
 		check_property(fdt, nodeoffset, name, sizeof(x), &x); \
 	})
 const void *check_getprop(void *fdt, int nodeoffset, const char *name,
 			  int len, const void *val);
 #define check_getprop_cell(fdt, nodeoffset, name, val) \
 	({ \
-		uint32_t x = cpu_to_fdt32(val);			     \
+		fdt32_t x = cpu_to_fdt32(val);			     \
 		check_getprop(fdt, nodeoffset, name, sizeof(x), &x); \
 	})
 #define check_getprop_64(fdt, nodeoffset, name, val) \
 	({ \
-		uint64_t x = cpu_to_fdt64(val);			     \
+		fdt64_t x = cpu_to_fdt64(val);			     \
 		check_getprop(fdt, nodeoffset, name, sizeof(x), &x); \
 	})
 #define check_getprop_string(fdt, nodeoffset, name, s) \
 	check_getprop((fdt), (nodeoffset), (name), strlen(s)+1, (s))
 int nodename_eq(const char *s1, const char *s2);
 void *load_blob(const char *filename);
 void *load_blob_arg(int argc, char *argv[]);
 void save_blob(const char *filename, void *blob);
 void *open_blob_rw(void *blob);
 #include "util.h"
 #endif /* _TESTS_H */