Home | History | Annotate | Download | only in compiler 
      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 }
    146