[patch] chromium-system_icu_array_size_calculation_minimalistic_fix.patch

chromium-system_icu_array_size_calculation_minimalistic_fix.patch (text/plain), 7.23 KB, created by Arfrever Frehtes Taifersar Arahesis on 2018-10-17 00:54:17 UTC

Chromium contains at least 3 ways of array size calculation:

base/macros.h contains:
[[[
// The arraysize(arr) macro returns the # of elements in an array arr.  The
// expression is a compile-time constant, and therefore can be used in defining
// new arrays, for example.  If you use arraysize on a pointer by mistake, you
// will get a compile-time error.  For the technical details, refer to
// http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx.

// This template function declaration is used in defining arraysize.
// Note that the function doesn't need an implementation, as we only
// use its type.
//
// DEPRECATED, please use base::size(array) instead.
// TODO(https://crbug.com/837308): Replace existing arraysize usages.
template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
#define arraysize(array) (sizeof(ArraySizeHelper(array)))
]]]

base/stl_util.h contains:
[[[
template <typename T, size_t N>
constexpr size_t size(const T (&array)[N]) noexcept {
  return N;
}
]]]

third_party/blink/renderer/platform/text/character_property_data_generator.cc contains:
[[[
#define ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))
]]]


In C++, zero-length arrays can be defined, but some operations on them are not permitted
(by either Clang or GCC, even in GNU mode (-std=gnu++...)):
[[[
$ cat test.h
#include <cstddef>

template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
#define arraysize(array) (sizeof(ArraySizeHelper(array)))

template <typename T, size_t N>
constexpr size_t size(const T (&array)[N]) noexcept {
  return N;
}

#define ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))

int non_empty_array[] = {1, 3, 5, 7, 9};
int empty_array[] = {};
$ cat test_arraysize_1.cpp
#include "test.h"

int main() {
  size_t x = arraysize(non_empty_array);
}
$ cat test_arraysize_2.cpp
#include "test.h"

int main() {
  size_t x = arraysize(empty_array);
}
$ cat test_size_1.cpp
#include "test.h"

int main() {
  size_t x = size(non_empty_array);
}
$ cat test_size_2.cpp
#include "test.h"

int main() {
  size_t x = size(empty_array);
}
$ cat test_ARRAY_LENGTH_1.cpp
#include "test.h"

int main() {
  size_t x = ARRAY_LENGTH(non_empty_array);
}
$ cat test_ARRAY_LENGTH_2.cpp
#include "test.h"

int main() {
  size_t x = ARRAY_LENGTH(empty_array);
}
$ g++-8.2.0 -std=gnu++17 test_arraysize_1.cpp
$ clang++-7 -std=gnu++17 test_arraysize_1.cpp
$ g++-8.2.0 -std=gnu++17 test_arraysize_2.cpp
In file included from test_arraysize_2.cpp:1:
test_arraysize_2.cpp: In function ‘int main()’:
test.h:4:55: error: no matching function for call to ‘ArraySizeHelper(int [0])’
 #define arraysize(array) (sizeof(ArraySizeHelper(array)))
                                                       ^
test_arraysize_2.cpp:4:14: note: in expansion of macro ‘arraysize’
   size_t x = arraysize(empty_array);
              ^~~~~~~~~
test.h:3:40: note: candidate: ‘template<class T, long unsigned int N> char (& ArraySizeHelper(T (&)[N]))[N]’
 template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
                                        ^~~~~~~~~~~~~~~
test.h:3:40: note:   template argument deduction/substitution failed:
$ clang++-7 -std=gnu++17 test_arraysize_2.cpp
test_arraysize_2.cpp:4:14: error: no matching function for call to 'ArraySizeHelper'
  size_t x = arraysize(empty_array);
             ^~~~~~~~~~~~~~~~~~~~~~
./test.h:4:34: note: expanded from macro 'arraysize'
#define arraysize(array) (sizeof(ArraySizeHelper(array)))
                                 ^~~~~~~~~~~~~~~
./test.h:3:40: note: candidate template ignored: substitution failure [with T = int, N = 0]: zero-length arrays are not permitted in C++
template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
                                       ^                               ~
1 error generated.
$ g++-8.2.0 -std=gnu++17 test_size_1.cpp
$ clang++-7 -std=gnu++17 test_size_1.cpp
$ g++-8.2.0 -std=gnu++17 test_size_2.cpp
test_size_2.cpp: In function ‘int main()’:
test_size_2.cpp:4:30: error: no matching function for call to ‘size(int [0])’
   size_t x = size(empty_array);
                              ^
In file included from test_size_2.cpp:1:
test.h:7:18: note: candidate: ‘template<class T, long unsigned int N> constexpr size_t size(const T (&)[N])’
 constexpr size_t size(const T (&array)[N]) noexcept {
                  ^~~~
test.h:7:18: note:   template argument deduction/substitution failed:
$ clang++-7 -std=gnu++17 test_size_2.cpp
test_size_2.cpp:4:14: error: no matching function for call to 'size'
  size_t x = size(empty_array);
             ^~~~
./test.h:7:18: note: candidate template ignored: substitution failure [with T = int, N = 0]: zero-length arrays are not permitted in C++
constexpr size_t size(const T (&array)[N]) noexcept {
                 ^                     ~
1 error generated.
$ g++-8.2.0 -std=gnu++17 test_ARRAY_LENGTH_1.cpp
$ clang++-7 -std=gnu++17 test_ARRAY_LENGTH_1.cpp
$ g++-8.2.0 -std=gnu++17 test_ARRAY_LENGTH_2.cpp
$ clang++-7 -std=gnu++17 test_ARRAY_LENGTH_2.cpp
]]]

As seen above, arraysize() and size() work with non-zero-length arrays and fail with zero-length arrays,
while ARRAY_LENGTH() works with both non-zero-length arrays and zero-length arrays.


third_party/blink/renderer/platform/text/character_property_data_generator.h defines several arrays.
kIsHangulArray is a zero-length array.

When Chromium is being built with bundled ICU, then array size calculation occurs in
third_party/blink/renderer/platform/text/character_property_data_generator.cc in Generate() function,
which (through SET macro) uses ARRAY_LENGTH(), which works with zero-length arrays.

When Chromium is being built with system ICU, then array size calculation occurs in
third_party/blink/renderer/platform/text/character.cc in several functions,
which (through RETURN_HAS_PROPERTY and CREATE_UNICODE_SET macros) use arraysize(), which fails with zero-length arrays.

The minimalistic fix is to make third_party/blink/renderer/platform/text/character.cc also use ARRAY_LENGTH() instead of arraysize().

--- /third_party/blink/renderer/platform/text/character.cc
+++ /third_party/blink/renderer/platform/text/character.cc
@@ -61,9 +61,13 @@
   return unicodeSet;
 }
 
-#define CREATE_UNICODE_SET(name)                                      \
-  createUnicodeSet(name##Array, arraysize(name##Array), name##Ranges, \
-                   arraysize(name##Ranges))
+// arraysize (from base/macros.h) and base::size (from base/stl_util.h)
+// cause compilation errors with zero-length arrays.
+#define ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))
+
+#define CREATE_UNICODE_SET(name)                             \
+  createUnicodeSet(name##Array, ARRAY_LENGTH(name##Array),   \
+                   name##Ranges, ARRAY_LENGTH(name##Ranges))
 
 #define RETURN_HAS_PROPERTY(c, name)            \
   static icu::UnicodeSet* unicodeSet = nullptr; \
--- /third_party/blink/renderer/platform/text/character_property_data_generator.cc
+++ /third_party/blink/renderer/platform/text/character_property_data_generator.cc
@@ -21,6 +21,8 @@
 #else
 
 const UChar32 kMaxCodepoint = 0x10FFFF;
+// arraysize (from base/macros.h) and base::size (from base/stl_util.h)
+// cause compilation errors with zero-length arrays.
 #define ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))
 
 static void SetRanges(CharacterProperty* values,