Changeset 65311 in webkit for trunk/JavaScriptCore

Timestamp:

Aug 13, 2010, 3:14:36 AM (15 years ago)

Author:

[email protected]

Message:

Avoid increasing required alignment of target type warning on ARM
​https://bugs.webkit.org/show_bug.cgi?id=38045

Reviewed by Gavin Barraclough.

The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where
sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM:
increases required alignment of target type warnings.
Casting the type of [pointer to Type2] object to void* bypasses the
warning.

• JavaScriptCore/assembler/ARMAssembler.cpp:

(JSC::ARMAssembler::executableCopy):

• JavaScriptCore/assembler/AssemblerBuffer.h:

(JSC::AssemblerBuffer::putShortUnchecked):
(JSC::AssemblerBuffer::putIntUnchecked):
(JSC::AssemblerBuffer::putInt64Unchecked):

• JavaScriptCore/interpreter/RegisterFile.h:

(JSC::RegisterFile::RegisterFile):
(JSC::RegisterFile::grow):

• JavaScriptCore/jit/JITStubs.cpp:
• JavaScriptCore/pcre/pcre_compile.cpp:

(jsRegExpCompile):

• JavaScriptCore/runtime/JSArray.cpp:

(JSC::JSArray::putSlowCase):
(JSC::JSArray::increaseVectorLength):
(JSC::JSArray::increaseVectorPrefixLength):
(JSC::JSArray::shiftCount):
(JSC::JSArray::unshiftCount):

• JavaScriptCore/wtf/FastMalloc.cpp:

(WTF::PageHeapAllocator::New):
(WTF::TCMalloc_Central_FreeList::Populate):

• wtf/MD5.cpp:

(WTF::reverseBytes):
(WTF::MD5::addBytes):
(WTF::MD5::checksum):

• JavaScriptCore/wtf/StdLibExtras.h:

(isPointerTypeAlignmentOkay):
(reinterpret_cast_ptr):

• JavaScriptCore/wtf/Vector.h:

(WTF::VectorBuffer::inlineBuffer):

• JavaScriptCore/wtf/qt/StringQt.cpp:

(WTF::String::String):

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• assembler/ARMAssembler.cpp (modified) (1 diff)
• assembler/AssemblerBuffer.h (modified) (4 diffs)
• interpreter/RegisterFile.h (modified) (2 diffs)
• jit/JITStubs.cpp (modified) (2 diffs)
• pcre/pcre_compile.cpp (modified) (2 diffs)
• runtime/JSArray.cpp (modified) (5 diffs)
• wtf/FastMalloc.cpp (modified) (3 diffs)
• wtf/MD5.cpp (modified) (6 diffs)
• wtf/StdLibExtras.h (modified) (1 diff)
• wtf/Vector.h (modified) (2 diffs)
• wtf/qt/StringQt.cpp (modified) (3 diffs)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2010-08-13  Gabor Loki  <[email protected]>
+
+        Reviewed by Gavin Barraclough.
+
+        Avoid increasing required alignment of target type warning on ARM
+        https://bugs.webkit.org/show_bug.cgi?id=38045
+
+        The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where
+        sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM:
+        increases required alignment of target type warnings.
+        Casting the type of [pointer to Type2] object to void* bypasses the
+        warning.
+
+        * assembler/ARMAssembler.cpp:
+        (JSC::ARMAssembler::executableCopy):
+        * assembler/AssemblerBuffer.h:
+        (JSC::AssemblerBuffer::putShortUnchecked):
+        (JSC::AssemblerBuffer::putIntUnchecked):
+        (JSC::AssemblerBuffer::putInt64Unchecked):
+        * interpreter/RegisterFile.h:
+        (JSC::RegisterFile::RegisterFile):
+        (JSC::RegisterFile::grow):
+        * jit/JITStubs.cpp:
+        * pcre/pcre_compile.cpp:
+        (jsRegExpCompile):
+        * runtime/JSArray.cpp:
+        (JSC::JSArray::putSlowCase):
+        (JSC::JSArray::increaseVectorLength):
+        (JSC::JSArray::increaseVectorPrefixLength):
+        (JSC::JSArray::shiftCount):
+        (JSC::JSArray::unshiftCount):
+        * wtf/FastMalloc.cpp:
+        (WTF::PageHeapAllocator::New):
+        (WTF::TCMalloc_Central_FreeList::Populate):
+        * wtf/MD5.cpp:
+        (WTF::reverseBytes):
+        (WTF::MD5::addBytes):
+        (WTF::MD5::checksum):
+        * wtf/StdLibExtras.h:
+        (isPointerTypeAlignmentOkay):
+        (reinterpret_cast_ptr):
+        * wtf/Vector.h:
+        (WTF::VectorBuffer::inlineBuffer):
+        * wtf/qt/StringQt.cpp:
+        (WTF::String::String):
+
 2010-08-13  Gavin Barraclough  <[email protected]>
 

trunk/JavaScriptCore/assembler/ARMAssembler.cpp

@@ -358 +358 @@
         // The last bit is set if the constant must be placed on constant pool.
         int pos = (*iter) & (~0x1);
-        ARMWord* ldrAddr = reinterpret_cast<ARMWord*>(data + pos);
+        ARMWord* ldrAddr = reinterpret_cast_ptr<ARMWord*>(data + pos);
         ARMWord* addr = getLdrImmAddress(ldrAddr);
         if (*addr != InvalidBranchTarget) {
             if (!(*iter & 1)) {
-                int diff = reinterpret_cast<ARMWord*>(data + *addr) - (ldrAddr + DefaultPrefetching);
+                int diff = reinterpret_cast_ptr<ARMWord*>(data + *addr) - (ldrAddr + DefaultPrefetching);
 
                 if ((diff <= BOFFSET_MAX && diff >= BOFFSET_MIN)) {

trunk/JavaScriptCore/assembler/AssemblerBuffer.h

@@ -34 +34 @@
 #include <wtf/Assertions.h>
 #include <wtf/FastMalloc.h>
+#include <wtf/StdLibExtras.h>
 
 namespace JSC {
@@ -82 +83 @@
         {
             ASSERT(!(m_size > m_capacity - 4));
-            *reinterpret_cast<short*>(&m_buffer[m_size]) = value;
+            *reinterpret_cast_ptr<short*>(&m_buffer[m_size]) = value;
             m_size += 2;
         }
@@ -96 +97 @@
         {
             ASSERT(!(m_size > m_capacity - 4));
-            *reinterpret_cast<int*>(&m_buffer[m_size]) = value;
+            *reinterpret_cast_ptr<int*>(&m_buffer[m_size]) = value;
             m_size += 4;
         }
@@ -103 +104 @@
         {
             ASSERT(!(m_size > m_capacity - 8));
-            *reinterpret_cast<int64_t*>(&m_buffer[m_size]) = value;
+            *reinterpret_cast_ptr<int64_t*>(&m_buffer[m_size]) = value;
             m_size += 8;
         }

trunk/JavaScriptCore/interpreter/RegisterFile.h

@@ -167 +167 @@
         size_t committedSize = roundUpAllocationSize(maxGlobals * sizeof(Register), commitSize);
         checkAllocatedOkay(m_reservation.commit(base, committedSize));
-        m_commitEnd = reinterpret_cast<Register*>(reinterpret_cast<char*>(base) + committedSize);
+        m_commitEnd = reinterpret_cast_ptr<Register*>(reinterpret_cast<char*>(base) + committedSize);
         m_start = static_cast<Register*>(base) + maxGlobals;
         m_end = m_start;
@@ -194 +194 @@
             size_t size = roundUpAllocationSize(reinterpret_cast<char*>(newEnd) - reinterpret_cast<char*>(m_commitEnd), commitSize);
             checkAllocatedOkay(m_reservation.commit(m_commitEnd, size));
-            m_commitEnd = reinterpret_cast<Register*>(reinterpret_cast<char*>(m_commitEnd) + size);
+            m_commitEnd = reinterpret_cast_ptr<Register*>(reinterpret_cast<char*>(m_commitEnd) + size);
         }
 

trunk/JavaScriptCore/jit/JITStubs.cpp

@@ -968 +968 @@
 };
 
-#define STUB_INIT_STACK_FRAME(stackFrame) JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS); StackHack stackHack(stackFrame)
+#define STUB_INIT_STACK_FRAME(stackFrame) JITStackFrame& stackFrame = *reinterpret_cast_ptr<JITStackFrame*>(STUB_ARGS); StackHack stackHack(stackFrame)
 #define STUB_SET_RETURN_ADDRESS(returnAddress) stackHack.savedReturnAddress = ReturnAddressPtr(returnAddress)
 #define STUB_RETURN_ADDRESS stackHack.savedReturnAddress
@@ -974 +974 @@
 #else
 
-#define STUB_INIT_STACK_FRAME(stackFrame) JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS)
+#define STUB_INIT_STACK_FRAME(stackFrame) JITStackFrame& stackFrame = *reinterpret_cast_ptr<JITStackFrame*>(STUB_ARGS)
 #define STUB_SET_RETURN_ADDRESS(returnAddress) *stackFrame.returnAddressSlot() = ReturnAddressPtr(returnAddress)
 #define STUB_RETURN_ADDRESS *stackFrame.returnAddressSlot()

trunk/JavaScriptCore/pcre/pcre_compile.cpp

@@ -50 +50 @@
 #include <wtf/FastMalloc.h>
 #include <wtf/FixedArray.h>
+#include <wtf/StdLibExtras.h>
 
 using namespace WTF;
@@ -2591 +2592 @@
     size = stringOffset + patternLength * sizeof(UChar);
 #endif
-    JSRegExp* re = reinterpret_cast<JSRegExp*>(new char[size]);
+    JSRegExp* re = reinterpret_cast_ptr<JSRegExp*>(new char[size]);
     
     if (!re)

trunk/JavaScriptCore/runtime/JSArray.cpp

@@ -442 +442 @@
     }
 
-    m_storage = reinterpret_cast<ArrayStorage*>(static_cast<char*>(baseStorage) + m_indexBias * sizeof(JSValue));
+    m_storage = reinterpret_cast_ptr<ArrayStorage*>(static_cast<char*>(baseStorage) + m_indexBias * sizeof(JSValue));
     m_storage->m_allocBase = baseStorage;
     storage = m_storage;
@@ -592 +592 @@
         return false;
 
-    storage = m_storage = reinterpret_cast<ArrayStorage*>(static_cast<char*>(baseStorage) + m_indexBias * sizeof(JSValue));
+    storage = m_storage = reinterpret_cast_ptr<ArrayStorage*>(static_cast<char*>(baseStorage) + m_indexBias * sizeof(JSValue));
     m_storage->m_allocBase = baseStorage;
 
@@ -624 +624 @@
     m_indexBias += newVectorLength - newLength;
     
-    m_storage = reinterpret_cast<ArrayStorage*>(static_cast<char*>(newBaseStorage) + m_indexBias * sizeof(JSValue));
+    m_storage = reinterpret_cast_ptr<ArrayStorage*>(static_cast<char*>(newBaseStorage) + m_indexBias * sizeof(JSValue));
 
     memcpy(m_storage, storage, storageSize(0));
@@ -803 +803 @@
             char* newBaseStorage = reinterpret_cast<char*>(storage) + count * sizeof(JSValue);
             memmove(newBaseStorage, storage, storageSize(0));
-            m_storage = reinterpret_cast<ArrayStorage*>(newBaseStorage);
+            m_storage = reinterpret_cast_ptr<ArrayStorage*>(newBaseStorage);
 
             m_indexBias += count;
@@ -840 +840 @@
         char* newBaseStorage = reinterpret_cast<char*>(storage) - count * sizeof(JSValue);
         memmove(newBaseStorage, storage, storageSize(0));
-        m_storage = reinterpret_cast<ArrayStorage*>(newBaseStorage);
+        m_storage = reinterpret_cast_ptr<ArrayStorage*>(newBaseStorage);
         m_vectorLength += count;
     } else if (!increaseVectorPrefixLength(m_vectorLength + count)) {

trunk/JavaScriptCore/wtf/FastMalloc.cpp

@@ -83 +83 @@
 #include <pthread.h>
 #endif
+#include <wtf/StdLibExtras.h>
 
 #ifndef NO_TCMALLOC_SAMPLES
@@ -1018 +1019 @@
           CRASH();
 
-        *(void**)new_allocation = allocated_regions_;
+        *reinterpret_cast_ptr<void**>(new_allocation) = allocated_regions_;
         allocated_regions_ = new_allocation;
         free_area_ = new_allocation + kAlignedSize;
@@ -2719 +2720 @@
   while ((nptr = ptr + size) <= limit) {
     *tail = ptr;
-    tail = reinterpret_cast<void**>(ptr);
+    tail = reinterpret_cast_ptr<void**>(ptr);
     ptr = nptr;
     num++;

trunk/JavaScriptCore/wtf/MD5.cpp

@@ -55 +55 @@
 #include "text/CString.h"
 #endif
+#include <wtf/StdLibExtras.h>
 
 namespace WTF {
@@ -104 +105 @@
         uint32_t t = static_cast<uint32_t>(buf[3] << 8 | buf[2]) << 16 | buf[1] << 8 | buf[0];
         ASSERT_WITH_MESSAGE(!(reinterpret_cast<uintptr_t>(buf) % sizeof(t)), "alignment error of buf");
-        *reinterpret_cast<uint32_t *>(buf) = t;
+        *reinterpret_cast_ptr<uint32_t *>(buf) = t;
         buf += 4;
     } while (--longs);
@@ -239 +240 @@
         memcpy(p, buf, t);
         reverseBytes(m_in, 16);
-        MD5Transform(m_buf, reinterpret_cast<uint32_t*>(m_in)); // m_in is 4-byte aligned.
+        MD5Transform(m_buf, reinterpret_cast_ptr<uint32_t*>(m_in)); // m_in is 4-byte aligned.
         buf += t;
         length -= t;
@@ -249 +250 @@
         memcpy(m_in, buf, 64);
         reverseBytes(m_in, 16);
-        MD5Transform(m_buf, reinterpret_cast<uint32_t*>(m_in)); // m_in is 4-byte aligned.
+        MD5Transform(m_buf, reinterpret_cast_ptr<uint32_t*>(m_in)); // m_in is 4-byte aligned.
         buf += 64;
         length -= 64;
@@ -276 +277 @@
         memset(p, 0, count);
         reverseBytes(m_in, 16);
-        MD5Transform(m_buf, reinterpret_cast<uint32_t *>(m_in)); // m_in is 4-byte aligned.
+        MD5Transform(m_buf, reinterpret_cast_ptr<uint32_t *>(m_in)); // m_in is 4-byte aligned.
 
         // Now fill the next block with 56 bytes
@@ -288 +289 @@
     // Append length in bits and transform
     // m_in is 4-byte aligned.
-    (reinterpret_cast<uint32_t*>(m_in))[14] = m_bits[0];
-    (reinterpret_cast<uint32_t*>(m_in))[15] = m_bits[1];
-
-    MD5Transform(m_buf, reinterpret_cast<uint32_t*>(m_in));
+    (reinterpret_cast_ptr<uint32_t*>(m_in))[14] = m_bits[0];
+    (reinterpret_cast_ptr<uint32_t*>(m_in))[15] = m_bits[1];
+
+    MD5Transform(m_buf, reinterpret_cast_ptr<uint32_t*>(m_in));
     reverseBytes(reinterpret_cast<uint8_t*>(m_buf), 4);
 

trunk/JavaScriptCore/wtf/StdLibExtras.h

@@ -52 +52 @@
 #define STRINGIZE_VALUE_OF(exp) STRINGIZE(exp)
 
+/*
+ * The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where
+ * sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM with GCC:
+ * increases required alignment of target type.
+ *
+ * An implicit or an extra static_cast<void*> bypasses the warning.
+ * For more info see the following bugzilla entries:
+ * - https://bugs.webkit.org/show_bug.cgi?id=38045
+ * - http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43976
+ */
+#if CPU(ARM) && COMPILER(GCC)
+template<typename Type>
+bool isPointerTypeAlignmentOkay(Type* ptr)
+{
+    return !(reinterpret_cast<intptr_t>(ptr) % __alignof__(Type));
+}
+
+template<typename TypePtr>
+TypePtr reinterpret_cast_ptr(void* ptr)
+{
+    ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
+    return reinterpret_cast<TypePtr>(ptr);
+}
+
+template<typename TypePtr>
+TypePtr reinterpret_cast_ptr(const void* ptr)
+{
+    ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
+    return reinterpret_cast<TypePtr>(ptr);
+}
+#else
+#define reinterpret_cast_ptr reinterpret_cast
+#endif
+
 namespace WTF {
 

trunk/JavaScriptCore/wtf/Vector.h

@@ -25 +25 @@
 #include "Noncopyable.h"
 #include "NotFound.h"
+#include "StdLibExtras.h"
 #include "ValueCheck.h"
 #include "VectorTraits.h"
@@ -482 +483 @@
 
         static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
-        T* inlineBuffer() { return reinterpret_cast<T*>(m_inlineBuffer.buffer); }
+        T* inlineBuffer() { return reinterpret_cast_ptr<T*>(m_inlineBuffer.buffer); }
 
         AlignedBuffer<m_inlineBufferSize, WTF_ALIGN_OF(T)> m_inlineBuffer;

trunk/JavaScriptCore/wtf/qt/StringQt.cpp

@@ -26 +26 @@
 #include "config.h"
 
+#include <wtf/StdLibExtras.h>
 #include <wtf/text/WTFString.h>
 
@@ -37 +38 @@
     if (qstr.isNull())
         return;
-    m_impl = StringImpl::create(reinterpret_cast<const UChar*>(qstr.constData()), qstr.length());
+    m_impl = StringImpl::create(reinterpret_cast_ptr<const UChar*>(qstr.constData()), qstr.length());
 }
 
@@ -44 +45 @@
     if (!ref.string())
         return;
-    m_impl = StringImpl::create(reinterpret_cast<const UChar*>(ref.unicode()), ref.length());
+    m_impl = StringImpl::create(reinterpret_cast_ptr<const UChar*>(ref.unicode()), ref.length());
 }