// SPDX-License-Identifier: GPL-2.0-or-later/* * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005. */ #include "dtc.h"#include "srcpos.h" /* * Tree building functions */ void add_label(struct label **labels, char *label){	struct label *new; 	/* Make sure the label isn't already there */	for_each_label_withdel(*labels, new)		if (streq(new->label, label)) {			new->deleted = 0;			return;		} 	new = xmalloc(sizeof(*new));	memset(new, 0, sizeof(*new));	new->label = label;	new->next = *labels;	*labels = new;} void delete_labels(struct label **labels){	struct label *label; 	for_each_label(*labels, label)		label->deleted = 1;} struct property *build_property(char *name, struct data val,				struct srcpos *srcpos){	struct property *new = xmalloc(sizeof(*new)); 	memset(new, 0, sizeof(*new)); 	new->name = name;	new->val = val;	new->srcpos = srcpos_copy(srcpos); 	return new;} struct property *build_property_delete(char *name){	struct property *new = xmalloc(sizeof(*new)); 	memset(new, 0, sizeof(*new)); 	new->name = name;	new->deleted = 1; 	return new;} struct property *chain_property(struct property *first, struct property *list){	assert(first->next == NULL); 	first->next = list;	return first;} struct property *reverse_properties(struct property *first){	struct property *p = first;	struct property *head = NULL;	struct property *next; 	while (p) {		next = p->next;		p->next = head;		head = p;		p = next;	}	return head;} struct node *build_node(struct property *proplist, struct node *children,			struct srcpos *srcpos){	struct node *new = xmalloc(sizeof(*new));	struct node *child; 	memset(new, 0, sizeof(*new)); 	new->proplist = reverse_properties(proplist);	new->children = children;	new->srcpos = srcpos_copy(srcpos); 	for_each_child(new, child) {		child->parent = new;	} 	return new;} struct node *build_node_delete(struct srcpos *srcpos){	struct node *new = xmalloc(sizeof(*new)); 	memset(new, 0, sizeof(*new)); 	new->deleted = 1;	new->srcpos = srcpos_copy(srcpos); 	return new;} struct node *name_node(struct node *node, char *name){	assert(node->name == NULL); 	node->name = name; 	return node;} struct node *omit_node_if_unused(struct node *node){	node->omit_if_unused = 1; 	return node;} struct node *reference_node(struct node *node){	node->is_referenced = 1; 	return node;} struct node *merge_nodes(struct node *old_node, struct node *new_node){	struct property *new_prop, *old_prop;	struct node *new_child, *old_child;	struct label *l; 	old_node->deleted = 0; 	/* Add new node labels to old node */	for_each_label_withdel(new_node->labels, l)		add_label(&old_node->labels, l->label); 	/* Move properties from the new node to the old node.  If there	 * is a collision, replace the old value with the new */	while (new_node->proplist) {		/* Pop the property off the list */		new_prop = new_node->proplist;		new_node->proplist = new_prop->next;		new_prop->next = NULL; 		if (new_prop->deleted) {			delete_property_by_name(old_node, new_prop->name);			free(new_prop);			continue;		} 		/* Look for a collision, set new value if there is */		for_each_property_withdel(old_node, old_prop) {			if (streq(old_prop->name, new_prop->name)) {				/* Add new labels to old property */				for_each_label_withdel(new_prop->labels, l)					add_label(&old_prop->labels, l->label); 				old_prop->val = new_prop->val;				old_prop->deleted = 0;				free(old_prop->srcpos);				old_prop->srcpos = new_prop->srcpos;				free(new_prop);				new_prop = NULL;				break;			}		} 		/* if no collision occurred, add property to the old node. */		if (new_prop)			add_property(old_node, new_prop);	} 	/* Move the override child nodes into the primary node.  If	 * there is a collision, then merge the nodes. */	while (new_node->children) {		/* Pop the child node off the list */		new_child = new_node->children;		new_node->children = new_child->next_sibling;		new_child->parent = NULL;		new_child->next_sibling = NULL; 		if (new_child->deleted) {			delete_node_by_name(old_node, new_child->name);			free(new_child);			continue;		} 		/* Search for a collision.  Merge if there is */		for_each_child_withdel(old_node, old_child) {			if (streq(old_child->name, new_child->name)) {				merge_nodes(old_child, new_child);				new_child = NULL;				break;			}		} 		/* if no collision occurred, add child to the old node. */		if (new_child)			add_child(old_node, new_child);	} 	old_node->srcpos = srcpos_extend(old_node->srcpos, new_node->srcpos); 	/* The new node contents are now merged into the old node.  Free	 * the new node. */	free(new_node); 	return old_node;} struct node * add_orphan_node(struct node *dt, struct node *new_node, char *ref){	static unsigned int next_orphan_fragment = 0;	struct node *node;	struct property *p;	struct data d = empty_data;	char *name; 	if (ref[0] == '/') {		d = data_add_marker(d, TYPE_STRING, ref);		d = data_append_data(d, ref, strlen(ref) + 1); 		p = build_property("target-path", d, NULL);	} else {		d = data_add_marker(d, REF_PHANDLE, ref);		d = data_append_integer(d, 0xffffffff, 32); 		p = build_property("target", d, NULL);	} 	xasprintf(&name, "fragment@%u",			next_orphan_fragment++);	name_node(new_node, "__overlay__");	node = build_node(p, new_node, NULL);	name_node(node, name); 	add_child(dt, node);	return dt;} struct node *chain_node(struct node *first, struct node *list){	assert(first->next_sibling == NULL); 	first->next_sibling = list;	return first;} void add_property(struct node *node, struct property *prop){	struct property **p; 	prop->next = NULL; 	p = &node->proplist;	while (*p)		p = &((*p)->next); 	*p = prop;} void delete_property_by_name(struct node *node, char *name){	struct property *prop = node->proplist; 	while (prop) {		if (streq(prop->name, name)) {			delete_property(prop);			return;		}		prop = prop->next;	}} void delete_property(struct property *prop){	prop->deleted = 1;	delete_labels(&prop->labels);} void add_child(struct node *parent, struct node *child){	struct node **p; 	child->next_sibling = NULL;	child->parent = parent; 	p = &parent->children;	while (*p)		p = &((*p)->next_sibling); 	*p = child;} void delete_node_by_name(struct node *parent, char *name){	struct node *node = parent->children; 	while (node) {		if (streq(node->name, name)) {			delete_node(node);			return;		}		node = node->next_sibling;	}} void delete_node(struct node *node){	struct property *prop;	struct node *child; 	node->deleted = 1;	for_each_child(node, child)		delete_node(child);	for_each_property(node, prop)		delete_property(prop);	delete_labels(&node->labels);} void append_to_property(struct node *node,			char *name, const void *data, int len,			enum markertype type){	struct data d;	struct property *p; 	p = get_property(node, name);	if (p) {		d = data_add_marker(p->val, type, name);		d = data_append_data(d, data, len);		p->val = d;	} else {		d = data_add_marker(empty_data, type, name);		d = data_append_data(d, data, len);		p = build_property(name, d, NULL);		add_property(node, p);	}} struct reserve_info *build_reserve_entry(uint64_t address, uint64_t size){	struct reserve_info *new = xmalloc(sizeof(*new)); 	memset(new, 0, sizeof(*new)); 	new->address = address;	new->size = size; 	return new;} struct reserve_info *chain_reserve_entry(struct reserve_info *first,					struct reserve_info *list){	assert(first->next == NULL); 	first->next = list;	return first;} struct reserve_info *add_reserve_entry(struct reserve_info *list,				      struct reserve_info *new){	struct reserve_info *last; 	new->next = NULL; 	if (! list)		return new; 	for (last = list; last->next; last = last->next)		; 	last->next = new; 	return list;} struct dt_info *build_dt_info(unsigned int dtsflags,			      struct reserve_info *reservelist,			      struct node *tree, uint32_t boot_cpuid_phys){	struct dt_info *dti; 	dti = xmalloc(sizeof(*dti));	dti->dtsflags = dtsflags;	dti->reservelist = reservelist;	dti->dt = tree;	dti->boot_cpuid_phys = boot_cpuid_phys; 	return dti;} /* * Tree accessor functions */ const char *get_unitname(struct node *node){	if (node->name[node->basenamelen] == '\0')		return "";	else		return node->name + node->basenamelen + 1;} struct property *get_property(struct node *node, const char *propname){	struct property *prop; 	for_each_property(node, prop)		if (streq(prop->name, propname))			return prop; 	return NULL;} cell_t propval_cell(struct property *prop){	assert(prop->val.len == sizeof(cell_t));	return fdt32_to_cpu(*((fdt32_t *)prop->val.val));} cell_t propval_cell_n(struct property *prop, unsigned int n){	assert(prop->val.len / sizeof(cell_t) >= n);	return fdt32_to_cpu(*((fdt32_t *)prop->val.val + n));} struct property *get_property_by_label(struct node *tree, const char *label,				       struct node **node){	struct property *prop;	struct node *c; 	*node = tree; 	for_each_property(tree, prop) {		struct label *l; 		for_each_label(prop->labels, l)			if (streq(l->label, label))				return prop;	} 	for_each_child(tree, c) {		prop = get_property_by_label(c, label, node);		if (prop)			return prop;	} 	*node = NULL;	return NULL;} struct marker *get_marker_label(struct node *tree, const char *label,				struct node **node, struct property **prop){	struct marker *m;	struct property *p;	struct node *c; 	*node = tree; 	for_each_property(tree, p) {		*prop = p;		m = p->val.markers;		for_each_marker_of_type(m, LABEL)			if (streq(m->ref, label))				return m;	} 	for_each_child(tree, c) {		m = get_marker_label(c, label, node, prop);		if (m)			return m;	} 	*prop = NULL;	*node = NULL;	return NULL;} 

Lines 1–500 of 1032. Load more