1 介绍
JavaScript 是弱类型语言，那么它的变量、表达式等在参加运算时，即便类型不正确，也能通过隐式转换来失去正确地类型，这对使用者而言，就如同所有类型都能进行所有运算。本文通过剖析 V8 的加法源码，率领大家理解 JavaScript 加法运算的细节，看看 V8 到底是怎么做的。
2 ADD_HANDLER
V8 从字节码开始执行 JavaScript 源码，所以咱们从加法的字节码处理程序动手剖析，源码如下：
IGNITION_HANDLER(Add, InterpreterBinaryOpAssembler) {
BinaryOpWithFeedback(&BinaryOpAssembler::Generate_AddWithFeedback);
}
JavaScript 源码中的所有加法运算都要从下面这个 ADD_HANDLER 开始，它外部还会调用 Builtin::kAdd 等性能。而在 TurboFan 中，ADD_HANDLER 有可能被优化为 NewConsString 或 StringConcat 等性能，上面追随代码来看看 V8 是如何把这些性能组织起来的。
3 Generate_AddWithFeedback
1. TNode<Object> BinaryOpAssembler::Generate_AddWithFeedback() {
2. Label if_lhsisnotsmi(this,
3. rhs_known_smi ? Label::kDeferred : Label::kNonDeferred);
4. Branch(TaggedIsNotSmi(lhs), &if_lhsisnotsmi, &if_lhsissmi);
5. BIND(&if_lhsissmi);
6. {7. TNode<Smi> lhs_smi = CAST(lhs);
8. if (!rhs_known_smi) {9. Label if_rhsissmi(this), if_rhsisnotsmi(this);
10. Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
11. BIND(&if_rhsisnotsmi);
12. {13. TNode<HeapObject> rhs_heap_object = CAST(rhs);
14. GotoIfNot(IsHeapNumber(rhs_heap_object), &check_rhsisoddball);
15. var_fadd_lhs = SmiToFloat64(lhs_smi);
16. var_fadd_rhs = LoadHeapNumberValue(rhs_heap_object);
17. Goto(&do_fadd); }
18. BIND(&if_rhsissmi); }
19. {20. TNode<Smi> rhs_smi = CAST(rhs);
21. Label if_overflow(this,
22. rhs_known_smi ? Label::kDeferred : Label::kNonDeferred);
23. TNode<Smi> smi_result = TrySmiAdd(lhs_smi, rhs_smi, &if_overflow);
24. {25. var_type_feedback = SmiConstant(BinaryOperationFeedback::kSignedSmall);
26. UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector(),
27. slot_id, update_feedback_mode);
28. var_result = smi_result;
29. Goto(&end); }
30. BIND(&if_overflow);
31. {32. var_fadd_lhs = SmiToFloat64(lhs_smi);
33. var_fadd_rhs = SmiToFloat64(rhs_smi);
34. Goto(&do_fadd);
35. } } }
36. BIND(&if_lhsisnotsmi);
37. {38. TNode<HeapObject> lhs_heap_object = CAST(lhs);
39. GotoIfNot(IsHeapNumber(lhs_heap_object), &if_lhsisnotnumber);
40. if (!rhs_known_smi) {41. Label if_rhsissmi(this), if_rhsisnotsmi(this);
42. Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
43. BIND(&if_rhsisnotsmi);
44. {45. TNode<HeapObject> rhs_heap_object = CAST(rhs);
46. GotoIfNot(IsHeapNumber(rhs_heap_object), &check_rhsisoddball);
47. var_fadd_lhs = LoadHeapNumberValue(lhs_heap_object);
48. var_fadd_rhs = LoadHeapNumberValue(rhs_heap_object);
49. Goto(&do_fadd);
50. }
51. BIND(&if_rhsissmi);
52. }
53. {54. var_fadd_lhs = LoadHeapNumberValue(lhs_heap_object);
55. var_fadd_rhs = SmiToFloat64(CAST(rhs));
56. Goto(&do_fadd);
57. }
58. }
59. BIND(&do_fadd);
60. {61. var_type_feedback = SmiConstant(BinaryOperationFeedback::kNumber);
62. UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector(), slot_id,
63. update_feedback_mode);
64. TNode<Float64T> value =
65. Float64Add(var_fadd_lhs.value(), var_fadd_rhs.value());
66. TNode<HeapNumber> result = AllocateHeapNumberWithValue(value);
67. var_result = result;
68. Goto(&end);
69. }
70. BIND(&if_lhsisnotnumber);
71. {72. TNode<Uint16T> lhs_instance_type = LoadInstanceType(CAST(lhs));
73. TNode<BoolT> lhs_is_oddball =
74. InstanceTypeEqual(lhs_instance_type, ODDBALL_TYPE);
75. Branch(lhs_is_oddball, &if_lhsisoddball, &if_lhsisnotoddball);
76. BIND(&if_lhsisoddball);
77. {78. GotoIf(TaggedIsSmi(rhs), &call_with_oddball_feedback);
79. Branch(IsHeapNumber(CAST(rhs)), &call_with_oddball_feedback,
80. &check_rhsisoddball);
81. }
82. BIND(&if_lhsisnotoddball);
83. {84. GotoIf(TaggedIsSmi(rhs), &call_with_any_feedback);
85. TNode<HeapObject> rhs_heap_object = CAST(rhs);
86. GotoIf(IsStringInstanceType(lhs_instance_type), &lhs_is_string);
87. GotoIf(IsBigIntInstanceType(lhs_instance_type), &lhs_is_bigint);
88. Goto(&call_with_any_feedback);
89. BIND(&lhs_is_bigint);
90. Branch(IsBigInt(rhs_heap_object), &bigint, &call_with_any_feedback);
91. BIND(&lhs_is_string);
92. {93. TNode<Uint16T> rhs_instance_type = LoadInstanceType(rhs_heap_object);
94. GotoIfNot(IsStringInstanceType(rhs_instance_type),
95. &call_with_any_feedback);
96. var_type_feedback = SmiConstant(BinaryOperationFeedback::kString);
97. UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector(),
98. slot_id, update_feedback_mode);
99. var_result =
100. CallBuiltin(Builtin::kStringAdd_CheckNone, context(), lhs, rhs);
101. Goto(&end);
102. } } }
103. BIND(&check_rhsisoddball);
104. {105. TNode<Uint16T> rhs_instance_type = LoadInstanceType(CAST(rhs));
106. TNode<BoolT> rhs_is_oddball =
107. InstanceTypeEqual(rhs_instance_type, ODDBALL_TYPE);
108. GotoIf(rhs_is_oddball, &call_with_oddball_feedback);
109. Goto(&call_with_any_feedback);
110. }
111. BIND(&bigint);
112. {113. var_result = CallBuiltin(Builtin::kBigIntAddNoThrow, context(), lhs, rhs);
114. GotoIf(TaggedIsSmi(var_result.value()), &bigint_too_big);
115. var_type_feedback = SmiConstant(BinaryOperationFeedback::kBigInt);
116. UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector(), slot_id,
117. update_feedback_mode);
118. Goto(&end);
119. BIND(&bigint_too_big);
120. {121. UpdateFeedback(SmiConstant(BinaryOperationFeedback::kAny),
122. maybe_feedback_vector(), slot_id, update_feedback_mode);
123. ThrowRangeError(context(), MessageTemplate::kBigIntTooBig);
124. } }
125. BIND(&call_with_oddball_feedback);
126. {127. var_type_feedback = SmiConstant(BinaryOperationFeedback::kNumberOrOddball);
128. Goto(&call_add_stub); }
129. BIND(&call_with_any_feedback);
130. {131. var_type_feedback = SmiConstant(BinaryOperationFeedback::kAny);
132. Goto(&call_add_stub); }
133. BIND(&call_add_stub);
134. {135. UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector(), slot_id,
136. update_feedback_mode);
137. var_result = CallBuiltin(Builtin::kAdd, context(), lhs, rhs);
138. Goto(&end); }
139. BIND(&end);
140. return var_result.value();
141. }第一局部：左操作数是 Smi
第 4 行代码判断左操作数是不是 Smi；如果是 Smi 进入第 5 行代码，否则进入第 36 行代码；提醒 咱们写 JS 程序时，加法算运最常于两个数值的相加，所以最先判断左、右操作数是不是数值。
第 7 行代码把左操作数转为 Smi；
第 8-10 行代码判断右操作类型；
第 12-17 行解决右操作数不是 Smi 的状况；左、右类型不统一，须要类型转换
第 13-14 行转换右操作数为 HeapObject，且为 HeapNumber 时，将左操作数（第 15 行）转为 HeapNumber，跳转到 do_fadd 标签（第 59-68 行）以实现 float 加法；
第 18 行解决右操作数是 Smi 的状况：
第 20-23 行实现 Smi 加法；留神 TrySmiAdd() 求和的同时还负责判断后果是否越界，Smi 是 31bit；
第 26 行更新 Feedback，TurboFan 优化时应用，下篇文章解说；
第 30-34 行加法越界时采纳 fload 加法（第 59 行）；
第二局部：左操作是 HeapNumber
第 38-39 行代码把左操作数转为 HeapObject，并判断是否为 HeapNumber，不是就跳转到第 70 行代码；
第 40-58 行左操作数是 HeapNumber:
第 44-49 行判断出右操作数是 HeapNumber，跳转到第 59 行以实现 float 加法；第 54-56 行判断出右操作数是 Smi，转换右操作数为 HeapNumber 后跳转到第 59 行；
第 59-67 行实现 float 加法；
第三局部：左操作是 HeapObject，例如：BigInt、string
第 72-91 行取出左、右操作数的 instance_type 类型标记符，并进一步判断两个操作的类型。
第 96-100 行左、右操作数均为 String、调用 Builtin::kStringAdd_CheckNone 实现字符串加法；
第 91-94 行左操作数是 String 且右操作数不是 String 时跳转到 131 行；
第 131-135 行更新 feedback 为 kAny 之后，调用 Builtin::kAdd 实现“字符串”和“非字符串”的加法。
上述源码中的其它状况请自行剖析，上面简略解说 Builtin:kAdd 源码
4 Builtin:kAdd
其源码采纳 TQ 编写，源码如下：
1. transitioning builtin Add(implicit context: Context)(2. leftArg: JSAny, rightArg: JSAny): JSAny {
3. try {4. while (true) {5. typeswitch (left) {6. case (left: Smi): {
7. // 省略................
8. }
9. case (left: HeapNumber): {10. typeswitch (right) {
11. // 省略................
12. }
13. case (left: BigInt): {
14. // 省略................
15. }
16. case (left: String): {17. goto StringAddConvertRight(left, right);
18. }
19. case (leftReceiver: JSReceiver): {
20. // 省略................
21. }
22. case (HeapObject): {
23. // 省略................
24. } } } }
25. unreachable;
26. }上述代码先判断左操作数的类型、再判断右操作类型，而后进行类型转换并计算结果。第 17 行代给出了左操作数是字符串、右操作数非字符串的加法实现，即 Builtin 办法 StringAddConvertRight，该办法采纳 TQ 实现，其源码在 builtins-string.tq 中，下篇文章解说。
5 技术总结
（1）加法操作（所有操作）都是先由字节码开始，达到热点条件时进入 TurboFan；
（2）Generate_AddWithFeedback 的“Feedback”收集收左、右操作数的类型信息，用于 TurboFan 的投机优化；
（3）Generate_AddWithFeedback 做不了的加法应用 builtin::kAdd 实现，而 kAdd 还会一步做性能细分。
好了，明天到这里，下次见。
集体能力无限，有有余与纰漏，欢送批评指正
微信：qq9123013 备注：v8 交换 知乎：https://www.zhihu.com/people/…