Changeset 87771 in webkit

Timestamp:

May 31, 2011, 7:40:27 PM (14 years ago)

Author:

commit-queue@webkit.org

Message:

2011-05-31 Yong Li <​yoli@rim.com>

Reviewed by Eric Seidel.

​https://bugs.webkit.org/show_bug.cgi?id=54807
We have been assuming plain bitfields (like "int a : 31") are always signed integers.
However some compilers can treat them as unsigned. For example, RVCT 4.0 states plain
bitfields (declared without either signed or unsigned qualifiers) are treats as unsigned.
​http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0348c/Babjddhe.html
Although we can use "--signed-bitfields" flag to make RVCT 4.0 behave as most other compilers,
always using "signed"/"unsigned" qualifier to declare integral type bitfields is still a good
rule we should have in order to make our code independent from compilers and compiler flags.

No new test added because this change is not known to fix any issue.

• bytecode/StructureStubInfo.h:

2011-05-31 Yong Li <​yoli@rim.com>

Reviewed by Eric Seidel.

​https://bugs.webkit.org/show_bug.cgi?id=54807
We have been assuming plain bitfields (like "int a : 31") are always signed integers.
However some compilers can treat them as unsigned. For example, RVCT 4.0 states plain
bitfields (declared without either signed or unsigned qualifiers) are treats as unsigned.
​http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0348c/Babjddhe.html
Although we can use "--signed-bitfields" flag to make RVCT 4.0 behave as most other compilers,
always using "signed"/"unsigned" qualifier to declare integral type bitfields is still a good
rule we should have in order to make our code independent from compilers and compiler flags.

No new test added because this change is not known to fix any issue.

• css/CSSPrimitiveValue.h:
• css/CSSProperty.h:
• rendering/InlineBox.h:
• rendering/RenderBlock.h:

2011-05-31 Yong Li <​yoli@rim.com>

Reviewed by Eric Seidel.

​https://bugs.webkit.org/show_bug.cgi?id=54807
We have been assuming plain bitfields (like "int a : 31") are always signed integers.
However some compilers can treat them as unsigned. For example, RVCT 4.0 states plain
bitfields (declared without either signed or unsigned qualifiers) are treats as unsigned.
​http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0348c/Babjddhe.html
Although we can use "--signed-bitfields" flag to make RVCT 4.0 behave as most other compilers,
always using "signed"/"unsigned" qualifier to declare integral type bitfields is still a good
rule we should have in order to make our code independent from compilers and compiler flags.

• Scripts/webkitpy/style/checkers/cpp.py:

Location:

trunk

Files:

• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/bytecode/StructureStubInfo.h (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/css/CSSPrimitiveValue.h (modified) (1 diff)
• Source/WebCore/css/CSSProperty.h (modified) (1 diff)
• Source/WebCore/rendering/InlineBox.h (modified) (1 diff)
• Source/WebCore/rendering/RenderBlock.h (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/Scripts/webkitpy/style/checkers/cpp.py (modified) (2 diffs)
• Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog ¶

@@ +1 @@
+2011-05-31  Yong Li  <yoli@rim.com>
+
+        Reviewed by Eric Seidel.
+
+        https://bugs.webkit.org/show_bug.cgi?id=54807
+        We have been assuming plain bitfields (like "int a : 31") are always signed integers.
+        However some compilers can treat them as unsigned. For example, RVCT 4.0 states plain
+        bitfields (declared without either signed or unsigned qualifiers) are treats as unsigned.
+        http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0348c/Babjddhe.html
+        Although we can use "--signed-bitfields" flag to make RVCT 4.0 behave as most other compilers,
+        always using "signed"/"unsigned" qualifier to declare integral type bitfields is still a good
+        rule we should have in order to make our code independent from compilers and compiler flags.
+
+        No new test added because this change is not known to fix any issue.
+
+        * bytecode/StructureStubInfo.h:
+
 2011-05-30  Hojong Han  <hojong.han@samsung.com>
 

trunk/Source/JavaScriptCore/bytecode/StructureStubInfo.h ¶

@@ -128 +128 @@
         }
 
-        int accessType : 31;
-        int seen : 1;
+        signed accessType : 31;
+        unsigned seen : 1;
 
         union {

trunk/Source/WebCore/ChangeLog ¶

@@ +1 @@
+2011-05-31  Yong Li  <yoli@rim.com>
+
+        Reviewed by Eric Seidel.
+
+        https://bugs.webkit.org/show_bug.cgi?id=54807
+        We have been assuming plain bitfields (like "int a : 31") are always signed integers.
+        However some compilers can treat them as unsigned. For example, RVCT 4.0 states plain
+        bitfields (declared without either signed or unsigned qualifiers) are treats as unsigned.
+        http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0348c/Babjddhe.html
+        Although we can use "--signed-bitfields" flag to make RVCT 4.0 behave as most other compilers,
+        always using "signed"/"unsigned" qualifier to declare integral type bitfields is still a good
+        rule we should have in order to make our code independent from compilers and compiler flags.
+
+        No new test added because this change is not known to fix any issue.
+
+        * css/CSSPrimitiveValue.h:
+        * css/CSSProperty.h:
+        * rendering/InlineBox.h:
+        * rendering/RenderBlock.h:
+
 2011-05-31  Hironori Bono  <hbono@chromium.org>
 

trunk/Source/WebCore/css/CSSPrimitiveValue.h ¶

@@ -226 +226 @@
     virtual unsigned short cssValueType() const;
 
-    int m_type : 31;
+    signed m_type : 31;
     mutable unsigned m_hasCachedCSSText : 1;
     union {

trunk/Source/WebCore/css/CSSProperty.h ¶

@@ -67 +67 @@
 
     // Make sure the following fits in 4 bytes. Really.
-    int m_id : 15;
-    int m_shorthandID : 15; // If this property was set as part of a shorthand, gives the shorthand.
+    signed m_id : 15;
+    signed m_shorthandID : 15; // If this property was set as part of a shorthand, gives the shorthand.
     bool m_important : 1;
     bool m_implicit : 1; // Whether or not the property was set implicitly as the result of a shorthand.

trunk/Source/WebCore/rendering/InlineBox.h ¶

@@ -366 +366 @@
     mutable bool m_nextOnLineExists : 1;
     mutable bool m_prevOnLineExists : 1;
-    int m_expansion : 11; // for justified text
+    signed m_expansion : 11; // for justified text
 
 #ifndef NDEBUG

trunk/Source/WebCore/rendering/RenderBlock.h ¶

@@ -829 +829 @@
     RenderLineBoxList m_lineBoxes;   // All of the root line boxes created for this block flow.  For example, <div>Hello<br>world.</div> will have two total lines for the <div>.
 
-    mutable int m_lineHeight : 31;
+    mutable signed m_lineHeight : 31;
     bool m_beingDestroyed : 1;
 

trunk/Tools/ChangeLog ¶

@@ +1 @@
+2011-05-31  Yong Li  <yoli@rim.com>
+
+        Reviewed by Eric Seidel.
+
+        https://bugs.webkit.org/show_bug.cgi?id=54807
+        We have been assuming plain bitfields (like "int a : 31") are always signed integers.
+        However some compilers can treat them as unsigned. For example, RVCT 4.0 states plain
+        bitfields (declared without either signed or unsigned qualifiers) are treats as unsigned.
+        http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0348c/Babjddhe.html
+        Although we can use "--signed-bitfields" flag to make RVCT 4.0 behave as most other compilers,
+        always using "signed"/"unsigned" qualifier to declare integral type bitfields is still a good
+        rule we should have in order to make our code independent from compilers and compiler flags.
+
+        * Scripts/webkitpy/style/checkers/cpp.py:
+
 2011-05-31  Hironori Bono  <hbono@chromium.org>
 

trunk/Tools/Scripts/webkitpy/style/checkers/cpp.py ¶

@@ -2920 +2920 @@
               ' for more information.')
 
+    # Check for plain bitfields declared without either "singed" or "unsigned".
+    # Most compilers treat such bitfields as signed, but there are still compilers like
+    # RVCT 4.0 that use unsigned by default.
+    matched = re.match(r'\s*((const|mutable)\s+)?(char|(short(\s+int)?)|int|long(\s+(long|int))?)\s+.+\s*:\s*\d+\s*;', line)
+    if matched:
+        error(line_number, 'runtime/bitfields', 5,
+              'Please declare integral type bitfields with either signed or unsigned.')
+
     check_identifier_name_in_declaration(filename, line_number, line, file_state, error)
 
@@ -3453 +3461 @@
         'readability/webkit_api',
         'runtime/arrays',
+        'runtime/bitfields',
         'runtime/casting',
         'runtime/explicit',

trunk/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py ¶

@@ -2374 +2374 @@
                          'operator*).  [runtime/invalid_increment] [5]')
 
+    # Integral bitfields must be declared with either signed or unsigned keyword.
+    def test_plain_integral_bitfields(self):
+        errmsg = ('Please declare integral type bitfields with either signed or unsigned.  [runtime/bitfields] [5]')
+
+        self.assert_lint('int a : 30;', errmsg)
+        self.assert_lint('mutable short a : 14;', errmsg)
+        self.assert_lint('const char a : 6;', errmsg)
+        self.assert_lint('long int a : 30;', errmsg)
 
 class CleansedLinesTest(unittest.TestCase):