[PATCH 0/6] Restore phandles from binary representations

[PATCH 0/6] Restore phandles from binary representations

[Uwe Kleine-König]

Hello,

this is a followup to https://github.com/dgibson/dtc/pull/151, but I
switched to submission by mail because the workflow is (at least
subjectively for me) better suited for such a big and long living patch
set. Parts of the patches discussed on github were already applied.

Sample output to show the benefit:

	$ cat a.dts
	/dts-v1/;

	/ {
		node1 {
			node2 = <&node2>;
		};

		node2: node2 {
			property = "somevalue";
		};
	};

	$ cat b.dts
	/dts-v1/;

	/ {
		node0: node0 {
			self = <&node0>;
		};

		node1 {
			node2 = <&node2>;
		};

		node2: node2 {
			property = "somevalue";
		};
	};


So b.dts just added a node0 over a.dts, node1 and node2 didn't change at
all.

	$ dtc -L -@ a.dts > a.dtb
	$ dtc -L -@ b.dts > b.dtb

Now using dtc without this patch set I get:

	$ dtdiff a.dtb b.dtb
	--- /dev/fd/63	2025-08-20 14:55:37.253413183 +0200
	+++ /dev/fd/62	2025-08-20 14:55:37.253413183 +0200
	@@ -4,21 +4,31 @@
	 
		__local_fixups__ {
	 
	+		node0 {
	+			self = <0x00>;
	+		};
	+
			node1 {
				node2 = <0x00>;
			};
		};
	 
		__symbols__ {
	+		node0 = "/node0";
			node2 = "/node2";
		};
	 
	+	node0 {
	+		phandle = <0x01>;
	+		self = <0x01>;
	+	};
	+
		node1 {
	-		node2 = <0x01>;
	+		node2 = <0x02>;
		};
	 
		node2 {
	-		phandle = <0x01>;
	+		phandle = <0x02>;
			property = "somevalue";
		};
	 };

With this series applied the output becomes:

	$ dtdiff a.dtb b.dtb
	--- /dev/fd/63	2025-08-20 14:56:02.585884273 +0200
	+++ /dev/fd/62	2025-08-20 14:56:02.589884347 +0200
	@@ -5,21 +5,31 @@
	 
		__local_fixups__ {
	 
	+		node0 {
	+			self = <0x00>;
	+		};
	+
			node1 {
				node2 = <0x00>;
			};
		};
	 
		__symbols__ {
	+		node0 = "/node0";
			node2 = "/node2";
		};
	 
	+	node0: node0 {
	+		phandle = <0x01>;
	+		self = <&node0>;
	+	};
	+
		node1 {
			node2 = <&node2>;
		};
	 
		node2: node2 {
	-		phandle = <0x01>;
	+		phandle = <0x02>;
			property = "somevalue";
		};
	 };

The relevant difference here is that the renumbering of phandles that
affects /node2 doesn't result in noise in /node1, so it's easily visible
that /node1/node2 still points to the same node that just got a new
phandle value.

In this minimal example the signal to noise ratio is bad, with bigger
device trees the improvement is much more relevant. (Think 50 nodes that
are not affected by renumbering and the noise being concentrated to
__local_fixups__, __fixups__ and the changes of the actual phandle
properties but not their usage.)

Best regards
Uwe

Uwe Kleine-König (6):
  Emit /plugin/ when compiling to .dts with DTSF_PLUGIN set
  Set DTSF_PLUGIN if needed when compiling from dtb
  Improve type guessing when compiling to dts format
  Restore labels from __symbols__ node
  Restore phandle references from __local_fixups__ node
  Restore phandle references from __fixups__ node

 dtc.c        |   5 ++
 dtc.h        |   6 ++
 flattree.c   |   6 +-
 livetree.c   | 174 +++++++++++++++++++++++++++++++++++++++++++++++++++
 treesource.c | 114 ++++++++++++++++++++++++---------
 5 files changed, 273 insertions(+), 32 deletions(-)


base-commit: e1284ee5dc20f94097bc6424ede9c3e433dba77d
-- 
2.50.1

[PATCH 1/6] Emit /plugin/ when compiling to .dts with DTSF_PLUGIN set

[Uwe Kleine-König]

This fixes `dtc -I dts -O dts` to make the file a plugin if the source
file is one.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
---
 treesource.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/treesource.c b/treesource.c
index d25f01fc6937..72d1cb5508b5 100644
--- a/treesource.c
+++ b/treesource.c
@@ -369,7 +369,10 @@ void dt_to_source(FILE *f, struct dt_info *dti)
 {
 	struct reserve_info *re;
 
-	fprintf(f, "/dts-v1/;\n\n");
+	fprintf(f, "/dts-v1/;\n");
+	if (dti->dtsflags & DTSF_PLUGIN)
+		fprintf(f, "/plugin/;\n");
+	fprintf(f, "\n");
 
 	for (re = dti->reservelist; re; re = re->next) {
 		struct label *l;
-- 
2.50.1

Re: [PATCH 1/6] Emit /plugin/ when compiling to .dts with DTSF_PLUGIN set

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 1061 bytes --]

On Wed, Aug 20, 2025 at 03:11:27PM +0200, Uwe Kleine-König wrote:
> This fixes `dtc -I dts -O dts` to make the file a plugin if the source
> file is one.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>

Reviewed-by: David Gibson <david@gibson.dropbear.id.au>

> ---
>  treesource.c | 5 ++++-
>  1 file changed, 4 insertions(+), 1 deletion(-)
> 
> diff --git a/treesource.c b/treesource.c
> index d25f01fc6937..72d1cb5508b5 100644
> --- a/treesource.c
> +++ b/treesource.c
> @@ -369,7 +369,10 @@ void dt_to_source(FILE *f, struct dt_info *dti)
>  {
>  	struct reserve_info *re;
>  
> -	fprintf(f, "/dts-v1/;\n\n");
> +	fprintf(f, "/dts-v1/;\n");
> +	if (dti->dtsflags & DTSF_PLUGIN)
> +		fprintf(f, "/plugin/;\n");
> +	fprintf(f, "\n");
>  
>  	for (re = dti->reservelist; re; re = re->next) {
>  		struct label *l;

-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

[PATCH 2/6] Set DTSF_PLUGIN if needed when compiling from dtb

[Uwe Kleine-König]

The need for the plugin flag is determined by the existence of __fixups__
or __local_fixups__.

This is a bit simplifying because if __fixups__ or __local_fixups__
exist but don't have properties, the plugin flag isn't needed. But in
practise the test should be good enough such that this corner case
doesn't matter.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
---
 flattree.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/flattree.c b/flattree.c
index 30e6de2044b2..f3b698c17e89 100644
--- a/flattree.c
+++ b/flattree.c
@@ -807,6 +807,7 @@ struct dt_info *dt_from_blob(const char *fname)
 	struct node *tree;
 	uint32_t val;
 	int flags = 0;
+	unsigned int dtsflags = DTSF_V1;
 
 	f = srcfile_relative_open(fname, NULL);
 
@@ -919,5 +920,8 @@ struct dt_info *dt_from_blob(const char *fname)
 
 	fclose(f);
 
-	return build_dt_info(DTSF_V1, reservelist, tree, boot_cpuid_phys);
+	if (get_subnode(tree, "__fixups__") || get_subnode(tree, "__local_fixups__"))
+		dtsflags |= DTSF_PLUGIN;
+
+	return build_dt_info(dtsflags, reservelist, tree, boot_cpuid_phys);
 }
-- 
2.50.1

Re: [PATCH 2/6] Set DTSF_PLUGIN if needed when compiling from dtb

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 1541 bytes --]

On Wed, Aug 20, 2025 at 03:11:28PM +0200, Uwe Kleine-König wrote:
> The need for the plugin flag is determined by the existence of __fixups__
> or __local_fixups__.
> 
> This is a bit simplifying because if __fixups__ or __local_fixups__
> exist but don't have properties, the plugin flag isn't needed. But in
> practise the test should be good enough such that this corner case
> doesn't matter.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>

Reviewed-by: David Gibson <david@gibson.dropbear.id.au>


> ---
>  flattree.c | 6 +++++-
>  1 file changed, 5 insertions(+), 1 deletion(-)
> 
> diff --git a/flattree.c b/flattree.c
> index 30e6de2044b2..f3b698c17e89 100644
> --- a/flattree.c
> +++ b/flattree.c
> @@ -807,6 +807,7 @@ struct dt_info *dt_from_blob(const char *fname)
>  	struct node *tree;
>  	uint32_t val;
>  	int flags = 0;
> +	unsigned int dtsflags = DTSF_V1;
>  
>  	f = srcfile_relative_open(fname, NULL);
>  
> @@ -919,5 +920,8 @@ struct dt_info *dt_from_blob(const char *fname)
>  
>  	fclose(f);
>  
> -	return build_dt_info(DTSF_V1, reservelist, tree, boot_cpuid_phys);
> +	if (get_subnode(tree, "__fixups__") || get_subnode(tree, "__local_fixups__"))
> +		dtsflags |= DTSF_PLUGIN;
> +
> +	return build_dt_info(dtsflags, reservelist, tree, boot_cpuid_phys);
>  }

-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

[PATCH 3/6] Improve type guessing when compiling to dts format

[Uwe Kleine-König]

In the presence of (non-type) markers guess the type of each chunk
between markers individually instead of only once for the whole
property.

Note that this only gets relevant with the next few commits that restore
labels and phandles. Note further that this rework is necessary with
these further changes, because phandle markers are currently not
considered for type guessing and so a phandle at an offset that isn't a
multiple of 4 triggers an assertion if the property was guessed to have
type TYPE_UINT32.

Now that guess_value_type() is only called for data chunks without
markers, the function can be simplified a bit.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
---
 treesource.c | 70 ++++++++++++++++++++++++++++++----------------------
 1 file changed, 40 insertions(+), 30 deletions(-)

diff --git a/treesource.c b/treesource.c
index 72d1cb5508b5..576495902f0d 100644
--- a/treesource.c
+++ b/treesource.c
@@ -173,23 +173,20 @@ static struct marker **add_marker(struct marker **mi,
 	return &nm->next;
 }
 
-static void add_string_markers(struct property *prop)
+static void add_string_markers(struct property *prop, unsigned int offset, int len)
 {
-	int l, len = prop->val.len;
-	const char *p = prop->val.val;
+	int l;
+	const char *p = prop->val.val + offset;
 	struct marker **mi = &prop->val.markers;
 
 	for (l = strlen(p) + 1; l < len; l += strlen(p + l) + 1)
-		mi = add_marker(mi, TYPE_STRING, l, NULL);
+		mi = add_marker(mi, TYPE_STRING, offset + l, NULL);
 }
 
-static enum markertype guess_value_type(struct property *prop)
+static enum markertype guess_value_type(struct property *prop, unsigned int offset, int len)
 {
-	int len = prop->val.len;
-	const char *p = prop->val.val;
-	struct marker *m = prop->val.markers;
+	const char *p = prop->val.val + offset;
 	int nnotstring = 0, nnul = 0;
-	int nnotstringlbl = 0, nnotcelllbl = 0;
 	int i;
 
 	for (i = 0; i < len; i++) {
@@ -199,30 +196,49 @@ static enum markertype guess_value_type(struct property *prop)
 			nnul++;
 	}
 
-	for_each_marker_of_type(m, LABEL) {
-		if ((m->offset > 0) && (prop->val.val[m->offset - 1] != '\0'))
-			nnotstringlbl++;
-		if ((m->offset % sizeof(cell_t)) != 0)
-			nnotcelllbl++;
-	}
-
-	if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul <= (len-nnul))
-	    && (nnotstringlbl == 0)) {
+	if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul <= len - nnul)) {
 		if (nnul > 1)
-			add_string_markers(prop);
+			add_string_markers(prop, offset, len);
 		return TYPE_STRING;
-	} else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) {
+	} else if ((len % sizeof(cell_t)) == 0) {
 		return TYPE_UINT32;
 	}
 
 	return TYPE_UINT8;
 }
 
+static void guess_type_markers(struct property *prop)
+{
+	struct marker **m = &prop->val.markers;
+	unsigned int offset = 0;
+
+	for (m = &prop->val.markers; *m; m = &((*m)->next)) {
+		if (is_type_marker((*m)->type))
+			/* assume the whole property is already marked */
+			return;
+
+		if ((*m)->offset > offset) {
+			m = add_marker(m, guess_value_type(prop, offset, (*m)->offset - offset),
+				       offset, NULL);
+
+			offset = (*m)->offset;
+		}
+
+		if ((*m)->type == REF_PHANDLE) {
+			m = add_marker(m, TYPE_UINT32, offset, NULL);
+			offset += 4;
+		}
+	}
+
+	if (offset < prop->val.len)
+		add_marker(m, guess_value_type(prop, offset, prop->val.len - offset),
+			   offset, NULL);
+}
+
 static void write_propval(FILE *f, struct property *prop)
 {
 	size_t len = prop->val.len;
-	struct marker *m = prop->val.markers;
-	struct marker dummy_marker;
+	struct marker *m;
 	enum markertype emit_type = TYPE_NONE;
 	char *srcstr;
 
@@ -241,14 +257,8 @@ static void write_propval(FILE *f, struct property *prop)
 
 	fprintf(f, " =");
 
-	if (!next_type_marker(m)) {
-		/* data type information missing, need to guess */
-		dummy_marker.type = guess_value_type(prop);
-		dummy_marker.next = prop->val.markers;
-		dummy_marker.offset = 0;
-		dummy_marker.ref = NULL;
-		m = &dummy_marker;
-	}
+	guess_type_markers(prop);
+	m = prop->val.markers;
 
 	for_each_marker(m) {
 		size_t chunk_len = (m->next ? m->next->offset : len) - m->offset;
-- 
2.50.1

Re: [PATCH 3/6] Improve type guessing when compiling to dts format

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 4849 bytes --]

On Wed, Aug 20, 2025 at 03:11:29PM +0200, Uwe Kleine-König wrote:
> In the presence of (non-type) markers guess the type of each chunk
> between markers individually instead of only once for the whole
> property.
> 
> Note that this only gets relevant with the next few commits that restore
> labels and phandles. Note further that this rework is necessary with
> these further changes, because phandle markers are currently not
> considered for type guessing and so a phandle at an offset that isn't a
> multiple of 4 triggers an assertion if the property was guessed to have
> type TYPE_UINT32.
> 
> Now that guess_value_type() is only called for data chunks without
> markers, the function can be simplified a bit.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>

Reviewed-by: David Gibson <david@gibson.dropbear.id.au>

> ---
>  treesource.c | 70 ++++++++++++++++++++++++++++++----------------------
>  1 file changed, 40 insertions(+), 30 deletions(-)
> 
> diff --git a/treesource.c b/treesource.c
> index 72d1cb5508b5..576495902f0d 100644
> --- a/treesource.c
> +++ b/treesource.c
> @@ -173,23 +173,20 @@ static struct marker **add_marker(struct marker **mi,
>  	return &nm->next;
>  }
>  
> -static void add_string_markers(struct property *prop)
> +static void add_string_markers(struct property *prop, unsigned int offset, int len)
>  {
> -	int l, len = prop->val.len;
> -	const char *p = prop->val.val;
> +	int l;
> +	const char *p = prop->val.val + offset;
>  	struct marker **mi = &prop->val.markers;
>  
>  	for (l = strlen(p) + 1; l < len; l += strlen(p + l) + 1)
> -		mi = add_marker(mi, TYPE_STRING, l, NULL);
> +		mi = add_marker(mi, TYPE_STRING, offset + l, NULL);
>  }
>  
> -static enum markertype guess_value_type(struct property *prop)
> +static enum markertype guess_value_type(struct property *prop, unsigned int offset, int len)
>  {
> -	int len = prop->val.len;
> -	const char *p = prop->val.val;
> -	struct marker *m = prop->val.markers;
> +	const char *p = prop->val.val + offset;
>  	int nnotstring = 0, nnul = 0;
> -	int nnotstringlbl = 0, nnotcelllbl = 0;
>  	int i;
>  
>  	for (i = 0; i < len; i++) {
> @@ -199,30 +196,49 @@ static enum markertype guess_value_type(struct property *prop)
>  			nnul++;
>  	}
>  
> -	for_each_marker_of_type(m, LABEL) {
> -		if ((m->offset > 0) && (prop->val.val[m->offset - 1] != '\0'))
> -			nnotstringlbl++;
> -		if ((m->offset % sizeof(cell_t)) != 0)
> -			nnotcelllbl++;
> -	}
> -
> -	if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul <= (len-nnul))
> -	    && (nnotstringlbl == 0)) {
> +	if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul <= len - nnul)) {
>  		if (nnul > 1)
> -			add_string_markers(prop);
> +			add_string_markers(prop, offset, len);
>  		return TYPE_STRING;
> -	} else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) {
> +	} else if ((len % sizeof(cell_t)) == 0) {
>  		return TYPE_UINT32;
>  	}
>  
>  	return TYPE_UINT8;
>  }
>  
> +static void guess_type_markers(struct property *prop)
> +{
> +	struct marker **m = &prop->val.markers;
> +	unsigned int offset = 0;
> +
> +	for (m = &prop->val.markers; *m; m = &((*m)->next)) {
> +		if (is_type_marker((*m)->type))
> +			/* assume the whole property is already marked */
> +			return;
> +
> +		if ((*m)->offset > offset) {
> +			m = add_marker(m, guess_value_type(prop, offset, (*m)->offset - offset),
> +				       offset, NULL);
> +
> +			offset = (*m)->offset;
> +		}
> +
> +		if ((*m)->type == REF_PHANDLE) {
> +			m = add_marker(m, TYPE_UINT32, offset, NULL);
> +			offset += 4;
> +		}
> +	}
> +
> +	if (offset < prop->val.len)
> +		add_marker(m, guess_value_type(prop, offset, prop->val.len - offset),
> +			   offset, NULL);
> +}
> +
>  static void write_propval(FILE *f, struct property *prop)
>  {
>  	size_t len = prop->val.len;
> -	struct marker *m = prop->val.markers;
> -	struct marker dummy_marker;
> +	struct marker *m;
>  	enum markertype emit_type = TYPE_NONE;
>  	char *srcstr;
>  
> @@ -241,14 +257,8 @@ static void write_propval(FILE *f, struct property *prop)
>  
>  	fprintf(f, " =");
>  
> -	if (!next_type_marker(m)) {
> -		/* data type information missing, need to guess */
> -		dummy_marker.type = guess_value_type(prop);
> -		dummy_marker.next = prop->val.markers;
> -		dummy_marker.offset = 0;
> -		dummy_marker.ref = NULL;
> -		m = &dummy_marker;
> -	}
> +	guess_type_markers(prop);
> +	m = prop->val.markers;
>  
>  	for_each_marker(m) {
>  		size_t chunk_len = (m->next ? m->next->offset : len) - m->offset;

-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

[PATCH 4/6] Restore labels from __symbols__ node

[Uwe Kleine-König]

If the input has a __symbols__ node, restore the named labels for the
respective nodes.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
---
 dtc.c      |  2 ++
 dtc.h      |  1 +
 livetree.c | 21 +++++++++++++++++++++
 3 files changed, 24 insertions(+)

diff --git a/dtc.c b/dtc.c
index b3445b7d6473..63a6c85da5cf 100644
--- a/dtc.c
+++ b/dtc.c
@@ -338,6 +338,8 @@ int main(int argc, char *argv[])
 	if (auto_label_aliases)
 		generate_label_tree(dti, "aliases", false);
 
+	generate_labels_from_tree(dti, "__symbols__");
+
 	if (generate_symbols)
 		generate_label_tree(dti, "__symbols__", true);
 
diff --git a/dtc.h b/dtc.h
index 3a220b9afc99..f97f3c29e2d4 100644
--- a/dtc.h
+++ b/dtc.h
@@ -339,6 +339,7 @@ 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_labels_from_tree(struct dt_info *dti, const char *name);
 void generate_label_tree(struct dt_info *dti, const char *name, bool allocph);
 void generate_fixups_tree(struct dt_info *dti, const char *name);
 void generate_local_fixups_tree(struct dt_info *dti, const char *name);
diff --git a/livetree.c b/livetree.c
index f328824c3bc6..8aafc9aa5cd6 100644
--- a/livetree.c
+++ b/livetree.c
@@ -1112,6 +1112,27 @@ static int generate_local_fixups_tree_internal(struct dt_info *dti,
 	return ret;
 }
 
+void generate_labels_from_tree(struct dt_info *dti, const char *name)
+{
+	struct node *an;
+	struct property *p;
+
+	an = get_subnode(dti->dt, name);
+	if (!an)
+		return;
+
+	for_each_property(an, p) {
+		struct node *labeled_node;
+
+		labeled_node = get_node_by_path(dti->dt, p->val.val);
+		if (labeled_node)
+			add_label(&labeled_node->labels, p->name);
+		else if (quiet < 1)
+			fprintf(stderr, "Warning: Path %s referenced in property %s/%s missing",
+				p->val.val, name, p->name);
+	}
+}
+
 void generate_label_tree(struct dt_info *dti, const char *name, bool allocph)
 {
 	if (!any_label_tree(dti, dti->dt))
-- 
2.50.1

Re: [PATCH 4/6] Restore labels from __symbols__ node

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 2581 bytes --]

On Wed, Aug 20, 2025 at 03:11:30PM +0200, Uwe Kleine-König wrote:
> If the input has a __symbols__ node, restore the named labels for the
> respective nodes.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>

Reviewed-by: David Gibson <david@gibson.dropbear.id.au>

> ---
>  dtc.c      |  2 ++
>  dtc.h      |  1 +
>  livetree.c | 21 +++++++++++++++++++++
>  3 files changed, 24 insertions(+)
> 
> diff --git a/dtc.c b/dtc.c
> index b3445b7d6473..63a6c85da5cf 100644
> --- a/dtc.c
> +++ b/dtc.c
> @@ -338,6 +338,8 @@ int main(int argc, char *argv[])
>  	if (auto_label_aliases)
>  		generate_label_tree(dti, "aliases", false);
>  
> +	generate_labels_from_tree(dti, "__symbols__");
> +
>  	if (generate_symbols)
>  		generate_label_tree(dti, "__symbols__", true);
>  
> diff --git a/dtc.h b/dtc.h
> index 3a220b9afc99..f97f3c29e2d4 100644
> --- a/dtc.h
> +++ b/dtc.h
> @@ -339,6 +339,7 @@ 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_labels_from_tree(struct dt_info *dti, const char *name);
>  void generate_label_tree(struct dt_info *dti, const char *name, bool allocph);
>  void generate_fixups_tree(struct dt_info *dti, const char *name);
>  void generate_local_fixups_tree(struct dt_info *dti, const char *name);
> diff --git a/livetree.c b/livetree.c
> index f328824c3bc6..8aafc9aa5cd6 100644
> --- a/livetree.c
> +++ b/livetree.c
> @@ -1112,6 +1112,27 @@ static int generate_local_fixups_tree_internal(struct dt_info *dti,
>  	return ret;
>  }
>  
> +void generate_labels_from_tree(struct dt_info *dti, const char *name)
> +{
> +	struct node *an;
> +	struct property *p;
> +
> +	an = get_subnode(dti->dt, name);
> +	if (!an)
> +		return;
> +
> +	for_each_property(an, p) {
> +		struct node *labeled_node;
> +
> +		labeled_node = get_node_by_path(dti->dt, p->val.val);
> +		if (labeled_node)
> +			add_label(&labeled_node->labels, p->name);
> +		else if (quiet < 1)
> +			fprintf(stderr, "Warning: Path %s referenced in property %s/%s missing",
> +				p->val.val, name, p->name);
> +	}
> +}
> +
>  void generate_label_tree(struct dt_info *dti, const char *name, bool allocph)
>  {
>  	if (!any_label_tree(dti, dti->dt))

-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

[PATCH 5/6] Restore phandle references from __local_fixups__ node

[Uwe Kleine-König]

The __local_fixups__ node contains information about phandles. Parse it
to improve the result when decompiling a device tree blob.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
---
 dtc.c        |  2 ++
 dtc.h        |  2 ++
 livetree.c   | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 treesource.c | 33 ++++++++++++++++++++++++++++++
 4 files changed, 94 insertions(+)

diff --git a/dtc.c b/dtc.c
index 63a6c85da5cf..9f90b373967d 100644
--- a/dtc.c
+++ b/dtc.c
@@ -343,6 +343,8 @@ int main(int argc, char *argv[])
 	if (generate_symbols)
 		generate_label_tree(dti, "__symbols__", true);
 
+	local_fixup_phandles(dti, "__local_fixups__");
+
 	if (generate_fixups) {
 		generate_fixups_tree(dti, "__fixups__");
 		generate_local_fixups_tree(dti, "__local_fixups__");
diff --git a/dtc.h b/dtc.h
index f97f3c29e2d4..d07a583441f6 100644
--- a/dtc.h
+++ b/dtc.h
@@ -343,6 +343,7 @@ void generate_labels_from_tree(struct dt_info *dti, const char *name);
 void generate_label_tree(struct dt_info *dti, const char *name, bool allocph);
 void generate_fixups_tree(struct dt_info *dti, const char *name);
 void generate_local_fixups_tree(struct dt_info *dti, const char *name);
+void local_fixup_phandles(struct dt_info *dti, const char *name);
 
 /* Checks */
 
@@ -358,6 +359,7 @@ struct dt_info *dt_from_blob(const char *fname);
 
 /* Tree source */
 
+void add_phandle_marker(struct dt_info *dti, struct property *prop, unsigned int offset);
 void dt_to_source(FILE *f, struct dt_info *dti);
 struct dt_info *dt_from_source(const char *f);
 
diff --git a/livetree.c b/livetree.c
index 8aafc9aa5cd6..3dbef9071017 100644
--- a/livetree.c
+++ b/livetree.c
@@ -1160,3 +1160,60 @@ void generate_local_fixups_tree(struct dt_info *dti, const char *name)
 			"Warning: Preexisting data in %s malformed, some content could not be added.\n",
 			name);
 }
+
+static void local_fixup_phandles_node(struct dt_info *dti, struct node *lf, struct node *n)
+{
+	struct property *lfp;
+	struct node *lfsubnode;
+
+	for_each_property(lf, lfp) {
+		struct property *p = get_property(n, lfp->name);
+		fdt32_t *offsets = (fdt32_t *)lfp->val.val;
+		size_t i;
+
+		if (!p) {
+			if (quiet < 1)
+				fprintf(stderr, "Warning: Property %s in %s referenced in __local_fixups__ missing\n",
+					lfp->name, n->fullpath);
+			continue;
+		}
+
+		/*
+		 * Each property in the __local_fixups__ tree is a concatenation
+		 * of offsets, so it must be a multiple of sizeof(fdt32_t).
+		 */
+		if (lfp->val.len % sizeof(fdt32_t)) {
+			if (quiet < 1)
+				fprintf(stderr, "Warning: property %s in /__local_fixups__%s malformed\n",
+					lfp->name, n->fullpath);
+			continue;
+		}
+
+		for (i = 0; i < lfp->val.len / sizeof(fdt32_t); i++)
+			add_phandle_marker(dti, p, dtb_ld32(offsets + i));
+	}
+
+	for_each_child(lf, lfsubnode) {
+		struct node *subnode = get_subnode(n, lfsubnode->name);
+
+		if (!subnode) {
+			if (quiet < 1)
+				fprintf(stderr, "Warning: node %s/%s referenced in __local_fixups__ missing\n",
+					lfsubnode->name, n->fullpath);
+			continue;
+		}
+
+		local_fixup_phandles_node(dti, lfsubnode, subnode);
+	}
+}
+
+void local_fixup_phandles(struct dt_info *dti, const char *name)
+{
+	struct node *an;
+
+	an = get_subnode(dti->dt, name);
+	if (!an)
+		return;
+
+	local_fixup_phandles_node(dti, an, dti->dt);
+}
diff --git a/treesource.c b/treesource.c
index 576495902f0d..5b8d7a679519 100644
--- a/treesource.c
+++ b/treesource.c
@@ -183,6 +183,39 @@ static void add_string_markers(struct property *prop, unsigned int offset, int l
 		mi = add_marker(mi, TYPE_STRING, offset + l, NULL);
 }
 
+void add_phandle_marker(struct dt_info *dti, struct property *prop, unsigned int offset)
+{
+	cell_t phandle;
+	struct node *refn;
+	char *ref;
+
+	if (prop->val.len < offset + 4) {
+		if (quiet < 1)
+			fprintf(stderr,
+				"Warning: property %s too short to contain a phandle at offset %u\n",
+				prop->name, offset);
+
+	}
+
+	phandle = dtb_ld32(prop->val.val + offset);
+	refn = get_node_by_phandle(dti->dt, phandle);
+
+	if (!refn) {
+		if (quiet < 1)
+			fprintf(stderr,
+				"Warning: node referenced by phandle 0x%x in property %s not found\n",
+				phandle, prop->name);
+		return;
+	}
+
+	if (refn->labels)
+		ref = refn->labels->label;
+	else
+		ref = refn->fullpath;
+
+	add_marker(&prop->val.markers, REF_PHANDLE, offset, ref);
+}
+
 static enum markertype guess_value_type(struct property *prop, unsigned int offset, int len)
 {
 	const char *p = prop->val.val + offset;
-- 
2.50.1

Re: [PATCH 5/6] Restore phandle references from __local_fixups__ node

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 5477 bytes --]

On Wed, Aug 20, 2025 at 03:11:31PM +0200, Uwe Kleine-König wrote:
> The __local_fixups__ node contains information about phandles. Parse it
> to improve the result when decompiling a device tree blob.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
> ---
>  dtc.c        |  2 ++
>  dtc.h        |  2 ++
>  livetree.c   | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++
>  treesource.c | 33 ++++++++++++++++++++++++++++++
>  4 files changed, 94 insertions(+)
> 
> diff --git a/dtc.c b/dtc.c
> index 63a6c85da5cf..9f90b373967d 100644
> --- a/dtc.c
> +++ b/dtc.c
> @@ -343,6 +343,8 @@ int main(int argc, char *argv[])
>  	if (generate_symbols)
>  		generate_label_tree(dti, "__symbols__", true);
>  
> +	local_fixup_phandles(dti, "__local_fixups__");
> +
>  	if (generate_fixups) {
>  		generate_fixups_tree(dti, "__fixups__");
>  		generate_local_fixups_tree(dti, "__local_fixups__");
> diff --git a/dtc.h b/dtc.h
> index f97f3c29e2d4..d07a583441f6 100644
> --- a/dtc.h
> +++ b/dtc.h
> @@ -343,6 +343,7 @@ void generate_labels_from_tree(struct dt_info *dti, const char *name);
>  void generate_label_tree(struct dt_info *dti, const char *name, bool allocph);
>  void generate_fixups_tree(struct dt_info *dti, const char *name);
>  void generate_local_fixups_tree(struct dt_info *dti, const char *name);
> +void local_fixup_phandles(struct dt_info *dti, const char *name);
>  
>  /* Checks */
>  
> @@ -358,6 +359,7 @@ struct dt_info *dt_from_blob(const char *fname);
>  
>  /* Tree source */
>  
> +void add_phandle_marker(struct dt_info *dti, struct property *prop, unsigned int offset);
>  void dt_to_source(FILE *f, struct dt_info *dti);
>  struct dt_info *dt_from_source(const char *f);
>  
> diff --git a/livetree.c b/livetree.c
> index 8aafc9aa5cd6..3dbef9071017 100644
> --- a/livetree.c
> +++ b/livetree.c
> @@ -1160,3 +1160,60 @@ void generate_local_fixups_tree(struct dt_info *dti, const char *name)
>  			"Warning: Preexisting data in %s malformed, some content could not be added.\n",
>  			name);
>  }
> +
> +static void local_fixup_phandles_node(struct dt_info *dti, struct node *lf, struct node *n)
> +{
> +	struct property *lfp;
> +	struct node *lfsubnode;
> +
> +	for_each_property(lf, lfp) {
> +		struct property *p = get_property(n, lfp->name);
> +		fdt32_t *offsets = (fdt32_t *)lfp->val.val;
> +		size_t i;
> +
> +		if (!p) {
> +			if (quiet < 1)
> +				fprintf(stderr, "Warning: Property %s in %s referenced in __local_fixups__ missing\n",
> +					lfp->name, n->fullpath);
> +			continue;
> +		}
> +
> +		/*
> +		 * Each property in the __local_fixups__ tree is a concatenation
> +		 * of offsets, so it must be a multiple of sizeof(fdt32_t).
> +		 */
> +		if (lfp->val.len % sizeof(fdt32_t)) {
> +			if (quiet < 1)
> +				fprintf(stderr, "Warning: property %s in /__local_fixups__%s malformed\n",
> +					lfp->name, n->fullpath);
> +			continue;
> +		}
> +
> +		for (i = 0; i < lfp->val.len / sizeof(fdt32_t); i++)
> +			add_phandle_marker(dti, p, dtb_ld32(offsets + i));
> +	}
> +
> +	for_each_child(lf, lfsubnode) {
> +		struct node *subnode = get_subnode(n, lfsubnode->name);
> +
> +		if (!subnode) {
> +			if (quiet < 1)
> +				fprintf(stderr, "Warning: node %s/%s referenced in __local_fixups__ missing\n",
> +					lfsubnode->name, n->fullpath);
> +			continue;
> +		}
> +
> +		local_fixup_phandles_node(dti, lfsubnode, subnode);
> +	}
> +}
> +
> +void local_fixup_phandles(struct dt_info *dti, const char *name)
> +{
> +	struct node *an;
> +
> +	an = get_subnode(dti->dt, name);
> +	if (!an)
> +		return;
> +
> +	local_fixup_phandles_node(dti, an, dti->dt);
> +}
> diff --git a/treesource.c b/treesource.c
> index 576495902f0d..5b8d7a679519 100644
> --- a/treesource.c
> +++ b/treesource.c
> @@ -183,6 +183,39 @@ static void add_string_markers(struct property *prop, unsigned int offset, int l
>  		mi = add_marker(mi, TYPE_STRING, offset + l, NULL);
>  }
>  
> +void add_phandle_marker(struct dt_info *dti, struct property *prop, unsigned int offset)
> +{
> +	cell_t phandle;
> +	struct node *refn;
> +	char *ref;
> +
> +	if (prop->val.len < offset + 4) {
> +		if (quiet < 1)
> +			fprintf(stderr,
> +				"Warning: property %s too short to contain a phandle at offset %u\n",
> +				prop->name, offset);

You print the error, but don't exit the function.

> +
> +	}
> +
> +	phandle = dtb_ld32(prop->val.val + offset);
> +	refn = get_node_by_phandle(dti->dt, phandle);
> +
> +	if (!refn) {
> +		if (quiet < 1)
> +			fprintf(stderr,
> +				"Warning: node referenced by phandle 0x%x in property %s not found\n",
> +				phandle, prop->name);
> +		return;
> +	}
> +
> +	if (refn->labels)
> +		ref = refn->labels->label;
> +	else
> +		ref = refn->fullpath;

The new marker will point to data in different structures by
reference, which makes me worried about lifetimes.  But this is not
new, and probably not the only hairy lifetime issue in dtc.

> +
> +	add_marker(&prop->val.markers, REF_PHANDLE, offset, ref);
> +}
> +
>  static enum markertype guess_value_type(struct property *prop, unsigned int offset, int len)
>  {
>  	const char *p = prop->val.val + offset;

-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

[PATCH 6/6] Restore phandle references from __fixups__ node

[Uwe Kleine-König]

The __fixups__ node contains information about labels. Parse its
properties to create phandle markers which improve the resulting dts
when decompiling a device tree blob.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
---
 dtc.c        |  1 +
 dtc.h        |  3 ++
 livetree.c   | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 treesource.c |  6 ++++
 4 files changed, 106 insertions(+)

diff --git a/dtc.c b/dtc.c
index 9f90b373967d..6dae60de0ea5 100644
--- a/dtc.c
+++ b/dtc.c
@@ -343,6 +343,7 @@ int main(int argc, char *argv[])
 	if (generate_symbols)
 		generate_label_tree(dti, "__symbols__", true);
 
+	fixup_phandles(dti, "__fixups__");
 	local_fixup_phandles(dti, "__local_fixups__");
 
 	if (generate_fixups) {
diff --git a/dtc.h b/dtc.h
index d07a583441f6..7231200e5d02 100644
--- a/dtc.h
+++ b/dtc.h
@@ -342,6 +342,7 @@ void sort_tree(struct dt_info *dti);
 void generate_labels_from_tree(struct dt_info *dti, const char *name);
 void generate_label_tree(struct dt_info *dti, const char *name, bool allocph);
 void generate_fixups_tree(struct dt_info *dti, const char *name);
+void fixup_phandles(struct dt_info *dti, const char *name);
 void generate_local_fixups_tree(struct dt_info *dti, const char *name);
 void local_fixup_phandles(struct dt_info *dti, const char *name);
 
@@ -359,6 +360,8 @@ struct dt_info *dt_from_blob(const char *fname);
 
 /* Tree source */
 
+void property_add_marker(struct property *prop,
+			 enum markertype type, unsigned int offset, char *ref);
 void add_phandle_marker(struct dt_info *dti, struct property *prop, unsigned int offset);
 void dt_to_source(FILE *f, struct dt_info *dti);
 struct dt_info *dt_from_source(const char *f);
diff --git a/livetree.c b/livetree.c
index 3dbef9071017..5d72abceb526 100644
--- a/livetree.c
+++ b/livetree.c
@@ -1151,6 +1151,102 @@ void generate_fixups_tree(struct dt_info *dti, const char *name)
 			name);
 }
 
+void fixup_phandles(struct dt_info *dti, const char *name)
+{
+	struct node *an;
+	struct property *fp;
+
+	an = get_subnode(dti->dt, name);
+	if (!an)
+		return;
+
+	for_each_property(an, fp) {
+		char *fnext = fp->val.val;
+		char *fv;
+		unsigned int fl;
+
+		while ((fl = fp->val.len - (fnext - fp->val.val))) {
+			char *propname, *soffset;
+			struct node *n;
+			struct property *p;
+			long offset;
+
+			fv = fnext;
+			fnext = memchr(fv, 0, fl);
+
+			if (!fnext) {
+				if (quiet < 1)
+					fprintf(stderr, "Warning: Malformed fixup entry for label %s\n",
+						fp->name);
+				break;
+			}
+			fnext += 1;
+
+			propname = memchr(fv, ':', fnext - 1 - fv);
+			if (!propname) {
+				if (quiet < 1)
+					fprintf(stderr, "Warning: Malformed fixup entry for label %s\n",
+						fp->name);
+				continue;
+			}
+			propname++;
+
+			soffset = memchr(propname, ':', fnext - 1 - propname);
+			if (!soffset) {
+				if (quiet < 1)
+					fprintf(stderr, "Warning: Malformed fixup entry for label %s\n",
+						fp->name);
+				continue;
+			}
+			soffset++;
+
+			/*
+			 * temporarily modify the property to not have to create
+			 * a copy for the node path.
+			 */
+			*(propname - 1) = '\0';
+
+			n = get_node_by_path(dti->dt, fv);
+			if (!n && quiet < 1)
+				fprintf(stderr, "Warning: Label %s references non-existing node %s\n",
+					fp->name, fv);
+
+			*(propname - 1) = ':';
+
+			if (!n)
+				continue;
+
+			/*
+			 * temporarily modify the property to not have to create
+			 * a copy for the property name.
+			 */
+			*(soffset - 1) = '\0';
+
+			p = get_property(n, propname);
+
+			if (!p && quiet < 1)
+				fprintf(stderr, "Warning: Label %s references non-existing property %s in node %s\n",
+					fp->name, n->fullpath, propname);
+
+			*(soffset - 1) = ':';
+
+			if (!p)
+				continue;
+
+			offset = strtol(soffset, NULL, 0);
+			if (offset < 0 || offset + 4 > p->val.len) {
+				if (quiet < 1)
+					fprintf(stderr,
+						"Warning: Label %s contains invalid offset for property %s in node %s\n",
+						fp->name, p->name, n->fullpath);
+				continue;
+			}
+
+			property_add_marker(p, REF_PHANDLE, offset, fp->name);
+		}
+	}
+}
+
 void generate_local_fixups_tree(struct dt_info *dti, const char *name)
 {
 	if (!any_local_fixup_tree(dti, dti->dt))
diff --git a/treesource.c b/treesource.c
index 5b8d7a679519..6cd996f0d17b 100644
--- a/treesource.c
+++ b/treesource.c
@@ -173,6 +173,12 @@ static struct marker **add_marker(struct marker **mi,
 	return &nm->next;
 }
 
+void property_add_marker(struct property *prop,
+			 enum markertype type, unsigned int offset, char *ref)
+{
+	add_marker(&prop->val.markers, type, offset, ref);
+}
+
 static void add_string_markers(struct property *prop, unsigned int offset, int len)
 {
 	int l;
-- 
2.50.1

Re: [PATCH 6/6] Restore phandle references from __fixups__ node

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 5526 bytes --]

On Wed, Aug 20, 2025 at 03:11:32PM +0200, Uwe Kleine-König wrote:
> The __fixups__ node contains information about labels. Parse its
> properties to create phandle markers which improve the resulting dts
> when decompiling a device tree blob.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>

Reviewed-by: David Gibson <david@gibson.dropbear.id.au>

> ---
>  dtc.c        |  1 +
>  dtc.h        |  3 ++
>  livetree.c   | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++
>  treesource.c |  6 ++++
>  4 files changed, 106 insertions(+)
> 
> diff --git a/dtc.c b/dtc.c
> index 9f90b373967d..6dae60de0ea5 100644
> --- a/dtc.c
> +++ b/dtc.c
> @@ -343,6 +343,7 @@ int main(int argc, char *argv[])
>  	if (generate_symbols)
>  		generate_label_tree(dti, "__symbols__", true);
>  
> +	fixup_phandles(dti, "__fixups__");
>  	local_fixup_phandles(dti, "__local_fixups__");
>  
>  	if (generate_fixups) {
> diff --git a/dtc.h b/dtc.h
> index d07a583441f6..7231200e5d02 100644
> --- a/dtc.h
> +++ b/dtc.h
> @@ -342,6 +342,7 @@ void sort_tree(struct dt_info *dti);
>  void generate_labels_from_tree(struct dt_info *dti, const char *name);
>  void generate_label_tree(struct dt_info *dti, const char *name, bool allocph);
>  void generate_fixups_tree(struct dt_info *dti, const char *name);
> +void fixup_phandles(struct dt_info *dti, const char *name);
>  void generate_local_fixups_tree(struct dt_info *dti, const char *name);
>  void local_fixup_phandles(struct dt_info *dti, const char *name);
>  
> @@ -359,6 +360,8 @@ struct dt_info *dt_from_blob(const char *fname);
>  
>  /* Tree source */
>  
> +void property_add_marker(struct property *prop,
> +			 enum markertype type, unsigned int offset, char *ref);
>  void add_phandle_marker(struct dt_info *dti, struct property *prop, unsigned int offset);
>  void dt_to_source(FILE *f, struct dt_info *dti);
>  struct dt_info *dt_from_source(const char *f);
> diff --git a/livetree.c b/livetree.c
> index 3dbef9071017..5d72abceb526 100644
> --- a/livetree.c
> +++ b/livetree.c
> @@ -1151,6 +1151,102 @@ void generate_fixups_tree(struct dt_info *dti, const char *name)
>  			name);
>  }
>  
> +void fixup_phandles(struct dt_info *dti, const char *name)
> +{
> +	struct node *an;
> +	struct property *fp;
> +
> +	an = get_subnode(dti->dt, name);
> +	if (!an)
> +		return;
> +
> +	for_each_property(an, fp) {
> +		char *fnext = fp->val.val;
> +		char *fv;
> +		unsigned int fl;
> +
> +		while ((fl = fp->val.len - (fnext - fp->val.val))) {
> +			char *propname, *soffset;
> +			struct node *n;
> +			struct property *p;
> +			long offset;
> +
> +			fv = fnext;
> +			fnext = memchr(fv, 0, fl);
> +
> +			if (!fnext) {
> +				if (quiet < 1)
> +					fprintf(stderr, "Warning: Malformed fixup entry for label %s\n",
> +						fp->name);
> +				break;
> +			}
> +			fnext += 1;
> +
> +			propname = memchr(fv, ':', fnext - 1 - fv);
> +			if (!propname) {
> +				if (quiet < 1)
> +					fprintf(stderr, "Warning: Malformed fixup entry for label %s\n",
> +						fp->name);
> +				continue;
> +			}
> +			propname++;
> +
> +			soffset = memchr(propname, ':', fnext - 1 - propname);
> +			if (!soffset) {
> +				if (quiet < 1)
> +					fprintf(stderr, "Warning: Malformed fixup entry for label %s\n",
> +						fp->name);
> +				continue;
> +			}
> +			soffset++;
> +
> +			/*
> +			 * temporarily modify the property to not have to create
> +			 * a copy for the node path.
> +			 */
> +			*(propname - 1) = '\0';
> +
> +			n = get_node_by_path(dti->dt, fv);
> +			if (!n && quiet < 1)
> +				fprintf(stderr, "Warning: Label %s references non-existing node %s\n",
> +					fp->name, fv);
> +
> +			*(propname - 1) = ':';
> +
> +			if (!n)
> +				continue;
> +
> +			/*
> +			 * temporarily modify the property to not have to create
> +			 * a copy for the property name.
> +			 */
> +			*(soffset - 1) = '\0';
> +
> +			p = get_property(n, propname);
> +
> +			if (!p && quiet < 1)
> +				fprintf(stderr, "Warning: Label %s references non-existing property %s in node %s\n",
> +					fp->name, n->fullpath, propname);
> +
> +			*(soffset - 1) = ':';
> +
> +			if (!p)
> +				continue;
> +
> +			offset = strtol(soffset, NULL, 0);
> +			if (offset < 0 || offset + 4 > p->val.len) {
> +				if (quiet < 1)
> +					fprintf(stderr,
> +						"Warning: Label %s contains invalid offset for property %s in node %s\n",
> +						fp->name, p->name, n->fullpath);
> +				continue;
> +			}
> +
> +			property_add_marker(p, REF_PHANDLE, offset, fp->name);
> +		}
> +	}
> +}
> +
>  void generate_local_fixups_tree(struct dt_info *dti, const char *name)
>  {
>  	if (!any_local_fixup_tree(dti, dti->dt))
> diff --git a/treesource.c b/treesource.c
> index 5b8d7a679519..6cd996f0d17b 100644
> --- a/treesource.c
> +++ b/treesource.c
> @@ -173,6 +173,12 @@ static struct marker **add_marker(struct marker **mi,
>  	return &nm->next;
>  }
>  
> +void property_add_marker(struct property *prop,
> +			 enum markertype type, unsigned int offset, char *ref)
> +{
> +	add_marker(&prop->val.markers, type, offset, ref);
> +}
> +
>  static void add_string_markers(struct property *prop, unsigned int offset, int len)
>  {
>  	int l;

-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]