[WebKit内核] JavaScriptCore深度解析--基础篇（一）字节码生成及语法树的构建详情分析 ...

看到HorkeyChen写的文章《[WebKit] JavaScriptCore解析--基础篇(三)从脚本代码到JIT编译的代码实现》，写的很好，深受启发。想补充一些Horkey没有写到的细节比如字节码是如何生成的等等，为此成文。
[img]https://img-blog.csdn.net/20130515081417694[/img]


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是这么解释词法和语法工作流程的：

[img]https://img-blog.csdn.net/20130601065357339[/img]


词法器Tokenizer的工作过程如下，就是不断从字符串中寻找一个个的词（Token），比如找到连续的“true”字符串，就创建一个TokenTrue。词法器工作过程如下：

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

[cpp] view plaincopyprint?01.template <ParserMode mode> TokenType LiteralParser<CharType>::Lexer::lex(LiteralParserToken<CharType>& token)
02.{
03. while (m_ptr < m_end && isJSONWhiteSpace(*m_ptr))
04. ++m_ptr;
05.
06. if (m_ptr >= m_end) {
07. token.type = TokEnd;
08. token.start = token.end = m_ptr;
09. 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':
template <ParserMode mode> TokenType LiteralParser<CharType>::Lexer::lex(LiteralParserToken<CharType>& token)
{
while (m_ptr < m_end && isJSONWhiteSpace(*m_ptr))
++m_ptr;

if (m_ptr >= m_end) {
token.type = TokEnd;
token.start = token.end = m_ptr;
return TokEnd;
}
token.type = TokError;
token.start = m_ptr;
switch (*m_ptr) {
case '[':
token.type = TokLBracket;
token.end = ++m_ptr;
return TokLBracket;
case ']':
token.type = TokRBracket;
token.end = ++m_ptr;
return TokRBracket;
case '(':
token.type = TokLParen;
token.end = ++m_ptr;
return TokLParen;
case ')':
token.type = TokRParen;
token.end = ++m_ptr;
return TokRParen;
case ',':
token.type = TokComma;
token.end = ++m_ptr;
return TokComma;
case ':':
token.type = TokColon;
token.end = ++m_ptr;
return TokColon;
case '"':
return lexString<mode, '"'>(token);
case 't':
if (m_end - m_ptr >= 4 && m_ptr[1] == 'r' && m_ptr[2] == 'u' && m_ptr[3] == 'e') {
m_ptr += 4;
token.type = TokTrue;
token.end = m_ptr;
return TokTrue;
}
break;
case '-':
case '0':[cpp] view plaincopyprint?01. ...
02. case '9':
03. return lexNumber(token);
04. }
05. if (m_ptr < m_end) {
06. if (*m_ptr == '.') {
07. token.type = TokDot;
08. token.end = ++m_ptr;
09. 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.}
...
case '9':
return lexNumber(token);
}
if (m_ptr < m_end) {
if (*m_ptr == '.') {
token.type = TokDot;
token.end = ++m_ptr;
return TokDot;
}
if (*m_ptr == '=') {
token.type = TokAssign;
token.end = ++m_ptr;
return TokAssign;
}
if (*m_ptr == ';') {
token.type = TokSemi;
token.end = ++m_ptr;
return TokAssign;
}
if (isASCIIAlpha(*m_ptr) || *m_ptr == '_' || *m_ptr == '$')
return lexIdentifier(token);
if (*m_ptr == '\'') {
return lexString<mode, '\''>(token);
}
}
m_lexErrorMessage = String::format("Unrecognized token '%c'", *m_ptr).impl();
return TokError;
} 经过此过程，一个完整的JSC世界的Token就生成了。然后，再进行语法分析，生成抽象语法树.


JavaScriptCore/parser/parser.cpp:

[cpp] view plaincopyprint?01.<span style="font-family: Arial, Helvetica, sans-serif;">PassRefPtr<ParsedNode> Parser<LexerType>::parse(JSGlobalObject* lexicalGlobalObject, Debugger* debugger, ExecState* debuggerExecState, JSObject** exception)</span>
<span style="font-family: Arial, Helvetica, sans-serif;">PassRefPtr<ParsedNode> Parser<LexerType>::parse(JSGlobalObject* lexicalGlobalObject, Debugger* debugger, ExecState* debuggerExecState, JSObject** exception)</span>[cpp] view plaincopyprint?01.{
02. ASSERT(lexicalGlobalObject);
03. ASSERT(exception && !*exception);
04. int errLine;
05. UString errMsg;
06.
07. if (ParsedNode::scopeIsFunction)
08. m_lexer->setIsReparsing();
09.
10. m_sourceElements = 0;
11.
12. errLine = -1;
13. errMsg = UString();
14.
15. UString parseError = parseInner();
16. 。。。
17.｝
{
ASSERT(lexicalGlobalObject);
ASSERT(exception && !*exception);
int errLine;
UString errMsg;

if (ParsedNode::scopeIsFunction)
m_lexer->setIsReparsing();

m_sourceElements = 0;

errLine = -1;
errMsg = UString();

UString parseError = parseInner();
。。。
｝
UString Parser<LexerType>::parseInner()
[cpp] view plaincopyprint?01.{
02. UString parseError = UString();
03.
04. unsigned oldFunctionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;
{
UString parseError = UString();

unsigned oldFunctionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;[cpp] view plaincopyprint?01.//抽象语法树Builder：
02.ASTBuilder context(const_cast<JSGlobalData*>(m_globalData), const_cast<SourceCode*>(m_source));
03.if (m_lexer->isReparsing())
04. m_statementDepth--;
05.ScopeRef scope = currentScope();
//抽象语法树Builder：
ASTBuilder context(const_cast<JSGlobalData*>(m_globalData), const_cast<SourceCode*>(m_source));
if (m_lexer->isReparsing())
m_statementDepth--;
ScopeRef scope = currentScope();[cpp] view plaincopyprint?01.//开始解析生成语法树的一个节点：
02.SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);
03.if (!sourceElements || !consume(EOFTOK))
//开始解析生成语法树的一个节点：
SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);
if (!sourceElements || !consume(EOFTOK))
｝
举例说来，根据Token的类型，JSC认为输入的Token是一个常量声明，就会使用如下的模板函数生成语法节点（Node），然后放入ASTBuilder里面：

[cpp] view plaincopyprint?01.JavaScriptCore/bytecompiler/NodeCodeGen.cpp:
02.template <typename LexerType>
03.template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context)
04.{
05. failIfTrue(strictMode());
06. TreeConstDeclList constDecls = 0;
07. TreeConstDeclList tail = 0;
08. do {
09. 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.}
JavaScriptCore/bytecompiler/NodeCodeGen.cpp:
template <typename LexerType>
template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context)
{
failIfTrue(strictMode());
TreeConstDeclList constDecls = 0;
TreeConstDeclList tail = 0;
do {
next();
matchOrFail(IDENT);
const Identifier* name = m_token.m_data.ident;
next();
bool hasInitializer = match(EQUAL);
declareVariable(name);
context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
TreeExpression initializer = 0;
if (hasInitializer) {
next(TreeBuilder::DontBuildStrings); // consume '='
initializer = parseAssignmentExpression(context);
}
tail = context.appendConstDecl(m_lexer->lastLineNumber(), tail, name, initializer);
if (!constDecls)
constDecls = tail;
} while (match(COMMA));
return constDecls;
}
接下来，就会调用BytecodeGenerator::generate生成字节码，具体分下节分析。我们先看看下面来自JavaScript的一个个语法树节点生成字节码的过程：
[img]https://img-blog.csdn.net/20150327001655392?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbGljaHdlaTE5ODM=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center[/img]
JavaScriptCore/bytecompiler/NodeCodeGen.cpp:
RegisterID* BooleanNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

[cpp] view plaincopyprint?01.{
02. if (dst == generator.ignoredResult())
03. return 0;
04. return generator.emitLoad(dst, m_value);
05.}
{
if (dst == generator.ignoredResult())
return 0;
return generator.emitLoad(dst, m_value);
}
以下是我准备写的文章题目：


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

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

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

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

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

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

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

八、JavaScriptCore的未来展望；

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

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

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


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

[img]https://img-blog.csdn.net/20150323142905787[/img]