deps/v8/src/compiler/ast-loop-assignment-analyzer.cc

   1 // Copyright 2014 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 "src/compiler/ast-loop-assignment-analyzer.h"
   6 #include "src/compiler.h"
   7 #include "src/parser.h"
   8
   9 namespace v8 {
  10 namespace internal {
  11 namespace compiler {
  12
  13 typedef class AstLoopAssignmentAnalyzer ALAA;  // for code shortitude.
  14
  15 ALAA::AstLoopAssignmentAnalyzer(Zone* zone, CompilationInfo* info)
  16     : info_(info), loop_stack_(zone) {
  17   InitializeAstVisitor(info->isolate(), zone);
  18 }
  19
  20
  21 LoopAssignmentAnalysis* ALAA::Analyze() {
  22   LoopAssignmentAnalysis* a = new (zone()) LoopAssignmentAnalysis(zone());
  23   result_ = a;
  24   VisitStatements(info()->function()->body());
  25   result_ = NULL;
  26   return a;
  27 }
  28
  29
  30 void ALAA::Enter(IterationStatement* loop) {
  31   int num_variables = 1 + info()->scope()->num_parameters() +
  32                       info()->scope()->num_stack_slots();
  33   BitVector* bits = new (zone()) BitVector(num_variables, zone());
  34   if (info()->is_osr() && info()->osr_ast_id() == loop->OsrEntryId())
  35     bits->AddAll();
  36   loop_stack_.push_back(bits);
  37 }
  38
  39
  40 void ALAA::Exit(IterationStatement* loop) {
  41   DCHECK(loop_stack_.size() > 0);
  42   BitVector* bits = loop_stack_.back();
  43   loop_stack_.pop_back();
  44   if (!loop_stack_.empty()) {
  45     loop_stack_.back()->Union(*bits);
  46   }
  47   result_->list_.push_back(
  48       std::pair<IterationStatement*, BitVector*>(loop, bits));
  49 }
  50
  51
  52 // ---------------------------------------------------------------------------
  53 // -- Leaf nodes -------------------------------------------------------------
  54 // ---------------------------------------------------------------------------
  55
  56 void ALAA::VisitVariableDeclaration(VariableDeclaration* leaf) {}
  57 void ALAA::VisitFunctionDeclaration(FunctionDeclaration* leaf) {}
  58 void ALAA::VisitModuleDeclaration(ModuleDeclaration* leaf) {}
  59 void ALAA::VisitImportDeclaration(ImportDeclaration* leaf) {}
  60 void ALAA::VisitExportDeclaration(ExportDeclaration* leaf) {}
  61 void ALAA::VisitModulePath(ModulePath* leaf) {}
  62 void ALAA::VisitModuleUrl(ModuleUrl* leaf) {}
  63 void ALAA::VisitEmptyStatement(EmptyStatement* leaf) {}
  64 void ALAA::VisitContinueStatement(ContinueStatement* leaf) {}
  65 void ALAA::VisitBreakStatement(BreakStatement* leaf) {}
  66 void ALAA::VisitDebuggerStatement(DebuggerStatement* leaf) {}
  67 void ALAA::VisitFunctionLiteral(FunctionLiteral* leaf) {}
  68 void ALAA::VisitNativeFunctionLiteral(NativeFunctionLiteral* leaf) {}
  69 void ALAA::VisitVariableProxy(VariableProxy* leaf) {}
  70 void ALAA::VisitLiteral(Literal* leaf) {}
  71 void ALAA::VisitRegExpLiteral(RegExpLiteral* leaf) {}
  72 void ALAA::VisitThisFunction(ThisFunction* leaf) {}
  73 void ALAA::VisitSuperReference(SuperReference* leaf) {}
  74
  75
  76 // ---------------------------------------------------------------------------
  77 // -- Pass-through nodes------------------------------------------------------
  78 // ---------------------------------------------------------------------------
  79 void ALAA::VisitModuleLiteral(ModuleLiteral* e) { Visit(e->body()); }
  80
  81
  82 void ALAA::VisitBlock(Block* stmt) { VisitStatements(stmt->statements()); }
  83
  84
  85 void ALAA::VisitExpressionStatement(ExpressionStatement* stmt) {
  86   Visit(stmt->expression());
  87 }
  88
  89
  90 void ALAA::VisitIfStatement(IfStatement* stmt) {
  91   Visit(stmt->condition());
  92   Visit(stmt->then_statement());
  93   Visit(stmt->else_statement());
  94 }
  95
  96
  97 void ALAA::VisitReturnStatement(ReturnStatement* stmt) {
  98   Visit(stmt->expression());
  99 }
 100
 101
 102 void ALAA::VisitWithStatement(WithStatement* stmt) {
 103   Visit(stmt->expression());
 104   Visit(stmt->statement());
 105 }
 106
 107
 108 void ALAA::VisitSwitchStatement(SwitchStatement* stmt) {
 109   Visit(stmt->tag());
 110   ZoneList<CaseClause*>* clauses = stmt->cases();
 111   for (int i = 0; i < clauses->length(); i++) {
 112     Visit(clauses->at(i));
 113   }
 114 }
 115
 116
 117 void ALAA::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
 118   Visit(stmt->try_block());
 119   Visit(stmt->finally_block());
 120 }
 121
 122
 123 void ALAA::VisitClassLiteral(ClassLiteral* e) {
 124   VisitIfNotNull(e->extends());
 125   VisitIfNotNull(e->constructor());
 126   ZoneList<ObjectLiteralProperty*>* properties = e->properties();
 127   for (int i = 0; i < properties->length(); i++) {
 128     Visit(properties->at(i)->value());
 129   }
 130 }
 131
 132
 133 void ALAA::VisitConditional(Conditional* e) {
 134   Visit(e->condition());
 135   Visit(e->then_expression());
 136   Visit(e->else_expression());
 137 }
 138
 139
 140 void ALAA::VisitObjectLiteral(ObjectLiteral* e) {
 141   ZoneList<ObjectLiteralProperty*>* properties = e->properties();
 142   for (int i = 0; i < properties->length(); i++) {
 143     Visit(properties->at(i)->value());
 144   }
 145 }
 146
 147
 148 void ALAA::VisitArrayLiteral(ArrayLiteral* e) { VisitExpressions(e->values()); }
 149
 150
 151 void ALAA::VisitYield(Yield* stmt) {
 152   Visit(stmt->generator_object());
 153   Visit(stmt->expression());
 154 }
 155
 156
 157 void ALAA::VisitThrow(Throw* stmt) { Visit(stmt->exception()); }
 158
 159
 160 void ALAA::VisitProperty(Property* e) {
 161   Visit(e->obj());
 162   Visit(e->key());
 163 }
 164
 165
 166 void ALAA::VisitCall(Call* e) {
 167   Visit(e->expression());
 168   VisitExpressions(e->arguments());
 169 }
 170
 171
 172 void ALAA::VisitCallNew(CallNew* e) {
 173   Visit(e->expression());
 174   VisitExpressions(e->arguments());
 175 }
 176
 177
 178 void ALAA::VisitCallRuntime(CallRuntime* e) {
 179   VisitExpressions(e->arguments());
 180 }
 181
 182
 183 void ALAA::VisitUnaryOperation(UnaryOperation* e) { Visit(e->expression()); }
 184
 185
 186 void ALAA::VisitBinaryOperation(BinaryOperation* e) {
 187   Visit(e->left());
 188   Visit(e->right());
 189 }
 190
 191
 192 void ALAA::VisitCompareOperation(CompareOperation* e) {
 193   Visit(e->left());
 194   Visit(e->right());
 195 }
 196
 197
 198 void ALAA::VisitCaseClause(CaseClause* cc) {
 199   if (!cc->is_default()) Visit(cc->label());
 200   VisitStatements(cc->statements());
 201 }
 202
 203
 204 // ---------------------------------------------------------------------------
 205 // -- Interesting nodes-------------------------------------------------------
 206 // ---------------------------------------------------------------------------
 207 void ALAA::VisitModuleStatement(ModuleStatement* stmt) {
 208   // TODO(turbofan): can a module appear in a loop?
 209   Visit(stmt->body());
 210 }
 211
 212
 213 void ALAA::VisitTryCatchStatement(TryCatchStatement* stmt) {
 214   Visit(stmt->try_block());
 215   Visit(stmt->catch_block());
 216   // TODO(turbofan): are catch variables well-scoped?
 217   AnalyzeAssignment(stmt->variable());
 218 }
 219
 220
 221 void ALAA::VisitDoWhileStatement(DoWhileStatement* loop) {
 222   Enter(loop);
 223   Visit(loop->body());
 224   Visit(loop->cond());
 225   Exit(loop);
 226 }
 227
 228
 229 void ALAA::VisitWhileStatement(WhileStatement* loop) {
 230   Enter(loop);
 231   Visit(loop->cond());
 232   Visit(loop->body());
 233   Exit(loop);
 234 }
 235
 236
 237 void ALAA::VisitForStatement(ForStatement* loop) {
 238   VisitIfNotNull(loop->init());
 239   Enter(loop);
 240   VisitIfNotNull(loop->cond());
 241   Visit(loop->body());
 242   VisitIfNotNull(loop->next());
 243   Exit(loop);
 244 }
 245
 246
 247 void ALAA::VisitForInStatement(ForInStatement* loop) {
 248   Enter(loop);
 249   Visit(loop->each());
 250   Visit(loop->subject());
 251   Visit(loop->body());
 252   Exit(loop);
 253 }
 254
 255
 256 void ALAA::VisitForOfStatement(ForOfStatement* loop) {
 257   Enter(loop);
 258   Visit(loop->each());
 259   Visit(loop->subject());
 260   Visit(loop->body());
 261   Exit(loop);
 262 }
 263
 264
 265 void ALAA::VisitAssignment(Assignment* stmt) {
 266   Expression* l = stmt->target();
 267   Visit(l);
 268   Visit(stmt->value());
 269   if (l->IsVariableProxy()) AnalyzeAssignment(l->AsVariableProxy()->var());
 270 }
 271
 272
 273 void ALAA::VisitCountOperation(CountOperation* e) {
 274   Expression* l = e->expression();
 275   Visit(l);
 276   if (l->IsVariableProxy()) AnalyzeAssignment(l->AsVariableProxy()->var());
 277 }
 278
 279
 280 void ALAA::AnalyzeAssignment(Variable* var) {
 281   if (!loop_stack_.empty() && var->IsStackAllocated()) {
 282     loop_stack_.back()->Add(GetVariableIndex(info()->scope(), var));
 283   }
 284 }
 285
 286
 287 int ALAA::GetVariableIndex(Scope* scope, Variable* var) {
 288   CHECK(var->IsStackAllocated());
 289   if (var->is_this()) return 0;
 290   if (var->IsParameter()) return 1 + var->index();
 291   return 1 + scope->num_parameters() + var->index();
 292 }
 293
 294
 295 int LoopAssignmentAnalysis::GetAssignmentCountForTesting(Scope* scope,
 296                                                          Variable* var) {
 297   int count = 0;
 298   int var_index = AstLoopAssignmentAnalyzer::GetVariableIndex(scope, var);
 299   for (size_t i = 0; i < list_.size(); i++) {
 300     if (list_[i].second->Contains(var_index)) count++;
 301   }
 302   return count;
 303 }
 304 }
 305 }
 306 }  // namespace v8::internal::compiler