src/lib/device

Bug Summary

File:	lib/device_tree.c
Warning:	line 753, column 2 Dereference of null pointer
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name device_tree.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -fno-delete-null-pointer-checks -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/home/coreboot/node-root/workspace/coreboot_scanbuild -nostdsysteminc -nobuiltininc -resource-dir /opt/xgcc/lib/clang/17 -include src/include/kconfig.h -include src/include/rules.h -include src/commonlib/bsd/include/commonlib/bsd/compiler.h -I src -I src/include -I src/commonlib/include -I src/commonlib/bsd/include -I /cb-build/coreboot_scanbuild.0/SIFIVE_HIFIVE_UNLEASHED -I 3rdparty/vboot/firmware/include -I 3rdparty -D __BUILD_DIR__="/cb-build/coreboot_scanbuild.0/SIFIVE_HIFIVE_UNLEASHED" -D __COREBOOT__ -D __TIMELESS__ -I src/soc/sifive/fu540/include -I src/arch/riscv/include -D __ARCH_riscv__ -I src/arch/riscv/ -D __riscv -D __riscv_xlen=64 -D __riscv_flen=64 -D __RAMSTAGE__ -source-date-epoch 1715206807 -Os -Wwrite-strings -Wno-trigraphs -Wno-address-of-packed-member -std=gnu11 -fconst-strings -fdebug-compilation-dir=/home/coreboot/node-root/workspace/coreboot_scanbuild -ferror-limit 19 -fno-builtin -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-max-loop 10 -analyzer-output=plist-html -faddrsig -o /cb-build/coreboot_scanbuild.0/SIFIVE_HIFIVE_UNLEASHED-scanbuildtmp/2024-05-09-081028-2840436-1/report-xbl1Ez.plist -x c src/lib/device_tree.c
1/* Taken from depthcharge: src/base/device_tree.c */
2/* SPDX-License-Identifier: GPL-2.0-or-later */

4#include <assert.h>
5#include <console/console.h>
6#include <ctype.h>
7#include <device_tree.h>
8#include <endian.h>
9#include <stdint.h>
10#include <string.h>
11#include <stddef.h>
12#include <stdlib.h>

14/*
* Functions for picking apart flattened trees.
*/

18int fdt_next_property(const void *blob, uint32_t offset,
      struct fdt_property *prop)
20{
struct fdt_header *header = (struct fdt_header *)blob;
uint32_t *ptr = (uint32_t *)(((uint8_t *)blob) + offset);

int index = 0;
if (be32toh(ptr[index++]) != FDT_TOKEN_PROPERTY3)
return 0;

uint32_t size = be32toh(ptr[index++]);
uint32_t name_offset = be32toh(ptr[index++]);
name_offset += be32toh(header->strings_offset);

if (prop) {
prop->name = (char *)((uint8_t *)blob + name_offset);
prop->data = &ptr[index];
prop->size = size;
}

index += DIV_ROUND_UP(size, sizeof(uint32_t))({ __typeof__(size) _div_local_x = (size); __typeof__(sizeof(
uint32_t)) _div_local_y = (sizeof(uint32_t)); (_div_local_x +
 _div_local_y - 1) / _div_local_y; });

return index * sizeof(uint32_t);
41}

43int fdt_node_name(const void *blob, uint32_t offset, const char **name)
44{
uint8_t *ptr = ((uint8_t *)blob) + offset;
if (be32dec(ptr) != FDT_TOKEN_BEGIN_NODE1)
return 0;

ptr += 4;
if (name)
*name = (char *)ptr;
return ALIGN_UP(strlen((char *)ptr) + 1, sizeof(uint32_t))((((strlen((char *)ptr) + 1))+((__typeof__((strlen((char *)ptr
) + 1)))((sizeof(uint32_t)))-1UL))&~((__typeof__((strlen(
(char *)ptr) + 1)))((sizeof(uint32_t)))-1UL)) + 4;
53}

55static int dt_prop_is_phandle(struct device_tree_property *prop)
56{
return !(strcmp("phandle", prop->prop.name) &&
 strcmp("linux,phandle", prop->prop.name));
59}



63/*
* Functions for printing flattened trees.
*/

67static void print_indent(int depth)
68{
printk(BIOS_DEBUG7, "%*s", depth * 8, "");
70}

72static void print_property(const struct fdt_property *prop, int depth)
73{
int is_string = prop->size > 0 &&
	((char *)prop->data)[prop->size - 1] == '\0';

if (is_string) {
for (int i = 0; i < prop->size - 1; i++) {
	if (!isprint(((char *)prop->data)[i])) {
		is_string = 0;
		break;
	}
}
}

print_indent(depth);
if (is_string) {
printk(BIOS_DEBUG7, "%s = \"%s\";\n",
       prop->name, (const char *)prop->data);
} else {
printk(BIOS_DEBUG7, "%s = < ", prop->name);
for (int i = 0; i < MIN(128, prop->size)__builtin_choose_expr( __builtin_constant_p(128) && __builtin_constant_p
(prop->size), ((128) < (prop->size) ? (128) : (prop->
size)), ({ __typeof__( __builtin_choose_expr(__builtin_constant_p
(128), prop->size, 128)) __tmpname_28 = (128); __typeof__(
 __builtin_choose_expr(__builtin_constant_p(prop->size), 128
, prop->size)) __tmpname_29 = (prop->size); __tmpname_28
 < __tmpname_29 ? __tmpname_28 : __tmpname_29; })); i += 4) {
	uint32_t val = 0;
	for (int j = 0; j < MIN(4, prop->size - i)__builtin_choose_expr( __builtin_constant_p(4) && __builtin_constant_p
(prop->size - i), ((4) < (prop->size - i) ? (4) : (prop
->size - i)), ({ __typeof__( __builtin_choose_expr(__builtin_constant_p
(4), prop->size - i, 4)) __tmpname_30 = (4); __typeof__( __builtin_choose_expr
(__builtin_constant_p(prop->size - i), 4, prop->size - i
)) __tmpname_31 = (prop->size - i); __tmpname_30 < __tmpname_31
 ? __tmpname_30 : __tmpname_31; })); j++)
		val |= ((uint8_t *)prop->data)[i + j] <<
			(24 - j * 8);
	printk(BIOS_DEBUG7, "%#.2x ", val);
}
if (prop->size > 128)
	printk(BIOS_DEBUG7, "...");
printk(BIOS_DEBUG7, ">;\n");
}
103}

105static int print_flat_node(const void *blob, uint32_t start_offset, int depth)
106{
int offset = start_offset;
const char *name;
int size;

size = fdt_node_name(blob, offset, &name);
if (!size)
return 0;
offset += size;

print_indent(depth);
printk(BIOS_DEBUG7, "%s {\n", name);

struct fdt_property prop;
while ((size = fdt_next_property(blob, offset, &prop))) {
print_property(&prop, depth + 1);

offset += size;
}

printk(BIOS_DEBUG7, "\n");	/* empty line between props and nodes */

while ((size = print_flat_node(blob, offset, depth + 1)))
offset += size;

print_indent(depth);
printk(BIOS_DEBUG7, "}\n");

return offset - start_offset + sizeof(uint32_t);
135}

137void fdt_print_node(const void *blob, uint32_t offset)
138{
print_flat_node(blob, offset, 0);
140}



144/*
* A utility function to skip past nodes in flattened trees.
*/

148int fdt_skip_node(const void *blob, uint32_t start_offset)
149{
int offset = start_offset;
int size;

const char *name;
size = fdt_node_name(blob, offset, &name);
if (!size)
return 0;
offset += size;

while ((size = fdt_next_property(blob, offset, NULL((void *)0))))
offset += size;

while ((size = fdt_skip_node(blob, offset)))
offset += size;

return offset - start_offset + sizeof(uint32_t);
166}



170/*
* Functions to turn a flattened tree into an unflattened one.
*/

174static int fdt_unflatten_node(const void *blob, uint32_t start_offset,
	      struct device_tree *tree,
	      struct device_tree_node **new_node)
177{
struct list_node *last;
int offset = start_offset;
const char *name;
int size;

size = fdt_node_name(blob, offset, &name);
if (!size)
return 0;
offset += size;

struct device_tree_node *node = xzalloc(sizeof(*node))xzalloc_work((sizeof(*node)), "src/lib/device_tree.c", __func__
, 188);
*new_node = node;
node->name = name;

struct fdt_property fprop;
last = &node->properties;
while ((size = fdt_next_property(blob, offset, &fprop))) {
struct device_tree_property *prop = xzalloc(sizeof(*prop))xzalloc_work((sizeof(*prop)), "src/lib/device_tree.c", __func__
, 195);
prop->prop = fprop;

if (dt_prop_is_phandle(prop)) {
	node->phandle = be32dec(prop->prop.data);
	if (node->phandle > tree->max_phandle)
		tree->max_phandle = node->phandle;
}

list_insert_after(&prop->list_node, last);
last = &prop->list_node;

offset += size;
}

struct device_tree_node *child;
last = &node->children;
while ((size = fdt_unflatten_node(blob, offset, tree, &child))) {
list_insert_after(&child->list_node, last);
last = &child->list_node;

offset += size;
}

return offset - start_offset + sizeof(uint32_t);
220}

222static int fdt_unflatten_map_entry(const void *blob, uint32_t offset,
		   struct device_tree_reserve_map_entry **new)
224{
const uint64_t *ptr = (const uint64_t *)(((uint8_t *)blob) + offset);
const uint64_t start = be64toh(ptr[0]);
const uint64_t size = be64toh(ptr[1]);

if (!size)
return 0;

struct device_tree_reserve_map_entry *entry = xzalloc(sizeof(*entry))xzalloc_work((sizeof(*entry)), "src/lib/device_tree.c", __func__
, 232);
*new = entry;
entry->start = start;
entry->size = size;

return sizeof(uint64_t) * 2;
238}

240struct device_tree *fdt_unflatten(const void *blob)
241{
struct device_tree *tree = xzalloc(sizeof(*tree))xzalloc_work((sizeof(*tree)), "src/lib/device_tree.c", __func__
, 242);
const struct fdt_header *header = (const struct fdt_header *)blob;
tree->header = header;

uint32_t magic = be32toh(header->magic);
uint32_t version = be32toh(header->version);
uint32_t last_comp_version = be32toh(header->last_comp_version);

if (magic != FDT_HEADER_MAGIC0xd00dfeed) {
printk(BIOS_DEBUG7, "Invalid device tree magic %#.8x!\n", magic);
free(tree);
return NULL((void *)0);
}
if (last_comp_version > FDT_SUPPORTED_VERSION17) {
printk(BIOS_DEBUG7, "Unsupported device tree version %u(>=%u)\n",
       version, last_comp_version);
free(tree);
return NULL((void *)0);
}
if (version > FDT_SUPPORTED_VERSION17)
printk(BIOS_NOTICE5, "FDT version %u too new, should add support!\n",
       version);

uint32_t struct_offset = be32toh(header->structure_offset);
uint32_t strings_offset = be32toh(header->strings_offset);
uint32_t reserve_offset = be32toh(header->reserve_map_offset);
uint32_t min_offset = 0;
min_offset = MIN(struct_offset, strings_offset)__builtin_choose_expr( __builtin_constant_p(struct_offset) &&
 __builtin_constant_p(strings_offset), ((struct_offset) < (
strings_offset) ? (struct_offset) : (strings_offset)), ({ __typeof__
( __builtin_choose_expr(__builtin_constant_p(struct_offset), strings_offset
, struct_offset)) __tmpname_32 = (struct_offset); __typeof__(
 __builtin_choose_expr(__builtin_constant_p(strings_offset), struct_offset
, strings_offset)) __tmpname_33 = (strings_offset); __tmpname_32
 < __tmpname_33 ? __tmpname_32 : __tmpname_33; }));
min_offset = MIN(min_offset, reserve_offset)__builtin_choose_expr( __builtin_constant_p(min_offset) &&
 __builtin_constant_p(reserve_offset), ((min_offset) < (reserve_offset
) ? (min_offset) : (reserve_offset)), ({ __typeof__( __builtin_choose_expr
(__builtin_constant_p(min_offset), reserve_offset, min_offset
)) __tmpname_34 = (min_offset); __typeof__( __builtin_choose_expr
(__builtin_constant_p(reserve_offset), min_offset, reserve_offset
)) __tmpname_35 = (reserve_offset); __tmpname_34 < __tmpname_35
 ? __tmpname_34 : __tmpname_35; }));
/* Assume everything up to the first non-header component is part of
  the header and needs to be preserved. This will protect us against
  new elements being added in the future. */
tree->header_size = min_offset;

struct device_tree_reserve_map_entry *entry;
uint32_t offset = reserve_offset;
int size;
struct list_node *last = &tree->reserve_map;
while ((size = fdt_unflatten_map_entry(blob, offset, &entry))) {
list_insert_after(&entry->list_node, last);
last = &entry->list_node;

offset += size;
}

fdt_unflatten_node(blob, struct_offset, tree, &tree->root);

return tree;
290}



294/*
* Functions to find the size of the device tree if it was flattened.
*/

298static void dt_flat_prop_size(struct device_tree_property *prop,
	      uint32_t *struct_size, uint32_t *strings_size)
300{
/* Starting token. */
*struct_size += sizeof(uint32_t);
/* Size. */
*struct_size += sizeof(uint32_t);
/* Name offset. */
*struct_size += sizeof(uint32_t);
/* Property value. */
*struct_size += ALIGN_UP(prop->prop.size, sizeof(uint32_t))((((prop->prop.size))+((__typeof__((prop->prop.size)))(
(sizeof(uint32_t)))-1UL))&~((__typeof__((prop->prop.size
)))((sizeof(uint32_t)))-1UL));

/* Property name. */
*strings_size += strlen(prop->prop.name) + 1;
312}

314static void dt_flat_node_size(struct device_tree_node *node,
	      uint32_t *struct_size, uint32_t *strings_size)
316{
/* Starting token. */
*struct_size += sizeof(uint32_t);
/* Node name. */
*struct_size += ALIGN_UP(strlen(node->name) + 1, sizeof(uint32_t))((((strlen(node->name) + 1))+((__typeof__((strlen(node->
name) + 1)))((sizeof(uint32_t)))-1UL))&~((__typeof__((strlen
(node->name) + 1)))((sizeof(uint32_t)))-1UL));

struct device_tree_property *prop;
list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
dt_flat_prop_size(prop, struct_size, strings_size);

struct device_tree_node *child;
list_for_each(child, node->children, list_node)for ((child) = ({ const __typeof__(((typeof(*(child)) *)0)->
list_node) *__mptr = ((node->children).next); (typeof(*(child
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(child)), list_node
)); }); (uintptr_t)child + (uintptr_t)__builtin_offsetof(typeof
(*(child)), list_node); (child) = ({ const __typeof__(((typeof
(*(child)) *)0)->list_node) *__mptr = ((child)->list_node
.next); (typeof(*(child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(child)), list_node)); }))
dt_flat_node_size(child, struct_size, strings_size);

/* End token. */
*struct_size += sizeof(uint32_t);
332}

334uint32_t dt_flat_size(const struct device_tree *tree)
335{
uint32_t size = tree->header_size;
struct device_tree_reserve_map_entry *entry;
list_for_each(entry, tree->reserve_map, list_node)for ((entry) = ({ const __typeof__(((typeof(*(entry)) *)0)->
list_node) *__mptr = ((tree->reserve_map).next); (typeof(*
(entry)) *)((char *)__mptr - __builtin_offsetof(typeof(*(entry
)), list_node)); }); (uintptr_t)entry + (uintptr_t)__builtin_offsetof
(typeof(*(entry)), list_node); (entry) = ({ const __typeof__(
((typeof(*(entry)) *)0)->list_node) *__mptr = ((entry)->
list_node.next); (typeof(*(entry)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(entry)), list_node)); }))
size += sizeof(uint64_t) * 2;
size += sizeof(uint64_t) * 2;

uint32_t struct_size = 0;
uint32_t strings_size = 0;
dt_flat_node_size(tree->root, &struct_size, &strings_size);

size += struct_size;
/* End token. */
size += sizeof(uint32_t);

size += strings_size;

return size;
353}



357/*
* Functions to flatten a device tree.
*/

361static void dt_flatten_map_entry(struct device_tree_reserve_map_entry *entry,
		 void **map_start)
363{
((uint64_t *)*map_start)[0] = htobe64(entry->start);
((uint64_t *)*map_start)[1] = htobe64(entry->size);
*map_start = ((uint8_t *)*map_start) + sizeof(uint64_t) * 2;
367}

369static void dt_flatten_prop(struct device_tree_property *prop,
	    void **struct_start, void *strings_base,
	    void **strings_start)
372{
uint8_t *dstruct = (uint8_t *)*struct_start;
uint8_t *dstrings = (uint8_t *)*strings_start;

be32enc(dstruct, FDT_TOKEN_PROPERTY3);
dstruct += sizeof(uint32_t);

be32enc(dstruct, prop->prop.size);
dstruct += sizeof(uint32_t);

uint32_t name_offset = (uintptr_t)dstrings - (uintptr_t)strings_base;
be32enc(dstruct, name_offset);
dstruct += sizeof(uint32_t);

strcpy((char *)dstrings, prop->prop.name);
dstrings += strlen(prop->prop.name) + 1;

memcpy(dstruct, prop->prop.data, prop->prop.size);
dstruct += ALIGN_UP(prop->prop.size, sizeof(uint32_t))((((prop->prop.size))+((__typeof__((prop->prop.size)))(
(sizeof(uint32_t)))-1UL))&~((__typeof__((prop->prop.size
)))((sizeof(uint32_t)))-1UL));

*struct_start = dstruct;
*strings_start = dstrings;
394}

396static void dt_flatten_node(const struct device_tree_node *node,
	    void **struct_start, void *strings_base,
	    void **strings_start)
399{
uint8_t *dstruct = (uint8_t *)*struct_start;
uint8_t *dstrings = (uint8_t *)*strings_start;

be32enc(dstruct, FDT_TOKEN_BEGIN_NODE1);
dstruct += sizeof(uint32_t);

strcpy((char *)dstruct, node->name);
dstruct += ALIGN_UP(strlen(node->name) + 1, sizeof(uint32_t))((((strlen(node->name) + 1))+((__typeof__((strlen(node->
name) + 1)))((sizeof(uint32_t)))-1UL))&~((__typeof__((strlen
(node->name) + 1)))((sizeof(uint32_t)))-1UL));

struct device_tree_property *prop;
list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
dt_flatten_prop(prop, (void **)&dstruct, strings_base,
		(void **)&dstrings);

struct device_tree_node *child;
list_for_each(child, node->children, list_node)for ((child) = ({ const __typeof__(((typeof(*(child)) *)0)->
list_node) *__mptr = ((node->children).next); (typeof(*(child
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(child)), list_node
)); }); (uintptr_t)child + (uintptr_t)__builtin_offsetof(typeof
(*(child)), list_node); (child) = ({ const __typeof__(((typeof
(*(child)) *)0)->list_node) *__mptr = ((child)->list_node
.next); (typeof(*(child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(child)), list_node)); }))
dt_flatten_node(child, (void **)&dstruct, strings_base,
		(void **)&dstrings);

be32enc(dstruct, FDT_TOKEN_END_NODE2);
dstruct += sizeof(uint32_t);

*struct_start = dstruct;
*strings_start = dstrings;
424}

426void dt_flatten(const struct device_tree *tree, void *start_dest)
427{
uint8_t *dest = (uint8_t *)start_dest;

memcpy(dest, tree->header, tree->header_size);
struct fdt_header *header = (struct fdt_header *)dest;
dest += tree->header_size;

struct device_tree_reserve_map_entry *entry;
list_for_each(entry, tree->reserve_map, list_node)for ((entry) = ({ const __typeof__(((typeof(*(entry)) *)0)->
list_node) *__mptr = ((tree->reserve_map).next); (typeof(*
(entry)) *)((char *)__mptr - __builtin_offsetof(typeof(*(entry
)), list_node)); }); (uintptr_t)entry + (uintptr_t)__builtin_offsetof
(typeof(*(entry)), list_node); (entry) = ({ const __typeof__(
((typeof(*(entry)) *)0)->list_node) *__mptr = ((entry)->
list_node.next); (typeof(*(entry)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(entry)), list_node)); }))
dt_flatten_map_entry(entry, (void **)&dest);
((uint64_t *)dest)[0] = ((uint64_t *)dest)[1] = 0;
dest += sizeof(uint64_t) * 2;

uint32_t struct_size = 0;
uint32_t strings_size = 0;
dt_flat_node_size(tree->root, &struct_size, &strings_size);

uint8_t *struct_start = dest;
header->structure_offset = htobe32(dest - (uint8_t *)start_dest);
header->structure_size = htobe32(struct_size);
dest += struct_size;

*((uint32_t *)dest) = htobe32(FDT_TOKEN_END9);
dest += sizeof(uint32_t);

uint8_t *strings_start = dest;
header->strings_offset = htobe32(dest - (uint8_t *)start_dest);
header->strings_size = htobe32(strings_size);
dest += strings_size;

dt_flatten_node(tree->root, (void **)&struct_start, strings_start,
	(void **)&strings_start);

header->totalsize = htobe32(dest - (uint8_t *)start_dest);
461}



465/*
* Functions for printing a non-flattened device tree.
*/

469static void print_node(const struct device_tree_node *node, int depth)
470{
print_indent(depth);
if (depth == 0)	/* root node has no name, print a starting slash */
printk(BIOS_DEBUG7, "/");
printk(BIOS_DEBUG7, "%s {\n", node->name);

struct device_tree_property *prop;
list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
print_property(&prop->prop, depth + 1);

printk(BIOS_DEBUG7, "\n");	/* empty line between props and nodes */

struct device_tree_node *child;
list_for_each(child, node->children, list_node)for ((child) = ({ const __typeof__(((typeof(*(child)) *)0)->
list_node) *__mptr = ((node->children).next); (typeof(*(child
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(child)), list_node
)); }); (uintptr_t)child + (uintptr_t)__builtin_offsetof(typeof
(*(child)), list_node); (child) = ({ const __typeof__(((typeof
(*(child)) *)0)->list_node) *__mptr = ((child)->list_node
.next); (typeof(*(child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(child)), list_node)); }))
print_node(child, depth + 1);

print_indent(depth);
printk(BIOS_DEBUG7, "};\n");
488}

490void dt_print_node(const struct device_tree_node *node)
491{
print_node(node, 0);
493}



497/*
* Functions for reading and manipulating an unflattened device tree.
*/

501/*
* Read #address-cells and #size-cells properties from a node.
*
* @param node		The device tree node to read from.
* @param addrcp	Pointer to store #address-cells in, skipped if NULL.
* @param sizecp	Pointer to store #size-cells in, skipped if NULL.
*/
508void dt_read_cell_props(const struct device_tree_node *node, u32 *addrcp,
	u32 *sizecp)
510{
struct device_tree_property *prop;
list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); })) {
if (addrcp && !strcmp("#address-cells", prop->prop.name))
	*addrcp = be32dec(prop->prop.data);
if (sizecp && !strcmp("#size-cells", prop->prop.name))
	*sizecp = be32dec(prop->prop.data);
}
518}

520/*
* Find a node from a device tree path, relative to a parent node.
*
* @param parent	The node from which to start the relative path lookup.
* @param path		An array of path component strings that will be looked
*			up in order to find the node. Must be terminated with
*			a NULL pointer. Example: {'firmware', 'coreboot', NULL}
* @param addrcp	Pointer that will be updated with any #address-cells
*			value found in the path. May be NULL to ignore.
* @param sizecp	Pointer that will be updated with any #size-cells
*			value found in the path. May be NULL to ignore.
* @param create	1: Create node(s) if not found. 0: Return NULL instead.
* @return		The found/created node, or NULL.
*/
534struct device_tree_node *dt_find_node(struct device_tree_node *parent,
		      const char **path, u32 *addrcp,
		      u32 *sizecp, int create)
537{
struct device_tree_node *node, *found = NULL((void *)0);

/* Update #address-cells and #size-cells for this level. */
dt_read_cell_props(parent, addrcp, sizecp);

if (!*path)
return parent;

/* Find the next node in the path, if it exists. */
list_for_each(node, parent->children, list_node)for ((node) = ({ const __typeof__(((typeof(*(node)) *)0)->
list_node) *__mptr = ((parent->children).next); (typeof(*(
node)) *)((char *)__mptr - __builtin_offsetof(typeof(*(node))
, list_node)); }); (uintptr_t)node + (uintptr_t)__builtin_offsetof
(typeof(*(node)), list_node); (node) = ({ const __typeof__(((
typeof(*(node)) *)0)->list_node) *__mptr = ((node)->list_node
.next); (typeof(*(node)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(node)), list_node)); })) {
if (!strcmp(node->name, *path)) {
	found = node;
	break;
}
}

/* Otherwise create it or return NULL. */
if (!found) {
if (!create)
	return NULL((void *)0);

found = calloc(1, sizeof(*found));
if (!found)
	return NULL((void *)0);
found->name = strdup(*path);
if (!found->name)
	return NULL((void *)0);

list_insert_after(&found->list_node, &parent->children);
}

return dt_find_node(found, path + 1, addrcp, sizecp, create);
570}

572/*
* Find a node in the tree from a string device tree path.
*
* @param tree		The device tree to search.
* @param path          A string representing a path in the device tree, with
*			nodes separated by '/'. Example: "/firmware/coreboot"
* @param addrcp	Pointer that will be updated with any #address-cells
*			value found in the path. May be NULL to ignore.
* @param sizecp	Pointer that will be updated with any #size-cells
*			value found in the path. May be NULL to ignore.
* @param create	1: Create node(s) if not found. 0: Return NULL instead.
* @return		The found/created node, or NULL.
*
* It is the caller responsibility to provide a path string that doesn't end
* with a '/' and doesn't contain any "//". If the path does not start with a
* '/', the first segment is interpreted as an alias. */
588struct device_tree_node *dt_find_node_by_path(struct device_tree *tree,
			      const char *path, u32 *addrcp,
			      u32 *sizecp, int create)
591{
char *sub_path;
char *duped_str;
struct device_tree_node *parent;
char *next_slash;
/* Hopefully enough depth for any node. */
const char *path_array[15];
int i;
struct device_tree_node *node = NULL((void *)0);

if (path[0] == '/') { /* regular path */
if (path[1] == '\0') {	/* special case: "/" is root node */
	dt_read_cell_props(tree->root, addrcp, sizecp);
	return tree->root;
}

sub_path = duped_str = strdup(&path[1]);
if (!sub_path)
	return NULL((void *)0);

parent = tree->root;
} else { /* alias */
char *alias;

alias = duped_str = strdup(path);
if (!alias)
	return NULL((void *)0);

sub_path = strchr(alias, '/');
if (sub_path)
	*sub_path = '\0';

parent = dt_find_node_by_alias(tree, alias);
if (!parent) {
	printk(BIOS_DEBUG7,
	       "Could not find node '%s', alias '%s' does not exist\n",
	       path, alias);
	free(duped_str);
	return NULL((void *)0);
}

if (!sub_path) {
	/* it's just the alias, no sub-path */
	free(duped_str);
	return parent;
}

sub_path++;
}

next_slash = sub_path;
path_array[0] = sub_path;
for (i = 1; i < (ARRAY_SIZE(path_array)(sizeof(path_array) / sizeof((path_array)[0])) - 1); i++) {
next_slash = strchr(next_slash, '/');
if (!next_slash)
	break;

*next_slash++ = '\0';
path_array[i] = next_slash;
}

if (!next_slash) {
path_array[i] = NULL((void *)0);
node = dt_find_node(parent, path_array,
		    addrcp, sizecp, create);
}

free(duped_str);
return node;
660}

662/*
* Find a node from an alias
*
* @param tree		The device tree.
* @param alias		The alias name.
* @return		The found node, or NULL.
*/
669struct device_tree_node *dt_find_node_by_alias(struct device_tree *tree,
			       const char *alias)
671{
struct device_tree_node *node;
const char *alias_path;

node = dt_find_node_by_path(tree, "/aliases", NULL((void *)0), NULL((void *)0), 0);
if (!node)
return NULL((void *)0);

alias_path = dt_find_string_prop(node, alias);
if (!alias_path)
return NULL((void *)0);

return dt_find_node_by_path(tree, alias_path, NULL((void *)0), NULL((void *)0), 0);
684}

686struct device_tree_node *dt_find_node_by_phandle(struct device_tree_node *root,
				 uint32_t phandle)
688{
if (!root)
return NULL((void *)0);

if (root->phandle == phandle)
return root;

struct device_tree_node *node;
struct device_tree_node *result;
list_for_each(node, root->children, list_node)for ((node) = ({ const __typeof__(((typeof(*(node)) *)0)->
list_node) *__mptr = ((root->children).next); (typeof(*(node
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(node)), list_node
)); }); (uintptr_t)node + (uintptr_t)__builtin_offsetof(typeof
(*(node)), list_node); (node) = ({ const __typeof__(((typeof(
*(node)) *)0)->list_node) *__mptr = ((node)->list_node.
next); (typeof(*(node)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(node)), list_node)); })) {
result = dt_find_node_by_phandle(node, phandle);
if (result)
	return result;
}

return NULL((void *)0);
704}

706/*
* Check if given node is compatible.
*
* @param node		The node which is to be checked for compatible property.
* @param compat	The compatible string to match.
* @return		1 = compatible, 0 = not compatible.
*/
713static int dt_check_compat_match(struct device_tree_node *node,
		 const char *compat)
715{
struct device_tree_property *prop;

list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); })) {
if (!strcmp("compatible", prop->prop.name)) {
	size_t bytes = prop->prop.size;
	const char *str = prop->prop.data;
	while (bytes > 0) {
		if (!strncmp(compat, str, bytes))
			return 1;
		size_t len = strnlen(str, bytes) + 1;
		if (bytes <= len)
			break;
		str += len;
		bytes -= len;
	}
	break;
}
}

return 0;
736}

738/*
* Find a node from a compatible string, in the subtree of a parent node.
*
* @param parent	The parent node under which to look.
* @param compat	The compatible string to find.
* @return		The found node, or NULL.
*/
745struct device_tree_node *dt_find_compat(struct device_tree_node *parent,
			const char *compat)
747{
/* Check if the parent node itself is compatible. */
if (dt_check_compat_match(parent, compat))
1
Assuming the condition is false→
2
←
Taking false branch→
6
←
Assuming the condition is true→
7
←
Taking true branch→
return parent;
8
←
Returning pointer (loaded from 'parent'), which participates in a condition later→

struct device_tree_node *child;
list_for_each(child, parent->children, list_node)for ((child) = ({ const __typeof__(((typeof(*(child)) *)0)->
list_node) *__mptr = ((parent->children).next); (typeof(*(
child)) *)((char *)__mptr - __builtin_offsetof(typeof(*(child
)), list_node)); }); (uintptr_t)child + (uintptr_t)__builtin_offsetof
(typeof(*(child)), list_node); (child) = ({ const __typeof__(
((typeof(*(child)) *)0)->list_node) *__mptr = ((child)->
list_node.next); (typeof(*(child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(child)), list_node)); })) {
3
←
Value assigned to 'child'→
4
←
Loop condition is true.  Entering loop body→
12
←
Dereference of null pointer
struct device_tree_node *found = dt_find_compat(child, compat);
5
←
Calling 'dt_find_compat'→
9
←
Returning from 'dt_find_compat'→
if (found)
10
←
Assuming 'found' is null→
11
←
Taking false branch→
	return found;
}

return NULL((void *)0);
760}

762/*
* Find the next compatible child of a given parent. All children up to the
* child passed in by caller are ignored. If child is NULL, it considers all the
* children to find the first child which is compatible.
*
* @param parent	The parent node under which to look.
* @param child	The child node to start search from (exclusive). If NULL
*                      consider all children.
* @param compat	The compatible string to find.
* @return		The found node, or NULL.
*/
773struct device_tree_node *
774dt_find_next_compat_child(struct device_tree_node *parent,
	  struct device_tree_node *child,
	  const char *compat)
777{
struct device_tree_node *next;
int ignore = 0;

if (child)
ignore = 1;

list_for_each(next, parent->children, list_node)for ((next) = ({ const __typeof__(((typeof(*(next)) *)0)->
list_node) *__mptr = ((parent->children).next); (typeof(*(
next)) *)((char *)__mptr - __builtin_offsetof(typeof(*(next))
, list_node)); }); (uintptr_t)next + (uintptr_t)__builtin_offsetof
(typeof(*(next)), list_node); (next) = ({ const __typeof__(((
typeof(*(next)) *)0)->list_node) *__mptr = ((next)->list_node
.next); (typeof(*(next)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(next)), list_node)); })) {
if (ignore) {
	if (child == next)
		ignore = 0;
	continue;
}

if (dt_check_compat_match(next, compat))
	return next;
}

return NULL((void *)0);
796}

798/*
* Find a node with matching property value, in the subtree of a parent node.
*
* @param parent	The parent node under which to look.
* @param name		The property name to look for.
* @param data		The property value to look for.
* @param size		The property size.
*/
806struct device_tree_node *dt_find_prop_value(struct device_tree_node *parent,
			    const char *name, void *data,
			    size_t size)
809{
struct device_tree_property *prop;

/* Check if parent itself has the required property value. */
list_for_each(prop, parent->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((parent->properties).next); (typeof(
*(prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop
)), list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); })) {
if (!strcmp(name, prop->prop.name)) {
	size_t bytes = prop->prop.size;
	const void *prop_data = prop->prop.data;
	if (size != bytes)
		break;
	if (!memcmp(data, prop_data, size))
		return parent;
	break;
}
}

struct device_tree_node *child;
list_for_each(child, parent->children, list_node)for ((child) = ({ const __typeof__(((typeof(*(child)) *)0)->
list_node) *__mptr = ((parent->children).next); (typeof(*(
child)) *)((char *)__mptr - __builtin_offsetof(typeof(*(child
)), list_node)); }); (uintptr_t)child + (uintptr_t)__builtin_offsetof
(typeof(*(child)), list_node); (child) = ({ const __typeof__(
((typeof(*(child)) *)0)->list_node) *__mptr = ((child)->
list_node.next); (typeof(*(child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(child)), list_node)); })) {
struct device_tree_node *found = dt_find_prop_value(child, name,
						    data, size);
if (found)
	return found;
}
return NULL((void *)0);
833}

835/*
* Write an arbitrary sized big-endian integer into a pointer.
*
* @param dest		Pointer to the DT property data buffer to write.
* @param src		The integer to write (in CPU endianness).
* @param length	the length of the destination integer in bytes.
*/
842void dt_write_int(u8 *dest, u64 src, size_t length)
843{
while (length--) {
dest[length] = (u8)src;
src >>= 8;
}
848}

850/*
* Delete a property by name in a given node if it exists.
*
* @param node		The device tree node to operate on.
* @param name		The name of the property to delete.
*/
856void dt_delete_prop(struct device_tree_node *node, const char *name)
857{
struct device_tree_property *prop;

list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); })) {
if (!strcmp(prop->prop.name, name)) {
	list_remove(&prop->list_node);
	return;
}
}
866}

868/*
* Add an arbitrary property to a node, or update it if it already exists.
*
* @param node		The device tree node to add to.
* @param name		The name of the new property.
* @param data		The raw data blob to be stored in the property.
* @param size		The size of data in bytes.
*/
876void dt_add_bin_prop(struct device_tree_node *node, const char *name,
     void *data, size_t size)
878{
struct device_tree_property *prop;

list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); })) {
if (!strcmp(prop->prop.name, name)) {
	prop->prop.data = data;
	prop->prop.size = size;
	return;
}
}

prop = xzalloc(sizeof(*prop))xzalloc_work((sizeof(*prop)), "src/lib/device_tree.c", __func__
, 889);
list_insert_after(&prop->list_node, &node->properties);
prop->prop.name = name;
prop->prop.data = data;
prop->prop.size = size;
894}

896/*
* Find given string property in a node and return its content.
*
* @param node		The device tree node to search.
* @param name		The name of the property.
* @return		The found string, or NULL.
*/
903const char *dt_find_string_prop(const struct device_tree_node *node,
		const char *name)
905{
const void *content;
size_t size;

dt_find_bin_prop(node, name, &content, &size);

return content;
912}

914/*
* Find given property in a node.
*
* @param node		The device tree node to search.
* @param name		The name of the property.
* @param data		Pointer to return raw data blob in the property.
* @param size		Pointer to return the size of data in bytes.
*/
922void dt_find_bin_prop(const struct device_tree_node *node, const char *name,
      const void **data, size_t *size)
924{
struct device_tree_property *prop;

*data = NULL((void *)0);
*size = 0;

list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); })) {
if (!strcmp(prop->prop.name, name)) {
	*data = prop->prop.data;
	*size = prop->prop.size;
	return;
}
}
937}

939/*
* Add a string property to a node, or update it if it already exists.
*
* @param node		The device tree node to add to.
* @param name		The name of the new property.
* @param str		The zero-terminated string to be stored in the property.
*/
946void dt_add_string_prop(struct device_tree_node *node, const char *name,
	const char *str)
948{
dt_add_bin_prop(node, name, (char *)str, strlen(str) + 1);
950}

952/*
* Add a 32-bit integer property to a node, or update it if it already exists.
*
* @param node		The device tree node to add to.
* @param name		The name of the new property.
* @param val		The integer to be stored in the property.
*/
959void dt_add_u32_prop(struct device_tree_node *node, const char *name, u32 val)
960{
u32 *val_ptr = xmalloc(sizeof(val))xmalloc_work((sizeof(val)), "src/lib/device_tree.c", __func__
, 961);
*val_ptr = htobe32(val);
dt_add_bin_prop(node, name, val_ptr, sizeof(*val_ptr));
964}

966/*
* Add a 64-bit integer property to a node, or update it if it already exists.
*
* @param node		The device tree node to add to.
* @param name		The name of the new property.
* @param val		The integer to be stored in the property.
*/
973void dt_add_u64_prop(struct device_tree_node *node, const char *name, u64 val)
974{
u64 *val_ptr = xmalloc(sizeof(val))xmalloc_work((sizeof(val)), "src/lib/device_tree.c", __func__
, 975);
*val_ptr = htobe64(val);
dt_add_bin_prop(node, name, val_ptr, sizeof(*val_ptr));
978}

980/*
* Add a 'reg' address list property to a node, or update it if it exists.
*
* @param node		The device tree node to add to.
* @param addrs		Array of address values to be stored in the property.
* @param sizes		Array of corresponding size values to 'addrs'.
* @param count		Number of values in 'addrs' and 'sizes' (must be equal).
* @param addr_cells	Value of #address-cells property valid for this node.
* @param size_cells	Value of #size-cells property valid for this node.
*/
990void dt_add_reg_prop(struct device_tree_node *node, u64 *addrs, u64 *sizes,
     int count, u32 addr_cells, u32 size_cells)
992{
int i;
size_t length = (addr_cells + size_cells) * sizeof(u32) * count;
u8 *data = xmalloc(length)xmalloc_work((length), "src/lib/device_tree.c", __func__, 995
);
u8 *cur = data;

for (i = 0; i < count; i++) {
dt_write_int(cur, addrs[i], addr_cells * sizeof(u32));
cur += addr_cells * sizeof(u32);
dt_write_int(cur, sizes[i], size_cells * sizeof(u32));
cur += size_cells * sizeof(u32);
}

dt_add_bin_prop(node, "reg", data, length);
1006}

1008/*
* Fixups to apply to a kernel's device tree before booting it.
*/

1012struct list_node device_tree_fixups;

1014int dt_apply_fixups(struct device_tree *tree)
1015{
struct device_tree_fixup *fixup;
list_for_each(fixup, device_tree_fixups, list_node)for ((fixup) = ({ const __typeof__(((typeof(*(fixup)) *)0)->
list_node) *__mptr = ((device_tree_fixups).next); (typeof(*(fixup
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(fixup)), list_node
)); }); (uintptr_t)fixup + (uintptr_t)__builtin_offsetof(typeof
(*(fixup)), list_node); (fixup) = ({ const __typeof__(((typeof
(*(fixup)) *)0)->list_node) *__mptr = ((fixup)->list_node
.next); (typeof(*(fixup)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(fixup)), list_node)); })) {
assert(fixup->fixup){ if (!(__builtin_constant_p(fixup->fixup) ? ((fixup->fixup
) ? 1 : ({ _dead_code_assertion_failed(); *(int *)(uintptr_t)
0; })) : 0) && !(fixup->fixup)) { printk(0, "ASSERTION ERROR: file '%s', line %d\n"
, "(filenames not available on timeless builds)", 404); ; if (
1) hlt(); } };
if (fixup->fixup(fixup, tree))
	return 1;
}
return 0;
1023}

1025int dt_set_bin_prop_by_path(struct device_tree *tree, const char *path,
	    void *data, size_t data_size, int create)
1027{
char *path_copy, *prop_name;
struct device_tree_node *dt_node;

path_copy = strdup(path);

if (!path_copy) {
printk(BIOS_ERR3, "Failed to allocate a copy of path %s\n",
       path);
return 1;
}

prop_name = strrchr(path_copy, '/');
if (!prop_name) {
free(path_copy);
printk(BIOS_ERR3, "Path %s does not include '/'\n", path);
return 1;
}

*prop_name++ = '\0'; /* Separate path from the property name. */

dt_node = dt_find_node_by_path(tree, path_copy, NULL((void *)0),
		       NULL((void *)0), create);

if (!dt_node) {
printk(BIOS_ERR3, "Failed to %s %s in the device tree\n",
       create ? "create" : "find", path_copy);
free(path_copy);
return 1;
}

dt_add_bin_prop(dt_node, prop_name, data, data_size);
free(path_copy);

return 0;
1062}

1064/*
* Prepare the /reserved-memory/ node.
*
* Technically, this can be called more than one time, to init and/or retrieve
* the node. But dt_add_u32_prop() may leak a bit of memory if you do.
*
* @tree: Device tree to add/retrieve from.
* @return: The /reserved-memory/ node (or NULL, if error).
*/
1073struct device_tree_node *dt_init_reserved_memory_node(struct device_tree *tree)
1074{
struct device_tree_node *reserved;
u32 addr = 0, size = 0;

reserved = dt_find_node_by_path(tree, "/reserved-memory", &addr,
			&size, 1);
if (!reserved)
return NULL((void *)0);

/* Binding doc says this should have the same #{address,size}-cells as
  the root. */
dt_add_u32_prop(reserved, "#address-cells", addr);
dt_add_u32_prop(reserved, "#size-cells", size);
/* Binding doc says this should be empty (1:1 mapping from root). */
dt_add_bin_prop(reserved, "ranges", NULL((void *)0), 0);

return reserved;
1091}

1093/*
* Increment a single phandle in prop at a given offset by a given adjustment.
*
* @param prop		Property whose phandle should be adjusted.
* @param adjustment	Value that should be added to the existing phandle.
* @param offset	Byte offset of the phandle in the property data.
*
* @return		New phandle value, or 0 on error.
*/
1102static uint32_t dt_adjust_phandle(struct device_tree_property *prop,
		  uint32_t adjustment, uint32_t offset)
1104{
if (offset + 4 > prop->prop.size)
return 0;

uint32_t phandle = be32dec(prop->prop.data + offset);
if (phandle == 0 ||
   phandle == FDT_PHANDLE_ILLEGAL0xdeadbeef ||
   phandle == 0xffffffff)
return 0;

phandle += adjustment;
if (phandle >= FDT_PHANDLE_ILLEGAL0xdeadbeef)
return 0;

be32enc(prop->prop.data + offset, phandle);
return phandle;
1120}

1122/*
* Adjust all phandles in subtree by adding a new base offset.
*
* @param node		Root node of the subtree to work on.
* @param base		New phandle base to be added to all phandles.
*
* @return		New highest phandle in the subtree, or 0 on error.
*/
1130static uint32_t dt_adjust_all_phandles(struct device_tree_node *node,
		       uint32_t base)
1132{
uint32_t new_max = MAX(base, 1)__builtin_choose_expr( __builtin_constant_p(base) && __builtin_constant_p
(1), ((base) > (1) ? (base) : (1)), ({ __typeof__( __builtin_choose_expr
(__builtin_constant_p(base), 1, base)) __tmpname_36 = (base);
 __typeof__( __builtin_choose_expr(__builtin_constant_p(1), base
, 1)) __tmpname_37 = (1); __tmpname_36 > __tmpname_37 ? __tmpname_36
 : __tmpname_37; }));  /* make sure we don't return 0 */
struct device_tree_property *prop;
struct device_tree_node *child;

if (!node)
return new_max;

list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
if (dt_prop_is_phandle(prop)) {
	node->phandle = dt_adjust_phandle(prop, base, 0);
	if (!node->phandle)
		return 0;
	new_max = MAX(new_max, node->phandle)__builtin_choose_expr( __builtin_constant_p(new_max) &&
 __builtin_constant_p(node->phandle), ((new_max) > (node
->phandle) ? (new_max) : (node->phandle)), ({ __typeof__
( __builtin_choose_expr(__builtin_constant_p(new_max), node->
phandle, new_max)) __tmpname_38 = (new_max); __typeof__( __builtin_choose_expr
(__builtin_constant_p(node->phandle), new_max, node->phandle
)) __tmpname_39 = (node->phandle); __tmpname_38 > __tmpname_39
 ? __tmpname_38 : __tmpname_39; }));
}  /* no break -- can have more than one phandle prop */

list_for_each(child, node->children, list_node)for ((child) = ({ const __typeof__(((typeof(*(child)) *)0)->
list_node) *__mptr = ((node->children).next); (typeof(*(child
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(child)), list_node
)); }); (uintptr_t)child + (uintptr_t)__builtin_offsetof(typeof
(*(child)), list_node); (child) = ({ const __typeof__(((typeof
(*(child)) *)0)->list_node) *__mptr = ((child)->list_node
.next); (typeof(*(child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(child)), list_node)); }))
new_max = MAX(new_max, dt_adjust_all_phandles(child, base))__builtin_choose_expr( __builtin_constant_p(new_max) &&
 __builtin_constant_p(dt_adjust_all_phandles(child, base)), (
(new_max) > (dt_adjust_all_phandles(child, base)) ? (new_max
) : (dt_adjust_all_phandles(child, base))), ({ __typeof__( __builtin_choose_expr
(__builtin_constant_p(new_max), dt_adjust_all_phandles(child,
 base), new_max)) __tmpname_40 = (new_max); __typeof__( __builtin_choose_expr
(__builtin_constant_p(dt_adjust_all_phandles(child, base)), new_max
, dt_adjust_all_phandles(child, base))) __tmpname_41 = (dt_adjust_all_phandles
(child, base)); __tmpname_40 > __tmpname_41 ? __tmpname_40
 : __tmpname_41; }));

return new_max;
1152}

1154/*
* Apply a /__local_fixup__ subtree to the corresponding overlay subtree.
*
* @param node		Root node of the overlay subtree to fix up.
* @param node		Root node of the /__local_fixup__ subtree.
* @param base		Adjustment that was added to phandles in the overlay.
*
* @return		0 on success, -1 on error.
*/
1163static int dt_fixup_locals(struct device_tree_node *node,
    struct device_tree_node *fixup, uint32_t base)
1165{
struct device_tree_property *prop;
struct device_tree_property *fixup_prop;
struct device_tree_node *child;
struct device_tree_node *fixup_child;
int i;

/*
* For local fixups the /__local_fixup__ subtree contains the same node
* hierarchy as the main tree we're fixing up. Each property contains
* the fixup offsets for the respective property in the main tree. For
* each property in the fixup node, find the corresponding property in
* the base node and apply fixups to all offsets it specifies.
*/
list_for_each(fixup_prop, fixup->properties, list_node)for ((fixup_prop) = ({ const __typeof__(((typeof(*(fixup_prop
)) *)0)->list_node) *__mptr = ((fixup->properties).next
); (typeof(*(fixup_prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(fixup_prop)), list_node)); }); (uintptr_t)fixup_prop
 + (uintptr_t)__builtin_offsetof(typeof(*(fixup_prop)), list_node
); (fixup_prop) = ({ const __typeof__(((typeof(*(fixup_prop))
 *)0)->list_node) *__mptr = ((fixup_prop)->list_node.next
); (typeof(*(fixup_prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(fixup_prop)), list_node)); })) {
struct device_tree_property *base_prop = NULL((void *)0);
list_for_each(prop, node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((node->properties).next); (typeof(*(
prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop))
, list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
	if (!strcmp(prop->prop.name, fixup_prop->prop.name)) {
		base_prop = prop;
		break;
	}

/* We should always find a corresponding base prop for a fixup,
   and fixup props contain a list of 32-bit fixup offsets. */
if (!base_prop || fixup_prop->prop.size % sizeof(uint32_t))
	return -1;

for (i = 0; i < fixup_prop->prop.size; i += sizeof(uint32_t))
	if (!dt_adjust_phandle(base_prop, base, be32dec(
			fixup_prop->prop.data + i)))
		return -1;
}

/* Now recursively descend both the base tree and the /__local_fixups__
  subtree in sync to apply all fixups. */
list_for_each(fixup_child, fixup->children, list_node)for ((fixup_child) = ({ const __typeof__(((typeof(*(fixup_child
)) *)0)->list_node) *__mptr = ((fixup->children).next);
 (typeof(*(fixup_child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(fixup_child)), list_node)); }); (uintptr_t)fixup_child
 + (uintptr_t)__builtin_offsetof(typeof(*(fixup_child)), list_node
); (fixup_child) = ({ const __typeof__(((typeof(*(fixup_child
)) *)0)->list_node) *__mptr = ((fixup_child)->list_node
.next); (typeof(*(fixup_child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(fixup_child)), list_node)); })) {
struct device_tree_node *base_child = NULL((void *)0);
list_for_each(child, node->children, list_node)for ((child) = ({ const __typeof__(((typeof(*(child)) *)0)->
list_node) *__mptr = ((node->children).next); (typeof(*(child
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(child)), list_node
)); }); (uintptr_t)child + (uintptr_t)__builtin_offsetof(typeof
(*(child)), list_node); (child) = ({ const __typeof__(((typeof
(*(child)) *)0)->list_node) *__mptr = ((child)->list_node
.next); (typeof(*(child)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(child)), list_node)); }))
	if (!strcmp(child->name, fixup_child->name)) {
		base_child = child;
		break;
	}

/* All fixup nodes should have a corresponding base node. */
if (!base_child)
	return -1;

if (dt_fixup_locals(base_child, fixup_child, base) < 0)
	return -1;
}

return 0;
1217}

1219/*
* Update all /__symbols__ properties in an overlay that start with
* "/fragment@X/__overlay__" with corresponding path prefix in the base tree.
*
* @param symbols	/__symbols__ done to update.
* @param fragment	/fragment@X node that references to should be updated.
* @param base_path	Path of base tree node that the fragment overlaid.
*/
1227static void dt_fix_symbols(struct device_tree_node *symbols,
	   struct device_tree_node *fragment,
	   const char *base_path)
1230{
struct device_tree_property *prop;
char buf[512]; /* Should be enough for maximum DT path length? */
char node_path[64]; /* easily enough for /fragment@XXXX/__overlay__ */

if (!symbols) /* If the overlay has no /__symbols__ node, we're done! */
return;

int len = snprintf(node_path, sizeof(node_path), "/%s/__overlay__",
	   fragment->name);

list_for_each(prop, symbols->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((symbols->properties).next); (typeof
(*(prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop
)), list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
if (!strncmp(prop->prop.data, node_path, len)) {
	prop->prop.size = snprintf(buf, sizeof(buf), "%s%s",
		base_path, (char *)prop->prop.data + len) + 1;
	free(prop->prop.data);
	prop->prop.data = strdup(buf);
}
1248}

1250/*
* Fix up overlay according to a property in /__fixup__. If the fixed property
* is a /fragment@X:target, also update /__symbols__ references to fragment.
*
* @params overlay	Overlay to fix up.
* @params fixup	/__fixup__ property.
* @params phandle	phandle value to insert where the fixup points to.
* @params base_path	Path to the base DT node that the fixup points to.
* @params overlay_symbols /__symbols__ node of the overlay.
*
* @return		0 on success, -1 on error.
*/
1262static int dt_fixup_external(struct device_tree *overlay,
	     struct device_tree_property *fixup,
	     uint32_t phandle, const char *base_path,
	     struct device_tree_node *overlay_symbols)
1266{
struct device_tree_property *prop;

/* External fixup properties are encoded as "<path>:<prop>:<offset>". */
char *entry = fixup->prop.data;
while ((void *)entry < fixup->prop.data + fixup->prop.size) {
/* okay to destroy fixup property value, won't need it again */
char *node_path = entry;
entry = strchr(node_path, ':');
if (!entry)
	return -1;
*entry++ = '\0';

char *prop_name = entry;
entry = strchr(prop_name, ':');
if (!entry)
	return -1;
*entry++ = '\0';

struct device_tree_node *ovl_node = dt_find_node_by_path(
	overlay, node_path, NULL((void *)0), NULL((void *)0), 0);
if (!ovl_node || !isdigit(*entry))
	return -1;

struct device_tree_property *ovl_prop = NULL((void *)0);
list_for_each(prop, ovl_node->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((ovl_node->properties).next); (typeof
(*(prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop
)), list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
	if (!strcmp(prop->prop.name, prop_name)) {
		ovl_prop = prop;
		break;
	}

/* Move entry to first char after number, must be a '\0'. */
uint32_t offset = skip_atoi(&entry);
if (!ovl_prop || offset + 4 > ovl_prop->prop.size || entry[0])
	return -1;
entry++;  /* jump over '\0' to potential next fixup */

be32enc(ovl_prop->prop.data + offset, phandle);

/* If this is a /fragment@X:target property, update references
   to this fragment in the overlay __symbols__ now. */
if (offset == 0 && !strcmp(prop_name, "target") &&
    !strchr(node_path + 1, '/')) /* only toplevel nodes */
	dt_fix_symbols(overlay_symbols, ovl_node, base_path);
}

return 0;
1313}

1315/*
* Apply all /__fixup__ properties in the overlay. This will destroy the
* property data in /__fixup__ and it should not be accessed again.
*
* @params tree		Base device tree that the overlay updates.
* @params symbols	/__symbols__ node of the base device tree.
* @params overlay	Overlay to fix up.
* @params fixups	/__fixup__ node in the overlay.
* @params overlay_symbols /__symbols__ node of the overlay.
*
* @return		0 on success, -1 on error.
*/
1327static int dt_fixup_all_externals(struct device_tree *tree,
		  struct device_tree_node *symbols,
		  struct device_tree *overlay,
		  struct device_tree_node *fixups,
		  struct device_tree_node *overlay_symbols)
1332{
struct device_tree_property *fix;

/* If we have any external fixups, base tree must have /__symbols__. */
if (!symbols)
return -1;

/*
* Unlike /__local_fixups__, /__fixups__ is not a whole subtree that
* mirrors the node hierarchy. It's just a directory of fixup properties
* that each directly contain all information necessary to apply them.
*/
list_for_each(fix, fixups->properties, list_node)for ((fix) = ({ const __typeof__(((typeof(*(fix)) *)0)->list_node
) *__mptr = ((fixups->properties).next); (typeof(*(fix)) *
)((char *)__mptr - __builtin_offsetof(typeof(*(fix)), list_node
)); }); (uintptr_t)fix + (uintptr_t)__builtin_offsetof(typeof
(*(fix)), list_node); (fix) = ({ const __typeof__(((typeof(*(
fix)) *)0)->list_node) *__mptr = ((fix)->list_node.next
); (typeof(*(fix)) *)((char *)__mptr - __builtin_offsetof(typeof
(*(fix)), list_node)); })) {
/* The name of a fixup property is the label of the node we want
   a property to phandle-reference. Look up in /__symbols__. */
const char *path = dt_find_string_prop(symbols, fix->prop.name);
if (!path)
	return -1;

/* Find node the label pointed to figure out its phandle. */
struct device_tree_node *node = dt_find_node_by_path(tree, path,
	NULL((void *)0), NULL((void *)0), 0);
if (!node)
	return -1;

/* Write into the overlay property(s) pointing to that node. */
if (dt_fixup_external(overlay, fix, node->phandle,
		      path, overlay_symbols) < 0)
	return -1;
}

return 0;
1364}

1366/*
* Copy all nodes and properties from one DT subtree into another. This is a
* shallow copy so both trees will point to the same property data afterwards.
*
* @params dst		Destination subtree to copy into.
* @params src		Source subtree to copy from.
* @params upd		1 to overwrite same-name properties, 0 to discard them.
*/
1374static void dt_copy_subtree(struct device_tree_node *dst,
	    struct device_tree_node *src, int upd)
1376{
struct device_tree_property *prop;
struct device_tree_property *src_prop;
list_for_each(src_prop, src->properties, list_node)for ((src_prop) = ({ const __typeof__(((typeof(*(src_prop)) *
)0)->list_node) *__mptr = ((src->properties).next); (typeof
(*(src_prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*
(src_prop)), list_node)); }); (uintptr_t)src_prop + (uintptr_t
)__builtin_offsetof(typeof(*(src_prop)), list_node); (src_prop
) = ({ const __typeof__(((typeof(*(src_prop)) *)0)->list_node
) *__mptr = ((src_prop)->list_node.next); (typeof(*(src_prop
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(src_prop))
, list_node)); })) {
if (dt_prop_is_phandle(src_prop) ||
    !strcmp(src_prop->prop.name, "name")) {
	printk(BIOS_DEBUG7,
	       "WARNING: ignoring illegal overlay prop '%s'\n",
	       src_prop->prop.name);
	continue;
}

struct device_tree_property *dst_prop = NULL((void *)0);
list_for_each(prop, dst->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((dst->properties).next); (typeof(*(prop
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop)), list_node
)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof(typeof
(*(prop)), list_node); (prop) = ({ const __typeof__(((typeof(
*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node.
next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); }))
	if (!strcmp(prop->prop.name, src_prop->prop.name)) {
		dst_prop = prop;
		break;
	}

if (dst_prop) {
	if (!upd) {
		printk(BIOS_DEBUG7,
		       "WARNING: ignoring prop update '%s'\n",
		       src_prop->prop.name);
		continue;
	}
} else {
	dst_prop = xzalloc(sizeof(*dst_prop))xzalloc_work((sizeof(*dst_prop)), "src/lib/device_tree.c", __func__
, 1403);
	list_insert_after(&dst_prop->list_node,
			  &dst->properties);
}

dst_prop->prop = src_prop->prop;
}

struct device_tree_node *node;
struct device_tree_node *src_node;
list_for_each(src_node, src->children, list_node)for ((src_node) = ({ const __typeof__(((typeof(*(src_node)) *
)0)->list_node) *__mptr = ((src->children).next); (typeof
(*(src_node)) *)((char *)__mptr - __builtin_offsetof(typeof(*
(src_node)), list_node)); }); (uintptr_t)src_node + (uintptr_t
)__builtin_offsetof(typeof(*(src_node)), list_node); (src_node
) = ({ const __typeof__(((typeof(*(src_node)) *)0)->list_node
) *__mptr = ((src_node)->list_node.next); (typeof(*(src_node
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(src_node))
, list_node)); })) {
struct device_tree_node *dst_node = NULL((void *)0);
list_for_each(node, dst->children, list_node)for ((node) = ({ const __typeof__(((typeof(*(node)) *)0)->
list_node) *__mptr = ((dst->children).next); (typeof(*(node
)) *)((char *)__mptr - __builtin_offsetof(typeof(*(node)), list_node
)); }); (uintptr_t)node + (uintptr_t)__builtin_offsetof(typeof
(*(node)), list_node); (node) = ({ const __typeof__(((typeof(
*(node)) *)0)->list_node) *__mptr = ((node)->list_node.
next); (typeof(*(node)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(node)), list_node)); }))
	if (!strcmp(node->name, src_node->name)) {
		dst_node = node;
		break;
	}

if (!dst_node) {
	dst_node = xzalloc(sizeof(*dst_node))xzalloc_work((sizeof(*dst_node)), "src/lib/device_tree.c", __func__
, 1422);
	*dst_node = *src_node;
	list_insert_after(&dst_node->list_node, &dst->children);
} else {
	dt_copy_subtree(dst_node, src_node, upd);
}
}
1429}

1431/*
* Apply an overlay /fragment@X node to a base device tree.
*
* @param tree		Base device tree.
* @param fragment	/fragment@X node.
* @params overlay_symbols /__symbols__ node of the overlay.
*
* @return		0 on success, -1 on error.
*/
1440static int dt_import_fragment(struct device_tree *tree,
	      struct device_tree_node *fragment,
	      struct device_tree_node *overlay_symbols)
1443{
/* The actual overlaid nodes/props are in an __overlay__ child node. */
static const char *overlay_path[] = { "__overlay__", NULL((void *)0) };
struct device_tree_node *overlay = dt_find_node(fragment, overlay_path,
					NULL((void *)0), NULL((void *)0), 0);

/* If it doesn't have an __overlay__ child, it's not a fragment. */
if (!overlay)
return 0;

/* Target node of the fragment can be given by path or by phandle. */
struct device_tree_property *prop;
struct device_tree_property *phandle = NULL((void *)0);
struct device_tree_property *path = NULL((void *)0);
list_for_each(prop, fragment->properties, list_node)for ((prop) = ({ const __typeof__(((typeof(*(prop)) *)0)->
list_node) *__mptr = ((fragment->properties).next); (typeof
(*(prop)) *)((char *)__mptr - __builtin_offsetof(typeof(*(prop
)), list_node)); }); (uintptr_t)prop + (uintptr_t)__builtin_offsetof
(typeof(*(prop)), list_node); (prop) = ({ const __typeof__(((
typeof(*(prop)) *)0)->list_node) *__mptr = ((prop)->list_node
.next); (typeof(*(prop)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(prop)), list_node)); })) {
if (!strcmp(prop->prop.name, "target")) {
	phandle = prop;
	break; /* phandle target has priority, stop looking */
}
if (!strcmp(prop->prop.name, "target-path"))
	path = prop;
}

struct device_tree_node *target = NULL((void *)0);
if (phandle) {
if (phandle->prop.size != sizeof(uint32_t))
	return -1;
target = dt_find_node_by_phandle(tree->root,
				 be32dec(phandle->prop.data));
/* Symbols already updated as part of dt_fixup_external(). */
} else if (path) {
target = dt_find_node_by_path(tree, path->prop.data,
			      NULL((void *)0), NULL((void *)0), 0);
dt_fix_symbols(overlay_symbols, fragment, path->prop.data);
}
if (!target)
return -1;

dt_copy_subtree(target, overlay, 1);
return 0;
1483}

1485/*
* Apply a device tree overlay to a base device tree. This will
* destroy/incorporate the overlay data, so it should not be freed or reused.
* See dtc.git/Documentation/dt-object-internal.txt for overlay format details.
*
* @param tree		Unflattened base device tree to add the overlay into.
* @param overlay	Unflattened overlay device tree to apply to the base.
*
* @return		0 on success, -1 on error.
*/
1495int dt_apply_overlay(struct device_tree *tree, struct device_tree *overlay)
1496{
/*
* First, we need to make sure phandles inside the overlay don't clash
* with those in the base tree. We just define the highest phandle value
* in the base tree as the "phandle offset" for this overlay and
* increment all phandles in it by that value.
*/
uint32_t phandle_base = tree->max_phandle;
uint32_t new_max = dt_adjust_all_phandles(overlay->root, phandle_base);
if (!new_max) {
printk(BIOS_ERR3, "invalid phandles in overlay\n");
return -1;
}
tree->max_phandle = new_max;

/* Now that we changed phandles in the overlay, we need to update any
  nodes referring to them. Those are listed in /__local_fixups__. */
struct device_tree_node *local_fixups = dt_find_node_by_path(overlay,
			"/__local_fixups__", NULL((void *)0), NULL((void *)0), 0);
if (local_fixups && dt_fixup_locals(overlay->root, local_fixups,
			    phandle_base) < 0) {
printk(BIOS_ERR3, "invalid local fixups in overlay\n");
return -1;
}

/*
* Besides local phandle references (from nodes within the overlay to
* other nodes within the overlay), the overlay may also contain phandle
* references to the base tree. These are stored with invalid values and
* must be updated now. /__symbols__ contains a list of all labels in
* the base tree, and /__fixups__ describes all nodes in the overlay
* that contain external phandle references.
* We also take this opportunity to update all /fragment@X/__overlay__/
* prefixes in the overlay's /__symbols__ node to the correct path that
* the fragment will be placed in later, since this is the only step
* where we have all necessary information for that easily available.
*/
struct device_tree_node *symbols = dt_find_node_by_path(tree,
"/__symbols__", NULL((void *)0), NULL((void *)0), 0);
struct device_tree_node *fixups = dt_find_node_by_path(overlay,
"/__fixups__", NULL((void *)0), NULL((void *)0), 0);
struct device_tree_node *overlay_symbols = dt_find_node_by_path(overlay,
"/__symbols__", NULL((void *)0), NULL((void *)0), 0);
if (fixups && dt_fixup_all_externals(tree, symbols, overlay,
			     fixups, overlay_symbols) < 0) {
printk(BIOS_ERR3, "cannot match external fixups from overlay\n");
return -1;
}

/* After all this fixing up, we can finally merge overlay into the tree
  (one fragment at a time, because for some reason it's split up). */
struct device_tree_node *fragment;
list_for_each(fragment, overlay->root->children, list_node)for ((fragment) = ({ const __typeof__(((typeof(*(fragment)) *
)0)->list_node) *__mptr = ((overlay->root->children)
.next); (typeof(*(fragment)) *)((char *)__mptr - __builtin_offsetof
(typeof(*(fragment)), list_node)); }); (uintptr_t)fragment + (
uintptr_t)__builtin_offsetof(typeof(*(fragment)), list_node);
 (fragment) = ({ const __typeof__(((typeof(*(fragment)) *)0)->
list_node) *__mptr = ((fragment)->list_node.next); (typeof
(*(fragment)) *)((char *)__mptr - __builtin_offsetof(typeof(*
(fragment)), list_node)); }))
if (dt_import_fragment(tree, fragment, overlay_symbols) < 0) {
	printk(BIOS_ERR3, "bad DT fragment '%s'\n",
	       fragment->name);
	return -1;
}

/*
* We need to also update /__symbols__ to include labels from this
* overlay, in case we want to load further overlays with external
* phandle references to it. If the base tree already has a /__symbols__
* we merge them together, otherwise we just insert the overlay's
* /__symbols__ node into the base tree root.
*/
if (overlay_symbols) {
if (symbols)
	dt_copy_subtree(symbols, overlay_symbols, 0);
else
	list_insert_after(&overlay_symbols->list_node,
			  &tree->root->children);
}

return 0;
1571}