2011-06-03 Oliver Hunt <oliver@apple.com>

ojhunt · ojhunt · commit cb09ed275f31 · 2011-06-04T00:43:42.000Z
Reviewed by Gavin Barraclough. GCC not inlining some functions that it really should be https://bugs.webkit.org/show_bug.cgi?id=62075 Add ALWAYS_INLINE to a number of parsing and lexing functions that should always be inlined. This gets us ~1.4% on my ad hoc parser test. * KeywordLookupGenerator.py: * parser/JSParser.cpp: (JSC::JSParser::next): (JSC::JSParser::nextTokenIsColon): (JSC::JSParser::consume): (JSC::JSParser::match): (JSC::JSParser::tokenStart): (JSC::JSParser::tokenLine): (JSC::JSParser::tokenEnd): * parser/Lexer.cpp: (JSC::isIdentPart): Canonical link: https://commits.webkit.org/77537@main git-svn-id: https://svn.webkit.org/repository/webkit/trunk@88083 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
@@ -1,3 +1,26 @@
+2011-06-03  Oliver Hunt  <oliver@apple.com>
+
+        Reviewed by Gavin Barraclough.
+
+        GCC not inlining some functions that it really should be
+        https://bugs.webkit.org/show_bug.cgi?id=62075
+
+        Add ALWAYS_INLINE to a number of parsing and lexing functions
+        that should always be inlined.  This gets us ~1.4% on my ad hoc
+        parser test.
+
+        * KeywordLookupGenerator.py:
+        * parser/JSParser.cpp:
+        (JSC::JSParser::next):
+        (JSC::JSParser::nextTokenIsColon):
+        (JSC::JSParser::consume):
+        (JSC::JSParser::match):
+        (JSC::JSParser::tokenStart):
+        (JSC::JSParser::tokenLine):
+        (JSC::JSParser::tokenEnd):
+        * parser/Lexer.cpp:
+        (JSC::isIdentPart):
+
 2011-06-03  Oliver Hunt  <oliver@apple.com>
 
         Whoops, fix last minute bug.
diff --git a/Source/JavaScriptCore/KeywordLookupGenerator.py b/Source/JavaScriptCore/KeywordLookupGenerator.py
@@ -163,7 +163,7 @@ def maxLength(self):
 
     def printAsC(self):
         print("namespace JSC {")
-        print("static inline bool isIdentPart(int c);")
+        print("static ALWAYS_INLINE bool isIdentPart(int c);")
         # max length + 1 so we don't need to do any bounds checking at all
         print("static const int maxTokenLength = %d;" % (self.maxLength() + 1))
         print("ALWAYS_INLINE JSTokenType Lexer::parseKeyword() {")
diff --git a/Source/JavaScriptCore/parser/JSParser.cpp b/Source/JavaScriptCore/parser/JSParser.cpp
@@ -99,43 +99,43 @@ class JSParser {
         bool m_isLoop;
     };
     
-    void next(unsigned lexType = 0)
+    ALWAYS_INLINE void next(unsigned lexType = 0)
     {
         m_lastLine = m_token.m_info.line;
         m_lastTokenEnd = m_token.m_info.endOffset;
         m_lexer->setLastLineNumber(m_lastLine);
         m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_info, lexType, strictMode());
     }
     
-    bool nextTokenIsColon()
+    ALWAYS_INLINE bool nextTokenIsColon()
     {
         return m_lexer->nextTokenIsColon();
     }
 
-    bool consume(JSTokenType expected, unsigned flags = 0)
+    ALWAYS_INLINE bool consume(JSTokenType expected, unsigned flags = 0)
     {
         bool result = m_token.m_type == expected;
         failIfFalse(result);
         next(flags);
         return result;
     }
 
-    bool match(JSTokenType expected)
+    ALWAYS_INLINE bool match(JSTokenType expected)
     {
         return m_token.m_type == expected;
     }
 
-    int tokenStart()
+    ALWAYS_INLINE int tokenStart()
     {
         return m_token.m_info.startOffset;
     }
 
-    int tokenLine()
+    ALWAYS_INLINE int tokenLine()
     {
         return m_token.m_info.line;
     }
 
-    int tokenEnd()
+    ALWAYS_INLINE int tokenEnd()
     {
         return m_token.m_info.endOffset;
     }
diff --git a/Source/JavaScriptCore/parser/Lexer.cpp b/Source/JavaScriptCore/parser/Lexer.cpp
@@ -357,7 +357,7 @@ static NEVER_INLINE bool isNonASCIIIdentPart(int c)
         | Mark_NonSpacing | Mark_SpacingCombining | Number_DecimalDigit | Punctuation_Connector);
 }
 
-static inline bool isIdentPart(int c)
+static ALWAYS_INLINE bool isIdentPart(int c)
 {
     // Character types are divided into two groups depending on whether they can be part of an
     // identifier or not. Those whose type value is less or equal than CharacterNumber can be

Original file line number	Diff line number	Diff line change
`@@ -99,43 +99,43 @@ class JSParser {`
`99`	`99`	`bool m_isLoop;`
`100`	`100`	`};`
`101`	`101`
`102`		`- void next(unsigned lexType = 0)`
	`102`	`+ ALWAYS_INLINE void next(unsigned lexType = 0)`
`103`	`103`	`{`
`104`	`104`	`m_lastLine = m_token.m_info.line;`
`105`	`105`	`m_lastTokenEnd = m_token.m_info.endOffset;`
`106`	`106`	`m_lexer->setLastLineNumber(m_lastLine);`
`107`	`107`	`m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_info, lexType, strictMode());`
`108`	`108`	`}`
`109`	`109`
`110`		`- bool nextTokenIsColon()`
	`110`	`+ ALWAYS_INLINE bool nextTokenIsColon()`
`111`	`111`	`{`
`112`	`112`	`return m_lexer->nextTokenIsColon();`
`113`	`113`	`}`
`114`	`114`
`115`		`- bool consume(JSTokenType expected, unsigned flags = 0)`
	`115`	`+ ALWAYS_INLINE bool consume(JSTokenType expected, unsigned flags = 0)`
`116`	`116`	`{`
`117`	`117`	`bool result = m_token.m_type == expected;`
`118`	`118`	`failIfFalse(result);`
`119`	`119`	`next(flags);`
`120`	`120`	`return result;`
`121`	`121`	`}`
`122`	`122`
`123`		`- bool match(JSTokenType expected)`
	`123`	`+ ALWAYS_INLINE bool match(JSTokenType expected)`
`124`	`124`	`{`
`125`	`125`	`return m_token.m_type == expected;`
`126`	`126`	`}`
`127`	`127`
`128`		`- int tokenStart()`
	`128`	`+ ALWAYS_INLINE int tokenStart()`
`129`	`129`	`{`
`130`	`130`	`return m_token.m_info.startOffset;`
`131`	`131`	`}`
`132`	`132`
`133`		`- int tokenLine()`
	`133`	`+ ALWAYS_INLINE int tokenLine()`
`134`	`134`	`{`
`135`	`135`	`return m_token.m_info.line;`
`136`	`136`	`}`
`137`	`137`
`138`		`- int tokenEnd()`
	`138`	`+ ALWAYS_INLINE int tokenEnd()`
`139`	`139`	`{`
`140`	`140`	`return m_token.m_info.endOffset;`
`141`	`141`	`}`
Original file line number	Diff line number	Diff line change
`@@ -357,7 +357,7 @@ static NEVER_INLINE bool isNonASCIIIdentPart(int c)`
`357`	`357`	`\| Mark_NonSpacing \| Mark_SpacingCombining \| Number_DecimalDigit \| Punctuation_Connector);`
`358`	`358`	`}`
`359`	`359`
`360`		`-static inline bool isIdentPart(int c)`
	`360`	`+static ALWAYS_INLINE bool isIdentPart(int c)`
`361`	`361`	`{`
`362`	`362`	`// Character types are divided into two groups depending on whether they can be part of an`
`363`	`363`	`// identifier or not. Those whose type value is less or equal than CharacterNumber can be`