src/v8/test/cctest/compiler/test-schedule.cc

   1 // Copyright 2013 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/v8.h"
   6
   7 #include "src/compiler/common-operator.h"
   8 #include "src/compiler/generic-node-inl.h"
   9 #include "src/compiler/graph.h"
  10 #include "src/compiler/machine-operator.h"
  11 #include "src/compiler/node.h"
  12 #include "src/compiler/operator.h"
  13 #include "src/compiler/schedule.h"
  14 #include "test/cctest/cctest.h"
  15
  16 using namespace v8::internal;
  17 using namespace v8::internal::compiler;
  18
  19 static SimpleOperator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
  20                                      0, 0, "dummy");
  21
  22 TEST(TestScheduleAllocation) {
  23   HandleAndZoneScope scope;
  24   Schedule schedule(scope.main_zone());
  25
  26   CHECK_NE(NULL, schedule.start());
  27   CHECK_EQ(schedule.start(), *(schedule.all_blocks().begin()));
  28 }
  29
  30
  31 TEST(TestScheduleAddNode) {
  32   HandleAndZoneScope scope;
  33   Graph graph(scope.main_zone());
  34   Node* n0 = graph.NewNode(&dummy_operator);
  35   Node* n1 = graph.NewNode(&dummy_operator);
  36
  37   Schedule schedule(scope.main_zone());
  38
  39   BasicBlock* entry = schedule.start();
  40   schedule.AddNode(entry, n0);
  41   schedule.AddNode(entry, n1);
  42
  43   CHECK_EQ(entry, schedule.block(n0));
  44   CHECK_EQ(entry, schedule.block(n1));
  45   CHECK(schedule.SameBasicBlock(n0, n1));
  46
  47   Node* n2 = graph.NewNode(&dummy_operator);
  48   CHECK_EQ(NULL, schedule.block(n2));
  49 }
  50
  51
  52 TEST(TestScheduleAddGoto) {
  53   HandleAndZoneScope scope;
  54
  55   Schedule schedule(scope.main_zone());
  56   BasicBlock* entry = schedule.start();
  57   BasicBlock* next = schedule.NewBasicBlock();
  58
  59   schedule.AddGoto(entry, next);
  60
  61   CHECK_EQ(0, entry->PredecessorCount());
  62   CHECK_EQ(1, entry->SuccessorCount());
  63   CHECK_EQ(next, entry->SuccessorAt(0));
  64
  65   CHECK_EQ(1, next->PredecessorCount());
  66   CHECK_EQ(entry, next->PredecessorAt(0));
  67   CHECK_EQ(0, next->SuccessorCount());
  68 }
  69
  70
  71 TEST(TestScheduleAddBranch) {
  72   HandleAndZoneScope scope;
  73   Schedule schedule(scope.main_zone());
  74
  75   BasicBlock* entry = schedule.start();
  76   BasicBlock* tblock = schedule.NewBasicBlock();
  77   BasicBlock* fblock = schedule.NewBasicBlock();
  78
  79   Graph graph(scope.main_zone());
  80   CommonOperatorBuilder common(scope.main_zone());
  81   Node* n0 = graph.NewNode(&dummy_operator);
  82   Node* b = graph.NewNode(common.Branch(), n0);
  83
  84   schedule.AddBranch(entry, b, tblock, fblock);
  85
  86   CHECK_EQ(0, entry->PredecessorCount());
  87   CHECK_EQ(2, entry->SuccessorCount());
  88   CHECK_EQ(tblock, entry->SuccessorAt(0));
  89   CHECK_EQ(fblock, entry->SuccessorAt(1));
  90
  91   CHECK_EQ(1, tblock->PredecessorCount());
  92   CHECK_EQ(entry, tblock->PredecessorAt(0));
  93   CHECK_EQ(0, tblock->SuccessorCount());
  94
  95   CHECK_EQ(1, fblock->PredecessorCount());
  96   CHECK_EQ(entry, fblock->PredecessorAt(0));
  97   CHECK_EQ(0, fblock->SuccessorCount());
  98 }
  99
 100
 101 TEST(TestScheduleAddReturn) {
 102   HandleAndZoneScope scope;
 103   Schedule schedule(scope.main_zone());
 104   Graph graph(scope.main_zone());
 105   Node* n0 = graph.NewNode(&dummy_operator);
 106   BasicBlock* entry = schedule.start();
 107   schedule.AddReturn(entry, n0);
 108
 109   CHECK_EQ(0, entry->PredecessorCount());
 110   CHECK_EQ(1, entry->SuccessorCount());
 111   CHECK_EQ(schedule.end(), entry->SuccessorAt(0));
 112 }
 113
 114
 115 TEST(TestScheduleAddThrow) {
 116   HandleAndZoneScope scope;
 117   Schedule schedule(scope.main_zone());
 118   Graph graph(scope.main_zone());
 119   Node* n0 = graph.NewNode(&dummy_operator);
 120   BasicBlock* entry = schedule.start();
 121   schedule.AddThrow(entry, n0);
 122
 123   CHECK_EQ(0, entry->PredecessorCount());
 124   CHECK_EQ(1, entry->SuccessorCount());
 125   CHECK_EQ(schedule.end(), entry->SuccessorAt(0));
 126 }
 127
 128
 129 TEST(BuildMulNodeGraph) {
 130   HandleAndZoneScope scope;
 131   Schedule schedule(scope.main_zone());
 132   Graph graph(scope.main_zone());
 133   CommonOperatorBuilder common(scope.main_zone());
 134   MachineOperatorBuilder machine;
 135
 136   Node* start = graph.NewNode(common.Start(0));
 137   graph.SetStart(start);
 138   Node* param0 = graph.NewNode(common.Parameter(0), graph.start());
 139   Node* param1 = graph.NewNode(common.Parameter(1), graph.start());
 140
 141   Node* mul = graph.NewNode(machine.Int32Mul(), param0, param1);
 142   Node* ret = graph.NewNode(common.Return(), mul, start);
 143
 144   USE(ret);
 145 }