aboutsummaryrefslogtreecommitdiff
path: root/gnu/packages/patches/dtc-32-bits-check.patch
blob: cf15be3404e047aec0294f9c5e978c8565521fe0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
This fixes tests on 32 bits platforms. Patch taken from upstream.

commit f8872e29ce06d78d3db71b3ab26a7465fc8a9586
Author: David Gibson <david@gibson.dropbear.id.au>
Date:   Fri Oct 6 23:07:30 2017 +1100

    tests: Avoid 64-bit arithmetic in assembler
    
    For testing we (ab)use the assembler to build us a sample dtb, independent
    of the other tools (dtc and libfdt) that we're trying to test.  In a few
    places this uses 64-bit arithmetic to decompose 64-bit constants into
    the individual bytes in the blob.
    
    Unfortunately, it seems that some builds of GNU as don't support >32 bit
    arithmetic, though it's not entirely clear to me which do and which don't
    (Fedora i386 does support 64-bit, Debian arm32 doesn't).
    
    Anyway, to be safe, this avoids 64-bit arithmetic in assembler at the cost
    of some extra awkwardness because we have to define the values in 32-bit
    halves.
    
    Signed-off-by: David Gibson <david@gibson.dropbear.id.au>

diff --git a/tests/testdata.h b/tests/testdata.h
index 3588778..f6bbe1d 100644
--- a/tests/testdata.h
+++ b/tests/testdata.h
@@ -4,15 +4,25 @@
 #define ASM_CONST_LL(x)	(x##ULL)
 #endif
 
-#define TEST_ADDR_1	ASM_CONST_LL(0xdeadbeef00000000)
-#define TEST_SIZE_1	ASM_CONST_LL(0x100000)
-#define TEST_ADDR_2	ASM_CONST_LL(123456789)
-#define TEST_SIZE_2	ASM_CONST_LL(010000)
+#define TEST_ADDR_1H	ASM_CONST_LL(0xdeadbeef)
+#define TEST_ADDR_1L	ASM_CONST_LL(0x00000000)
+#define TEST_ADDR_1	((TEST_ADDR_1H << 32) | TEST_ADDR_1L)
+#define TEST_SIZE_1H	ASM_CONST_LL(0x00000000)
+#define TEST_SIZE_1L	ASM_CONST_LL(0x00100000)
+#define TEST_SIZE_1	((TEST_SIZE_1H << 32) | TEST_SIZE_1L)
+#define TEST_ADDR_2H	ASM_CONST_LL(0)
+#define TEST_ADDR_2L	ASM_CONST_LL(123456789)
+#define TEST_ADDR_2	((TEST_ADDR_2H << 32) | TEST_ADDR_2L)
+#define TEST_SIZE_2H	ASM_CONST_LL(0)
+#define TEST_SIZE_2L	ASM_CONST_LL(010000)
+#define TEST_SIZE_2	((TEST_SIZE_2H << 32) | TEST_SIZE_2L)
 
 #define TEST_VALUE_1	0xdeadbeef
 #define TEST_VALUE_2	123456789
 
-#define TEST_VALUE64_1	ASM_CONST_LL(0xdeadbeef01abcdef)
+#define TEST_VALUE64_1H	ASM_CONST_LL(0xdeadbeef)
+#define TEST_VALUE64_1L	ASM_CONST_LL(0x01abcdef)
+#define TEST_VALUE64_1	((TEST_VALUE64_1H << 32) | TEST_VALUE64_1L)
 
 #define PHANDLE_1	0x2000
 #define PHANDLE_2	0x2001
diff --git a/tests/trees.S b/tests/trees.S
index 9854d1d..9859914 100644
--- a/tests/trees.S
+++ b/tests/trees.S
@@ -7,16 +7,6 @@
 	.byte	((val) >> 8) & 0xff ; \
 	.byte	(val) & 0xff	;
 
-#define FDTQUAD(val) \
-	.byte	((val) >> 56) & 0xff ; \
-	.byte	((val) >> 48) & 0xff ; \
-	.byte	((val) >> 40) & 0xff ; \
-	.byte	((val) >> 32) & 0xff ; \
-	.byte	((val) >> 24) & 0xff ; \
-	.byte	((val) >> 16) & 0xff ; \
-	.byte	((val) >> 8) & 0xff ; \
-	.byte	(val) & 0xff	;
-
 #define TREE_HDR(tree) \
 	.balign	8		; \
 	.globl	_##tree		; \
@@ -33,14 +23,16 @@ tree:	\
 	FDTLONG(tree##_strings_end - tree##_strings) ; \
 	FDTLONG(tree##_struct_end - tree##_struct) ;
 
-#define RSVMAP_ENTRY(addr, len) \
-	FDTQUAD(addr)		; \
-	FDTQUAD(len)		; \
+#define RSVMAP_ENTRY(addrh, addrl, lenh, lenl) \
+	FDTLONG(addrh)		; \
+	FDTLONG(addrl)		; \
+	FDTLONG(lenh)		; \
+	FDTLONG(lenl)
 
 #define EMPTY_RSVMAP(tree) \
 	.balign	8		; \
 tree##_rsvmap:			; \
-	RSVMAP_ENTRY(0, 0) \
+	RSVMAP_ENTRY(0, 0, 0, 0) \
 tree##_rsvmap_end:		;
 
 #define PROPHDR(tree, name, len) \
@@ -52,9 +44,10 @@ tree##_rsvmap_end:		;
 	PROPHDR(tree, name, 4) \
 	FDTLONG(val)		;
 
-#define PROP_INT64(tree, name, val) \
+#define PROP_INT64(tree, name, valh, vall) \
 	PROPHDR(tree, name, 8) \
-	FDTQUAD(val)		;
+	FDTLONG(valh)		; \
+	FDTLONG(vall)		;
 
 #define PROP_STR(tree, name, str) \
 	PROPHDR(tree, name, 55f - 54f) \
@@ -81,16 +74,16 @@ tree##_##name:			; \
 
 	.balign	8
 test_tree1_rsvmap:
-	RSVMAP_ENTRY(TEST_ADDR_1, TEST_SIZE_1)
-	RSVMAP_ENTRY(TEST_ADDR_2, TEST_SIZE_2)
-	RSVMAP_ENTRY(0, 0)
+	RSVMAP_ENTRY(TEST_ADDR_1H, TEST_ADDR_1L, TEST_SIZE_1H, TEST_SIZE_1L)
+	RSVMAP_ENTRY(TEST_ADDR_2H, TEST_ADDR_2L, TEST_SIZE_2H, TEST_SIZE_2L)
+	RSVMAP_ENTRY(0, 0, 0, 0)
 test_tree1_rsvmap_end:
 
 test_tree1_struct:
 	BEGIN_NODE("")
 	PROP_STR(test_tree1, compatible, "test_tree1")
 	PROP_INT(test_tree1, prop_int, TEST_VALUE_1)
-	PROP_INT64(test_tree1, prop_int64, TEST_VALUE64_1)
+	PROP_INT64(test_tree1, prop_int64, TEST_VALUE64_1H, TEST_VALUE64_1L)
 	PROP_STR(test_tree1, prop_str, TEST_STRING_1)
 	PROP_INT(test_tree1, address_cells, 1)
 	PROP_INT(test_tree1, size_cells, 0)