libfdt: use C memmove/memcpy instead of ASM to avoid rebooting

asm memmove() and memcpy() are not reliable yet,
so just use the C analogues for now

lib/libfdt/fdt.c

@@ -334,6 +334,6 @@ int fdt_move(const void *fdt, void *buf, int bufsize)
 	if (fdt_totalsize(fdt) > (unsigned int)bufsize)
 		return -FDT_ERR_NOSPACE;
 
-	memmove(buf, fdt, fdt_totalsize(fdt));
+	__optimized_memmove(buf, fdt, fdt_totalsize(fdt));
 	return 0;
 }

lib/libfdt/fdt_ro.c

@@ -594,7 +594,7 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
 			if (!name)
 				return namelen;
 			if ((p + namelen + 1) <= buflen) {
-				memcpy(buf + p, name, namelen);
+				__optimized_memcpy(buf + p, name, namelen);
 				p += namelen;
 				buf[p++] = '/';
 				pdepth++;

lib/libfdt/fdt_rw.c

@@ -63,7 +63,7 @@ static int fdt_splice_(void *fdt, void *splicepoint, int oldlen, int newlen)
 		return -FDT_ERR_BADOFFSET;
 	if (dsize - oldlen + newlen > fdt_totalsize(fdt))
 		return -FDT_ERR_NOSPACE;
-	memmove(p + newlen, p + oldlen, ((char *)fdt + dsize) - (p + oldlen));
+	__optimized_memmove(p + newlen, p + oldlen, ((char *)fdt + dsize) - (p + oldlen));
 	return 0;
 }
 
@@ -148,7 +148,7 @@ static int fdt_find_add_string_(void *fdt, const char *s, int slen,
 	if (!can_assume(NO_ROLLBACK))
 		*allocated = 1;
 
-	memcpy(new, s, slen);
+	__optimized_memcpy(new, s, slen);
 	new[slen] = '\0';
 
 	return (new - strtab);
@@ -255,7 +255,7 @@ int fdt_set_name(void *fdt, int nodeoffset, const char *name)
 	if (err)
 		return err;
 
-	memcpy(namep, name, newlen+1);
+	__optimized_memcpy(namep, name, newlen+1);
 	return 0;
 }
 
@@ -290,7 +290,7 @@ int fdt_setprop_namelen(void *fdt, int nodeoffset, const char *name,
 		return err;
 
 	if (len)
-		memcpy(prop_data, val, len);
+		__optimized_memcpy(prop_data, val, len);
 	return 0;
 }
 
@@ -311,13 +311,13 @@ int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
 		if (err)
 			return err;
 		prop->len = cpu_to_fdt32(newlen);
-		memcpy(prop->data + oldlen, val, len);
+		__optimized_memcpy(prop->data + oldlen, val, len);
 	} else {
 		err = fdt_add_property_(fdt, nodeoffset, name, strlen(name),
 					len, &prop);
 		if (err)
 			return err;
-		memcpy(prop->data, val, len);
+		__optimized_memcpy(prop->data, val, len);
 	}
 	return 0;
 }
@@ -374,7 +374,7 @@ int fdt_add_subnode_namelen(void *fdt, int parentoffset,
 
 	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
 	memset(nh->name, 0, FDT_TAGALIGN(namelen+1));
-	memcpy(nh->name, name, namelen);
+	__optimized_memcpy(nh->name, name, namelen);
 	endtag = (fdt32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
 	*endtag = cpu_to_fdt32(FDT_END_NODE);
 
@@ -411,14 +411,14 @@ static void fdt_packblocks_(const char *old, char *new,
 	struct_off = mem_rsv_off + mem_rsv_size;
 	strings_off = struct_off + struct_size;
 
-	memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), mem_rsv_size);
+	__optimized_memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), mem_rsv_size);
 	fdt_set_off_mem_rsvmap(new, mem_rsv_off);
 
-	memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);
+	__optimized_memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);
 	fdt_set_off_dt_struct(new, struct_off);
 	fdt_set_size_dt_struct(new, struct_size);
 
-	memmove(new + strings_off, old + fdt_off_dt_strings(old), strings_size);
+	__optimized_memmove(new + strings_off, old + fdt_off_dt_strings(old), strings_size);
 	fdt_set_off_dt_strings(new, strings_off);
 	fdt_set_size_dt_strings(new, fdt_size_dt_strings(old));
 }
@@ -480,7 +480,7 @@ int fdt_open_into(const void *fdt, void *buf, int bufsize)
 
 	fdt_packblocks_(fdt, tmp, mem_rsv_size, struct_size,
 			fdt_size_dt_strings(fdt));
-	memmove(buf, tmp, newsize);
+	__optimized_memmove(buf, tmp, newsize);
 
 	fdt_set_magic(buf, FDT_MAGIC);
 	fdt_set_totalsize(buf, bufsize);

lib/libfdt/fdt_sw.c

@@ -171,11 +171,11 @@ int fdt_resize(void *fdt, void *buf, int bufsize)
 	/* Two cases to avoid clobbering data if the old and new
 	 * buffers partially overlap */
 	if (buf <= fdt) {
-		memmove(buf, fdt, headsize);
-		memmove(newtail, oldtail, tailsize);
+		__optimized_memmove(buf, fdt, headsize);
+		__optimized_memmove(newtail, oldtail, tailsize);
 	} else {
-		memmove(newtail, oldtail, tailsize);
-		memmove(buf, fdt, headsize);
+		__optimized_memmove(newtail, oldtail, tailsize);
+		__optimized_memmove(buf, fdt, headsize);
 	}
 
 	fdt_set_totalsize(buf, bufsize);
@@ -229,7 +229,7 @@ int fdt_begin_node(void *fdt, const char *name)
 		return -FDT_ERR_NOSPACE;
 
 	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
-	memcpy(nh->name, name, namelen);
+	__optimized_memcpy(nh->name, name, namelen);
 	return 0;
 }
 
@@ -259,7 +259,7 @@ static int fdt_add_string_(void *fdt, const char *s)
 	if (fdt_totalsize(fdt) - offset < struct_top)
 		return 0; /* no more room :( */
 
-	memcpy(strtab - offset, s, len);
+	__optimized_memcpy(strtab - offset, s, len);
 	fdt_set_size_dt_strings(fdt, strtabsize + len);
 	return -offset;
 }
@@ -330,7 +330,7 @@ int fdt_property(void *fdt, const char *name, const void *val, int len)
 	ret = fdt_property_placeholder(fdt, name, len, &ptr);
 	if (ret)
 		return ret;
-	memcpy(ptr, val, len);
+	__optimized_memcpy(ptr, val, len);
 	return 0;
 }
 
@@ -353,7 +353,7 @@ int fdt_finish(void *fdt)
 	/* Relocate the string table */
 	oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
 	newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
-	memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
+	__optimized_memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
 	fdt_set_off_dt_strings(fdt, newstroffset);
 
 	/* Walk the structure, correcting string offsets */

lib/libfdt/fdt_wip.c

@@ -26,7 +26,7 @@ int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
 	if ((unsigned)proplen < (len + idx))
 		return -FDT_ERR_NOSPACE;
 
-	memcpy((char *)propval + idx, val, len);
+	__optimized_memcpy((char *)propval + idx, val, len);
 	return 0;
 }
 

lib/unic/string.h

@@ -39,6 +39,29 @@ void *memset (void *m, int c, size_t n);
 /* How many bytes are copied each iteration of the 4X unrolled loop.  */
 #define BIGBLOCKSIZE (sizeof(long) << 2)
 
+static void *__optimized_memmove (void *dst0, const void *src0, size_t len0) __attribute__((unused));
+static void *__optimized_memmove (void *dst0, const void *src0, size_t len0)
+{
+	char *d = dst0;
+	const char *s = src0;
+
+	if (d == s) {
+		return d;
+	}
+
+	if (s > d) {
+		for (size_t i = 0; i < len0; i++) {
+			d[i] = s[i];
+		}
+	} else {
+		for (size_t i = len0; i != 0; i--) {
+			d[i-1] = s[i-1];
+		}
+	}
+
+	return dst0;
+}
+
 static void *__optimized_memcpy (void *dst0, const void *src0, size_t len0) __attribute__((unused));
 static void *__optimized_memcpy (void *dst0, const void *src0, size_t len0)
 {