basic-block-instrumentor.cc 4.04 KB
Newer Older
1 2 3 4 5
// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/compiler/basic-block-instrumentor.h"
6 7 8

#include <sstream>

9 10 11
#include "src/compiler/common-operator.h"
#include "src/compiler/graph.h"
#include "src/compiler/machine-operator.h"
12
#include "src/compiler/node.h"
13
#include "src/compiler/operator-properties.h"
14
#include "src/compiler/schedule.h"
15
#include "src/objects-inl.h"
16
#include "src/optimized-compilation-info.h"
17 18 19 20 21 22 23

namespace v8 {
namespace internal {
namespace compiler {

// Find the first place to insert new nodes in a block that's already been
// scheduled that won't upset the register allocator.
24 25 26
static NodeVector::iterator FindInsertionPoint(BasicBlock* block) {
  NodeVector::iterator i = block->begin();
  for (; i != block->end(); ++i) {
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
    const Operator* op = (*i)->op();
    if (OperatorProperties::IsBasicBlockBegin(op)) continue;
    switch (op->opcode()) {
      case IrOpcode::kParameter:
      case IrOpcode::kPhi:
      case IrOpcode::kEffectPhi:
        continue;
    }
    break;
  }
  return i;
}


// TODO(dcarney): need to mark code as non-serializable.
static const Operator* PointerConstant(CommonOperatorBuilder* common,
43 44 45
                                       intptr_t ptr) {
  return kPointerSize == 8 ? common->Int64Constant(ptr)
                           : common->Int32Constant(static_cast<int32_t>(ptr));
46 47 48
}

BasicBlockProfiler::Data* BasicBlockInstrumentor::Instrument(
49 50
    OptimizedCompilationInfo* info, Graph* graph, Schedule* schedule,
    Isolate* isolate) {
51 52 53
  // Basic block profiling disables concurrent compilation, so handle deref is
  // fine.
  AllowHandleDereference allow_handle_dereference;
54 55 56
  // Skip the exit block in profiles, since the register allocator can't handle
  // it and entry into it means falling off the end of the function anyway.
  size_t n_blocks = static_cast<size_t>(schedule->RpoBlockCount()) - 1;
57
  BasicBlockProfiler::Data* data = BasicBlockProfiler::Get()->NewData(n_blocks);
58
  // Set the function name.
59
  data->SetFunctionName(info->GetDebugName());
60 61
  // Capture the schedule string before instrumentation.
  {
62
    std::ostringstream os;
63 64 65 66 67 68 69
    os << *schedule;
    data->SetSchedule(&os);
  }
  // Add the increment instructions to the start of every block.
  CommonOperatorBuilder common(graph->zone());
  Node* zero = graph->NewNode(common.Int32Constant(0));
  Node* one = graph->NewNode(common.Int32Constant(1));
70
  MachineOperatorBuilder machine(graph->zone());
71 72 73 74 75
  BasicBlockVector* blocks = schedule->rpo_order();
  size_t block_number = 0;
  for (BasicBlockVector::iterator it = blocks->begin(); block_number < n_blocks;
       ++it, ++block_number) {
    BasicBlock* block = (*it);
76
    data->SetBlockRpoNumber(block_number, block->rpo_number());
77 78 79 80
    // TODO(dcarney): wire effect and control deps for load and store.
    // Construct increment operation.
    Node* base = graph->NewNode(
        PointerConstant(&common, data->GetCounterAddress(block_number)));
81
    Node* load = graph->NewNode(machine.Load(MachineType::Uint32()), base, zero,
82
                                graph->start(), graph->start());
83
    Node* inc = graph->NewNode(machine.Int32Add(), load, one);
84
    Node* store =
85 86
        graph->NewNode(machine.Store(StoreRepresentation(
                           MachineRepresentation::kWord32, kNoWriteBarrier)),
87
                       base, zero, inc, graph->start(), graph->start());
88 89 90 91
    // Insert the new nodes.
    static const int kArraySize = 6;
    Node* to_insert[kArraySize] = {zero, one, base, load, inc, store};
    int insertion_start = block_number == 0 ? 0 : 2;
92 93 94
    NodeVector::iterator insertion_point = FindInsertionPoint(block);
    block->InsertNodes(insertion_point, &to_insert[insertion_start],
                       &to_insert[kArraySize]);
95 96 97 98 99 100 101 102 103 104 105
    // Tell the scheduler about the new nodes.
    for (int i = insertion_start; i < kArraySize; ++i) {
      schedule->SetBlockForNode(block, to_insert[i]);
    }
  }
  return data;
}

}  // namespace compiler
}  // namespace internal
}  // namespace v8