[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的中间表示代码、生成更高优化的机器码并执行。接下来，我将会用一下系列文章描述此过程。

其中，步骤1、2是类似的，3、4、5步的思想，CSS JIT也是采用类似方法，请参考[1]。想写写JSC的文章，用菜鸟和愚公移山的方式，敲开JSC的冰山一角。

本篇主要描述词法和语法解析的细节。

一、 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. if (m_ptr >= m_end) {

6. token.type = TokEnd;

7. token.start = token.end = m_ptr;

8. return TokEnd;

9. }

10. token.type = TokError;

11. token.start = m_ptr;

12. switch (*m_ptr) {

13. case '[':

14. token.type = TokLBracket;

15. token.end = ++m_ptr;

16. return TokLBracket;

17. case ']':

18. token.type = TokRBracket;

19. token.end = ++m_ptr;

20. return TokRBracket;

21. case '(':

22. token.type = TokLParen;

23. token.end = ++m_ptr;

24. return TokLParen;

25. case ')':

26. token.type = TokRParen;

27. token.end = ++m_ptr;

28. return TokRParen;

29. case ',':

30. token.type = TokComma;

31. token.end = ++m_ptr;

32. return TokComma;

33. case ':':

34. token.type = TokColon;

35. token.end = ++m_ptr;

36. return TokColon;

37. case '"':

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

39. case 't':

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

41. m_ptr += 4;

42. token.type = TokTrue;

43. token.end = m_ptr;

44. return TokTrue;

45. }

46. break;

47. case '-':

48. 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. if (ParsedNode::scopeIsFunction)

7. m_lexer->setIsReparsing();

8. m_sourceElements = 0;

9. errLine = -1;

10. errMsg = UString();

11. UString parseError = parseInner();

12. 。。。

13. ｝

UString Parser<LexerType>::parseInner()

[cpp] view plaincopy

1. {

2. UString parseError = UString();

3. 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. }

以下是我准备写的文章题目：

一、 JavaScriptCore的词法分析器工作流程分析；

二、 JavaScriptCore的语法分析器工作流程分析；

三、 JavaScriptCore的字节码生成流程分析；

四、 LLInt解释器工作流程分析；

五、 Baseline JIT编译器的工作流程分析；

六、 DFG JIT编译器的工作流程分析；

七、LLVM虚拟机的工作流程分析；

八、JavaScriptCore的未来展望；

文笔粗糙，不善表达，希望能越写越好。

第一时间获得博客更新提醒，以及更多技术信息分享，欢迎关注个人微信公众平台:程序员互动联盟(coder_online)，扫一扫下方二维码或搜索微信号coder_online即可关注,我们可以在线交流。

引用：

1 https://www.webkit.org/blog/3271/webkit-css-selector-jit-compiler/

2 http://blog.csdn.net/horkychen/article/details/8928578

转载自：http://my.oschina.net/coderonline/blog/392971