| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2015 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include <stdlib.h> |
| 6 |
| 7 #include "src/v8.h" |
| 8 |
| 9 #include "src/ast.h" |
| 10 #include "src/ast-expression-visitor.h" |
| 11 #include "src/parser.h" |
| 12 #include "src/rewriter.h" |
| 13 #include "src/scopes.h" |
| 14 #include "test/cctest/cctest.h" |
| 15 #include "test/cctest/expression-type-collector.h" |
| 16 |
| 17 using namespace v8::internal; |
| 18 |
| 19 namespace { |
| 20 |
| 21 static void CollectTypes(HandleAndZoneScope* handles, const char* source, |
| 22 ZoneVector<ExpressionTypeEntry>* dst) { |
| 23 i::Isolate* isolate = CcTest::i_isolate(); |
| 24 i::Factory* factory = isolate->factory(); |
| 25 |
| 26 i::Handle<i::String> source_code = |
| 27 factory->NewStringFromUtf8(i::CStrVector(source)).ToHandleChecked(); |
| 28 |
| 29 i::Handle<i::Script> script = factory->NewScript(source_code); |
| 30 |
| 31 i::ParseInfo info(handles->main_zone(), script); |
| 32 i::Parser parser(&info); |
| 33 parser.set_allow_harmony_arrow_functions(true); |
| 34 parser.set_allow_harmony_sloppy(true); |
| 35 info.set_global(); |
| 36 info.set_lazy(false); |
| 37 info.set_allow_lazy_parsing(false); |
| 38 info.set_toplevel(true); |
| 39 |
| 40 i::CompilationInfo compilation_info(&info); |
| 41 CHECK(i::Compiler::ParseAndAnalyze(&info)); |
| 42 info.set_literal( |
| 43 info.scope()->declarations()->at(0)->AsFunctionDeclaration()->fun()); |
| 44 |
| 45 ExpressionTypeCollector::Run(&compilation_info, dst); |
| 46 } |
| 47 } |
| 48 |
| 49 |
| 50 TEST(VisitExpressions) { |
| 51 v8::V8::Initialize(); |
| 52 HandleAndZoneScope handles; |
| 53 ZoneVector<ExpressionTypeEntry> types(handles.main_zone()); |
| 54 const char test_function[] = |
| 55 "function GeometricMean(stdlib, foreign, buffer) {\n" |
| 56 " \"use asm\";\n" |
| 57 "\n" |
| 58 " var exp = stdlib.Math.exp;\n" |
| 59 " var log = stdlib.Math.log;\n" |
| 60 " var values = new stdlib.Float64Array(buffer);\n" |
| 61 "\n" |
| 62 " function logSum(start, end) {\n" |
| 63 " start = start|0;\n" |
| 64 " end = end|0;\n" |
| 65 "\n" |
| 66 " var sum = 0.0, p = 0, q = 0;\n" |
| 67 "\n" |
| 68 " // asm.js forces byte addressing of the heap by requiring shifting " |
| 69 "by 3\n" |
| 70 " for (p = start << 3, q = end << 3; (p|0) < (q|0); p = (p + 8)|0) {\n" |
| 71 " sum = sum + +log(values[p>>3]);\n" |
| 72 " }\n" |
| 73 "\n" |
| 74 " return +sum;\n" |
| 75 " }\n" |
| 76 "\n" |
| 77 " function geometricMean(start, end) {\n" |
| 78 " start = start|0;\n" |
| 79 " end = end|0;\n" |
| 80 "\n" |
| 81 " return +exp(+logSum(start, end) / +((end - start)|0));\n" |
| 82 " }\n" |
| 83 "\n" |
| 84 " return { geometricMean: geometricMean };\n" |
| 85 "}\n"; |
| 86 |
| 87 CollectTypes(&handles, test_function, &types); |
| 88 CHECK_TYPES_BEGIN { |
| 89 // function logSum |
| 90 CHECK_EXPR(FunctionLiteral, DEFAULT_TYPE) { |
| 91 CHECK_EXPR(FunctionLiteral, DEFAULT_TYPE) { |
| 92 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 93 CHECK_VAR(start, DEFAULT_TYPE); |
| 94 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 95 CHECK_VAR(start, DEFAULT_TYPE); |
| 96 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 97 } |
| 98 } |
| 99 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 100 CHECK_VAR(end, DEFAULT_TYPE); |
| 101 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 102 CHECK_VAR(end, DEFAULT_TYPE); |
| 103 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 104 } |
| 105 } |
| 106 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 107 CHECK_VAR(sum, DEFAULT_TYPE); |
| 108 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 109 } |
| 110 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 111 CHECK_VAR(p, DEFAULT_TYPE); |
| 112 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 113 } |
| 114 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 115 CHECK_VAR(q, DEFAULT_TYPE); |
| 116 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 117 } |
| 118 // for (p = start << 3, q = end << 3; |
| 119 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 120 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 121 CHECK_VAR(p, DEFAULT_TYPE); |
| 122 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 123 CHECK_VAR(start, DEFAULT_TYPE); |
| 124 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 125 } |
| 126 } |
| 127 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 128 CHECK_VAR(q, DEFAULT_TYPE); |
| 129 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 130 CHECK_VAR(end, DEFAULT_TYPE); |
| 131 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 132 } |
| 133 } |
| 134 } |
| 135 // (p|0) < (q|0); |
| 136 CHECK_EXPR(CompareOperation, DEFAULT_TYPE) { |
| 137 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 138 CHECK_VAR(p, DEFAULT_TYPE); |
| 139 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 140 } |
| 141 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 142 CHECK_VAR(q, DEFAULT_TYPE); |
| 143 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 144 } |
| 145 } |
| 146 // p = (p + 8)|0) {\n" |
| 147 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 148 CHECK_VAR(p, DEFAULT_TYPE); |
| 149 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 150 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 151 CHECK_VAR(p, DEFAULT_TYPE); |
| 152 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 153 } |
| 154 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 155 } |
| 156 } |
| 157 // sum = sum + +log(values[p>>3]); |
| 158 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 159 CHECK_VAR(sum, DEFAULT_TYPE); |
| 160 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 161 CHECK_VAR(sum, DEFAULT_TYPE); |
| 162 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 163 CHECK_EXPR(Call, DEFAULT_TYPE) { |
| 164 CHECK_VAR(log, DEFAULT_TYPE); |
| 165 CHECK_VAR(values, DEFAULT_TYPE); |
| 166 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 167 CHECK_VAR(p, DEFAULT_TYPE); |
| 168 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 169 } |
| 170 } |
| 171 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 172 } |
| 173 } |
| 174 } |
| 175 // return +sum; |
| 176 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 177 CHECK_VAR(sum, DEFAULT_TYPE); |
| 178 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 179 } |
| 180 } |
| 181 // function geometricMean |
| 182 CHECK_EXPR(FunctionLiteral, DEFAULT_TYPE) { |
| 183 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 184 CHECK_VAR(start, DEFAULT_TYPE); |
| 185 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 186 CHECK_VAR(start, DEFAULT_TYPE); |
| 187 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 188 } |
| 189 } |
| 190 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 191 CHECK_VAR(end, DEFAULT_TYPE); |
| 192 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 193 CHECK_VAR(end, DEFAULT_TYPE); |
| 194 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 195 } |
| 196 } |
| 197 // return +exp(+logSum(start, end) / +((end - start)|0)); |
| 198 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 199 CHECK_EXPR(Call, DEFAULT_TYPE) { |
| 200 CHECK_VAR(exp, DEFAULT_TYPE); |
| 201 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 202 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 203 CHECK_EXPR(Call, DEFAULT_TYPE) { |
| 204 CHECK_VAR(logSum, DEFAULT_TYPE); |
| 205 CHECK_VAR(start, DEFAULT_TYPE); |
| 206 CHECK_VAR(end, DEFAULT_TYPE); |
| 207 } |
| 208 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 209 } |
| 210 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 211 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 212 CHECK_EXPR(BinaryOperation, DEFAULT_TYPE) { |
| 213 CHECK_VAR(end, DEFAULT_TYPE); |
| 214 CHECK_VAR(start, DEFAULT_TYPE); |
| 215 } |
| 216 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 217 } |
| 218 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 219 } |
| 220 } |
| 221 } |
| 222 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 223 } |
| 224 } |
| 225 // "use asm"; |
| 226 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 227 // var exp = stdlib.Math.exp; |
| 228 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 229 CHECK_VAR(exp, DEFAULT_TYPE); |
| 230 CHECK_VAR(stdlib, DEFAULT_TYPE); |
| 231 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 232 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 233 } |
| 234 // var log = stdlib.Math.log; |
| 235 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 236 CHECK_VAR(log, DEFAULT_TYPE); |
| 237 CHECK_VAR(stdlib, DEFAULT_TYPE); |
| 238 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 239 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 240 } |
| 241 // var values = new stdlib.Float64Array(buffer); |
| 242 CHECK_EXPR(Assignment, DEFAULT_TYPE) { |
| 243 CHECK_VAR(values, DEFAULT_TYPE); |
| 244 CHECK_EXPR(CallNew, DEFAULT_TYPE) { |
| 245 CHECK_VAR(stdlib, DEFAULT_TYPE); |
| 246 CHECK_EXPR(Literal, DEFAULT_TYPE); |
| 247 CHECK_VAR(buffer, DEFAULT_TYPE); |
| 248 } |
| 249 } |
| 250 // return { geometricMean: geometricMean }; |
| 251 CHECK_EXPR(ObjectLiteral, DEFAULT_TYPE) { |
| 252 CHECK_VAR(geometricMean, DEFAULT_TYPE); |
| 253 } |
| 254 } |
| 255 } |
| 256 CHECK_TYPES_END |
| 257 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1288773007:
Adding visitors to regurgitate expression types or reset them. (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master