add boot partition size

hc

2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d

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
# HG changeset patch
# User Lars T Hansen <lhansen@mozilla.com>
# Date 1538489772 -7200
# Node ID bb430eaf5521aa8ab233a45b585ff9e5dfecf4c9
# Parent  e87d7028568e721e8d297ce62f9622e74d29bb37
Bug 1495731 - remove JS_VOLATILE_ARM, it is no longer relevant.  r=waldo
 
JS_VOLATILE_ARM was a workaround for a gcc 4.7 bug on B2G where it
would generate unaligned word accesses that should have been
individual byte accesses.  We now require at least gcc 6.1 (and ARM
systems support unaligned accesses).
 
Signed-off-by: Khem Raj <raj.khem@gmail.com>
Upstream-Status: Backport [https://hg.mozilla.org/integration/mozilla-inbound/rev/bb430eaf5521]
 
--- a/js/src/vm/TypedArrayObject-inl.h
+++ b/js/src/vm/TypedArrayObject-inl.h
@@ -259,68 +259,61 @@ class ElementSpecific {
       return true;
     }
 
-      // Inhibit unaligned accesses on ARM (bug 1097253, a compiler bug).
-#if defined(__arm__) && defined(__GNUC__) && !defined(__clang__)
-#define JS_VOLATILE_ARM volatile
-#else
-#define JS_VOLATILE_ARM
-#endif
-
     SharedMem<void*> data = Ops::extract(source);
     switch (source->type()) {
       case Scalar::Int8: {
-        SharedMem<JS_VOLATILE_ARM int8_t*> src =
-            data.cast<JS_VOLATILE_ARM int8_t*>();
+        SharedMem<int8_t*> src =
+            data.cast<int8_t*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
       }
       case Scalar::Uint8:
       case Scalar::Uint8Clamped: {
-        SharedMem<JS_VOLATILE_ARM uint8_t*> src =
-            data.cast<JS_VOLATILE_ARM uint8_t*>();
+        SharedMem<uint8_t*> src =
+            data.cast<uint8_t*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
       }
       case Scalar::Int16: {
-        SharedMem<JS_VOLATILE_ARM int16_t*> src =
-            data.cast<JS_VOLATILE_ARM int16_t*>();
+        SharedMem<int16_t*> src =
+            data.cast<int16_t*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
       }
       case Scalar::Uint16: {
-        SharedMem<JS_VOLATILE_ARM uint16_t*> src =
-            data.cast<JS_VOLATILE_ARM uint16_t*>();
+        SharedMem<uint16_t*> src =
+            data.cast<uint16_t*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
       }
       case Scalar::Int32: {
-        SharedMem<JS_VOLATILE_ARM int32_t*> src =
-            data.cast<JS_VOLATILE_ARM int32_t*>();
+        SharedMem<int32_t*> src =
+            data.cast<int32_t*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
       }
       case Scalar::Uint32: {
-        SharedMem<JS_VOLATILE_ARM uint32_t*> src =
-            data.cast<JS_VOLATILE_ARM uint32_t*>();
+        SharedMem<uint32_t*> src =
+            data.cast<uint32_t*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
       }
       case Scalar::Float32: {
-        SharedMem<JS_VOLATILE_ARM float*> src =
-            data.cast<JS_VOLATILE_ARM float*>();
+        SharedMem<float*> src =
+            data.cast<float*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
       }
       case Scalar::Float64: {
-        SharedMem<JS_VOLATILE_ARM double*> src =
-            data.cast<JS_VOLATILE_ARM double*>();
+        SharedMem<double*> src =
+            data.cast<double*>();
         for (uint32_t i = 0; i < count; ++i)
           Ops::store(dest++, ConvertNumber<T>(Ops::load(src++)));
         break;
@@ -329,8 +322,6 @@ class ElementSpecific {
         MOZ_CRASH("setFromTypedArray with a typed array with bogus type");
     }
 
-#undef JS_VOLATILE_ARM
-
     return true;
   }