[WebKit內核] JavaScriptCore深度解析--基礎篇（一）字節碼生成及語法樹的構建

     看到HorkeyChen寫的文章《[WebKit] JavaScriptCore解析--基礎篇(三)從腳本代碼到JIT編譯的代碼實現》，寫的很好，深受啓發。想補充一些Horkey沒有寫到的細節好比字節碼是如何生成的等等，爲此成文。

      JSC對JavaScript的處理，其實與Webkit對CSS的處理許多地方是相似的，它這麼幾個部分：

（1）詞法分析->出來詞語(Token)；

（2）語法分析->出來抽象語法樹（AST：Abstract Syntax Tree）；

（3）遍歷抽象語法樹->生成字節碼（Bytecode）；

（4）用解釋器（LLInt：Low Level Interpreter）執行字節碼；

（5）若是性能不夠好就用Baseline JIT編譯字節碼生成機器碼、而後執行此機器碼；

（6）若是性能還不夠好，就用DFG JIT從新編譯字節碼生成更好的機器碼、而後執行此機器碼；

（7）最後，若是還很差，就祭出重器--虛擬器（LLVM：Low Level Virtual Machine）來編譯DFG的中間表示代碼、生成更高優化的機器碼並執行。接下來，我將會用一下系列文章描述此過程。

      其中，步驟一、2是相似的，三、四、5步的思想，CSS JIT也是採用相似方法，請參考[1]。想寫寫JSC的文章，用菜鳥和愚公移山的方式，敲開JSC的冰山一角。

本篇主要描述詞法和語法解析的細節。

 1、 JavaScriptCore的詞法分析器工做流程分析

    W3C是這麼解釋詞法和語法工做流程的：

 詞法器Tokenizer的工做過程以下，就是不斷從字符串中尋找一個個的詞（Token），好比找到連續的「true」字符串，就建立一個TokenTrue。詞法器工做過程以下：

JavaScriptCore/interpreter/interpreter.cpp:
template <typename CharType>

[cpp] view plaincopy

1. template <ParserMode mode> TokenType LiteralParser<CharType>::Lexer::lex(LiteralParserToken<CharType>& token)  

2. {  

3.     while (m_ptr < m_end && isJSONWhiteSpace(*m_ptr))  

4.         ++m_ptr;  

5.   

6.     if (m_ptr >= m_end) {  

7.         token.type = TokEnd;  

8.         token.start = token.end = m_ptr;  

9.         return TokEnd;  

10.     }  

11.     token.type = TokError;  

12.     token.start = m_ptr;  

13.     switch (*m_ptr) {  

14.         case '[':  

15.             token.type = TokLBracket;  

16.             token.end = ++m_ptr;  

17.             return TokLBracket;  

18.         case ']':  

19.             token.type = TokRBracket;  

20.             token.end = ++m_ptr;  

21.             return TokRBracket;  

22.         case '(':  

23.             token.type = TokLParen;  

24.             token.end = ++m_ptr;  

25.             return TokLParen;  

26.         case ')':  

27.             token.type = TokRParen;  

28.             token.end = ++m_ptr;  

29.             return TokRParen;  

30.         case ',':  

31.             token.type = TokComma;  

32.             token.end = ++m_ptr;  

33.             return TokComma;  

34.         case ':':  

35.             token.type = TokColon;  

36.             token.end = ++m_ptr;  

37.             return TokColon;  

38.         case '"':  

39.             return lexString<mode, '"'>(token);  

40.         case 't':  

41.             if (m_end - m_ptr >= 4 && m_ptr[1] == 'r' && m_ptr[2] == 'u' && m_ptr[3] == 'e') {  

42.                 m_ptr += 4;  

43.                 token.type = TokTrue;  

44.                 token.end = m_ptr;  

45.                 return TokTrue;  

46.             }  

47.             break;  

48.         case '-':  

49.         case '0':  

[cpp] view plaincopy

1.         ...  

2.         case '9':  

3.             return lexNumber(token);  

4.     }  

5.     if (m_ptr < m_end) {  

6.         if (*m_ptr == '.') {  

7.             token.type = TokDot;  

8.             token.end = ++m_ptr;  

9.             return TokDot;  

10.         }  

11.         if (*m_ptr == '=') {  

12.             token.type = TokAssign;  

13.             token.end = ++m_ptr;  

14.             return TokAssign;  

15.         }  

16.         if (*m_ptr == ';') {  

17.             token.type = TokSemi;  

18.             token.end = ++m_ptr;  

19.             return TokAssign;  

20.         }  

21.         if (isASCIIAlpha(*m_ptr) || *m_ptr == '_' || *m_ptr == '$')  

22.             return lexIdentifier(token);  

23.         if (*m_ptr == '\'') {  

24.             return lexString<mode, '\''>(token);  

25.         }  

26.     }  

27.     m_lexErrorMessage = String::format("Unrecognized token '%c'", *m_ptr).impl();  

28.     return TokError;  

29. }  

      通過此過程，一個完整的JSC世界的Token就生成了。而後，再進行語法分析，生成抽象語法樹.

JavaScriptCore/parser/parser.cpp:

[cpp] view plaincopy

1. <span style="font-family: Arial, Helvetica, sans-serif;">PassRefPtr<ParsedNode> Parser<LexerType>::parse(JSGlobalObject* lexicalGlobalObject, Debugger* debugger, ExecState* debuggerExecState, JSObject** exception)</span>  

[cpp] view plaincopy

1. {  

2.     ASSERT(lexicalGlobalObject);  

3.     ASSERT(exception && !*exception);  

4.     int errLine;  

5.     UString errMsg;  

6.   

7.     if (ParsedNode::scopeIsFunction)  

8.         m_lexer->setIsReparsing();  

9.   

10.     m_sourceElements = 0;  

11.   

12.     errLine = -1;  

13.     errMsg = UString();  

14.   

15.     UString parseError = parseInner();  

16.     。。。  

17. ｝  

UString Parser<LexerType>::parseInner()

[cpp] view plaincopy

1. {  

2.     UString parseError = UString();  

3.       

4.     unsigned oldFunctionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;  

[cpp] view plaincopy

1. //抽象語法樹Builder：  

2. ASTBuilder context(const_cast<JSGlobalData*>(m_globalData), const_cast<SourceCode*>(m_source));  

3. if (m_lexer->isReparsing())  

4.     m_statementDepth--;  

5. ScopeRef scope = currentScope();  

[cpp] view plaincopy

1. //開始解析生成語法樹的一個節點：  

2. SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);  

3. if (!sourceElements || !consume(EOFTOK))  

｝
         舉例說來，根據Token的類型，JSC認爲輸入的Token是一個常量聲明，就會使用以下的模板函數生成語法節點（Node），而後放入ASTBuilder裏面：

[cpp] view plaincopy

1. JavaScriptCore/bytecompiler/NodeCodeGen.cpp:  

2. template <typename LexerType>  

3. template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context)  

4. {  

5.     failIfTrue(strictMode());  

6.     TreeConstDeclList constDecls = 0;  

7.     TreeConstDeclList tail = 0;  

8.     do {  

9.         next();  

10.         matchOrFail(IDENT);  

11.         const Identifier* name = m_token.m_data.ident;  

12.         next();  

13.         bool hasInitializer = match(EQUAL);  

14.         declareVariable(name);  

15.         context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));  

16.         TreeExpression initializer = 0;  

17.         if (hasInitializer) {  

18.             next(TreeBuilder::DontBuildStrings); // consume '='  

19.             initializer = parseAssignmentExpression(context);  

20.         }  

21.         tail = context.appendConstDecl(m_lexer->lastLineNumber(), tail, name, initializer);  

22.         if (!constDecls)  

23.             constDecls = tail;  

24.     } while (match(COMMA));  

25.     return constDecls;  

26. }  

      接下來，就會調用BytecodeGenerator::generate生成字節碼，具體分下節分析。咱們先看看下面來自JavaScript的一個個語法樹節點生成字節碼的過程：

JavaScriptCore/bytecompiler/NodeCodeGen.cpp:
RegisterID* BooleanNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

[cpp] view plaincopy

1. {  

2.     if (dst == generator.ignoredResult())  

3.         return 0;  

4.     return generator.emitLoad(dst, m_value);  

5. }  

     如下是我準備寫的文章題目：

1、 JavaScriptCore的詞法分析器工做流程分析；

2、 JavaScriptCore的語法分析器工做流程分析；

3、 JavaScriptCore的字節碼生成流程分析；

4、 LLInt解釋器工做流程分析；

5、 Baseline JIT編譯器的工做流程分析；

6、 DFG JIT編譯器的工做流程分析；

7、LLVM虛擬機的工做流程分析；

8、JavaScriptCore的將來展望；

     文筆粗糙，不善表達，但願能越寫越好。

第一時間得到博客更新提醒，以及更多技術信息分享，歡迎關注我的微信公衆平臺:程序員互動聯盟(coder_online)，掃一掃下方二維碼或搜索微信號coder_online便可關注,咱們能夠在線交流。