il_test_helper.h File Reference

#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
#include "include/dart_api.h"
#include "platform/allocation.h"
#include "vm/compiler/backend/flow_graph.h"
#include "vm/compiler/backend/il.h"
#include "vm/compiler/backend/inliner.h"
#include "vm/compiler/compiler_pass.h"
#include "vm/compiler/compiler_state.h"
#include "vm/compiler/jit/compiler.h"
#include "vm/unit_test.h"

Go to the source code of this file.

Classes
class	dart::TestPipeline
class	dart::MatchCode
class	dart::ILMatcher
class	dart::FlowGraphBuilderHelper
class	dart::FlowGraphBuilderHelper::IncomingDef

Namespaces
namespace	dart

Macros
#define	DEFINE_MATCH_OPCODES(Instruction, _)
#define	DEFINE_TYPED_CONSTRUCTOR(Type, ignored)
#define	ENTITY_TOCSTRING(v)   ((v)->ToCString())
#define	EXPECT_PROPERTY(entity, property)

Enumerations
enum	dart::MatchOpCode {   dart::kMatchAndMoveBranchTrue , dart::kMatchAndMoveBranchFalse , dart::kNop , dart::kMoveAny ,   dart::kMoveParallelMoves , dart::kMoveGlob , dart::kMoveDebugStepChecks , dart::kInvalidMatchOpCode }
enum class	dart::ParallelMovesHandling { dart::kDefault , dart::kSkip }

Functions
LibraryPtr	dart::LoadTestScript (const char *script, Dart_NativeEntryResolver resolver, const char *lib_uri)
	dart::NOT_IN_PRODUCT (LibraryPtr ReloadTestScript(const char *script))
FunctionPtr	dart::GetFunction (const Library &lib, const char *name)
ClassPtr	dart::GetClass (const Library &lib, const char *name)
TypeParameterPtr	dart::GetClassTypeParameter (const Class &klass, intptr_t index)
TypeParameterPtr	dart::GetFunctionTypeParameter (const Function &fun, intptr_t index)
ObjectPtr	dart::Invoke (const Library &lib, const char *name)
InstructionsPtr	dart::BuildInstructions (std::function< void(compiler::Assembler *assembler)> fun)

Macro Definition Documentation

DEFINE_MATCH_OPCODES

#define DEFINE_MATCH_OPCODES	(		Instruction,
			_
	)

Value:

  kMatch##Instruction, kMatchAndMove##Instruction,                             \
      kMatchAndMoveOptional##Instruction,

Definition at line 119 of file il_test_helper.h.

                {
 public:
  MatchCode(MatchOpCode opcode)  // NOLINT
      : opcode_(opcode), capture_(nullptr) {}
 
  MatchCode(MatchOpCode opcode, Instruction** capture)
      : opcode_(opcode), capture_(capture) {}
 
#define DEFINE_TYPED_CONSTRUCTOR(Type, ignored)                                \
  MatchCode(MatchOpCode opcode, Type##Instr** capture)                         \
      : opcode_(opcode), capture_(reinterpret_cast<Instruction**>(capture)) {  \
    RELEASE_ASSERT(opcode == kMatch##Type || opcode == kMatchAndMove##Type);   \
  }
  FOR_EACH_INSTRUCTION(DEFINE_TYPED_CONSTRUCTOR)
  FOR_EACH_ABSTRACT_INSTRUCTION(DEFINE_TYPED_CONSTRUCTOR)
#undef DEFINE_TYPED_CONSTRUCTOR
 
  MatchOpCode opcode() { return opcode_; }
 
 private:
  friend class ILMatcher;
 
  MatchOpCode opcode_;
  Instruction** capture_;
};
 
enum class ParallelMovesHandling {
  // Matcher doesn't do anything special with ParallelMove instructions.
  kDefault,
  // All ParallelMove instructions are skipped.
  // This mode is useful when matching a flow graph after the whole
  // compiler pipeline, as it may have ParallelMove instructions
  // at arbitrary architecture-dependent places.
  kSkip,
};
 
// Used for matching a sequence of IL instructions including capturing support.
//
// Example:
//
//     TargetEntryInstr* entry = ....;
//     BranchInstr* branch = nullptr;
//
//     ILMatcher matcher(flow_graph, entry);
//     if (matcher.TryMatch({ kMoveGlob, {kMatchBranch, &branch}, })) {
//       EXPECT(branch->operation_cid() == kMintCid);
//       ...
//     }
//
// This match will start at [entry], follow any number instructions (including
// [GotoInstr]s until a [BranchInstr] is found).
//
// If the match was successful, this returns `true` and updates the current
// value for the cursor.
class ILMatcher : public ValueObject {
 public:
  ILMatcher(FlowGraph* flow_graph,
            Instruction* cursor,
            bool trace = true,
            ParallelMovesHandling parallel_moves_handling =
                ParallelMovesHandling::kDefault)
      : flow_graph_(flow_graph),
        cursor_(cursor),
        parallel_moves_handling_(parallel_moves_handling),
  // clang-format off
#if !defined(PRODUCT)
        trace_(trace) {}
#else
        trace_(false) {}
#endif
  // clang-format on
 
  Instruction* value() { return cursor_; }
 
  // From the current [value] according to match_codes.
  //
  // Returns `true` if the match was successful and cursor has been updated,
  // otherwise returns `false`.
  //
  // If [insert_before] is a valid match opcode, then it will be inserted
  // before each MatchCode in [match_codes] prior to matching.
  bool TryMatch(std::initializer_list<MatchCode> match_codes,
                MatchOpCode insert_before = kInvalidMatchOpCode);
 
 private:
  Instruction* MatchInternal(std::vector<MatchCode> match_codes,
                             size_t i,
                             Instruction* cursor);
 
  const char* MatchOpCodeToCString(MatchOpCode code);
 
  FlowGraph* flow_graph_;
  Instruction* cursor_;
  ParallelMovesHandling parallel_moves_handling_;
  bool trace_;
};
 
#if !defined(PRODUCT)
#define ENTITY_TOCSTRING(v) ((v)->ToCString())
#else
#define ENTITY_TOCSTRING(v) "<?>"
#endif
 
// Helper to check various IL and object properties and informative error
// messages if check fails. [entity] should be a pointer to a value.
// [property] should be an expression which can refer to [entity] using
// variable named [it].
// [entity] is expected to have a ToCString() method in non-PRODUCT builds.
#define EXPECT_PROPERTY(entity, property)                                      \
  do {                                                                         \
    auto& it = *entity;                                                        \
    if (!(property)) {                                                         \
      dart::Expect(__FILE__, __LINE__)                                         \
          .Fail("expected " #property " for " #entity " which is %s.\n",       \
                ENTITY_TOCSTRING(entity));                                     \
    }                                                                          \
  } while (0)
 
class FlowGraphBuilderHelper {
 public:
  explicit FlowGraphBuilderHelper(intptr_t num_parameters = 0)
      : state_(CompilerState::Current()),
        flow_graph_(MakeDummyGraph(Thread::Current(),
                                   num_parameters,
                                   state_.is_optimizing())) {
    flow_graph_.CreateCommonConstants();
  }
 
  TargetEntryInstr* TargetEntry(intptr_t try_index = kInvalidTryIndex) const {
    return new TargetEntryInstr(flow_graph_.allocate_block_id(), try_index,
                                state_.GetNextDeoptId());
  }
 
  JoinEntryInstr* JoinEntry(intptr_t try_index = kInvalidTryIndex) const {
    return new JoinEntryInstr(flow_graph_.allocate_block_id(), try_index,
                              state_.GetNextDeoptId());
  }
 
  ConstantInstr* IntConstant(int64_t value) const {
    return flow_graph_.GetConstant(
        Integer::Handle(Integer::NewCanonical(value)));
  }
 
  ConstantInstr* DoubleConstant(double value) {
    return flow_graph_.GetConstant(Double::Handle(Double::NewCanonical(value)));
  }
 
  // Adds a variable into the scope which would provide inferred argument type
  // for the parameter.
  void AddVariable(const char* name,
                   const AbstractType& static_type,
                   CompileType* inferred_arg_type = nullptr) {
    LocalVariable* v =
        new LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                          String::Handle(Symbols::New(Thread::Current(), name)),
                          static_type, LocalVariable::kNoKernelOffset,
                          new CompileType(CompileType::FromAbstractType(
                              static_type, CompileType::kCanBeNull,
                              CompileType::kCannotBeSentinel)),
                          inferred_arg_type);
    v->set_type_check_mode(LocalVariable::kTypeCheckedByCaller);
    flow_graph()->parsed_function().scope()->AddVariable(v);
  }
 
  enum class IncomingDefKind {
    kImmediate,
    kDelayed,
  };
 
  class IncomingDef {
   public:
    IncomingDef(BlockEntryInstr* from, Definition* defn)
        : kind_(IncomingDefKind::kImmediate), from_(from), defn_(defn) {}
 
    template <typename T,
              typename = typename std::enable_if<
                  std::is_base_of<Definition, T>::value>::type>
    IncomingDef(BlockEntryInstr* from, T** defn_source)
        : kind_(IncomingDefKind::kDelayed),
          from_(from),
          defn_source_(reinterpret_cast<Definition**>(defn_source)) {}
 
    BlockEntryInstr* from() const { return from_; }
    Definition* defn() const {
      return kind_ == IncomingDefKind::kImmediate ? defn_ : *defn_source_;
    }
 
   private:
    IncomingDefKind kind_;
    BlockEntryInstr* from_;
    union {
      Definition* defn_;
      Definition** defn_source_;
    };
  };
 
  PhiInstr* Phi(JoinEntryInstr* join,
                std::initializer_list<IncomingDef> incoming) {
    auto phi = new PhiInstr(join, incoming.size());
    for (size_t i = 0; i < incoming.size(); i++) {
      auto input = new Value(flow_graph_.constant_dead());
      phi->SetInputAt(i, input);
      input->definition()->AddInputUse(input);
    }
    for (auto def : incoming) {
      pending_phis_.Add({phi, def});
    }
    return phi;
  }
 
  void FinishGraph() {
    flow_graph_.DiscoverBlocks();
    GrowableArray<BitVector*> dominance_frontier;
    flow_graph_.ComputeDominators(&dominance_frontier);
 
    for (auto& pending : pending_phis_) {
      auto join = pending.phi->block();
      EXPECT(pending.phi->InputCount() == join->PredecessorCount());
      auto pred_index = join->IndexOfPredecessor(pending.incoming.from());
      EXPECT(pred_index != -1);
      pending.phi->InputAt(pred_index)->BindTo(pending.incoming.defn());
    }
  }
 
  FlowGraph* flow_graph() { return &flow_graph_; }
 
 private:
  static FlowGraph& MakeDummyGraph(Thread* thread,
                                   intptr_t num_parameters,
                                   bool is_optimizing) {
    const FunctionType& signature =
        FunctionType::ZoneHandle(FunctionType::New());
    signature.set_num_fixed_parameters(num_parameters);
    const Function& func = Function::ZoneHandle(Function::New(
        signature, String::Handle(Symbols::New(thread, "dummy")),
        UntaggedFunction::kRegularFunction,
        /*is_static=*/true,
        /*is_const=*/false,
        /*is_abstract=*/false,
        /*is_external=*/false,
        /*is_native=*/true,
        Class::Handle(thread->isolate_group()->object_store()->object_class()),
        TokenPosition::kNoSource));
 
    Zone* zone = thread->zone();
    ParsedFunction* parsed_function = new (zone) ParsedFunction(thread, func);
 
    parsed_function->set_scope(new LocalScope(nullptr, 0, 0));
 
    auto graph_entry =
        new GraphEntryInstr(*parsed_function, Compiler::kNoOSRDeoptId);
 
    const intptr_t block_id = 1;  // 0 is GraphEntry.
    graph_entry->set_normal_entry(
        new FunctionEntryInstr(graph_entry, block_id, kInvalidTryIndex,
                               CompilerState::Current().GetNextDeoptId()));
    return *new FlowGraph(*parsed_function, graph_entry, block_id,
                          PrologueInfo{-1, -1},
                          FlowGraph::CompilationModeFrom(is_optimizing));
  }
 
  CompilerState& state_;
  FlowGraph& flow_graph_;
 
  struct PendingPhiInput {
    PhiInstr* phi;
    IncomingDef incoming;
  };
  GrowableArray<PendingPhiInput> pending_phis_;
};
 
}  // namespace dart
 
#endif  // RUNTIME_VM_COMPILER_BACKEND_IL_TEST_HELPER_H_

DEFINE_TYPED_CONSTRUCTOR

#define DEFINE_TYPED_CONSTRUCTOR	(		Type,
			ignored
	)

Value:

  MatchCode(MatchOpCode opcode, Type##Instr** capture)                         \
      : opcode_(opcode), capture_(reinterpret_cast<Instruction**>(capture)) {  \
    RELEASE_ASSERT(opcode == kMatch##Type || opcode == kMatchAndMove##Type);   \
  }

Definition at line 161 of file il_test_helper.h.

      : opcode_(opcode), capture_(reinterpret_cast<Instruction**>(capture)) {  \
    RELEASE_ASSERT(opcode == kMatch##Type || opcode == kMatchAndMove##Type);   \
  }

ENTITY_TOCSTRING

#define ENTITY_TOCSTRING

(

v

)

((v)->ToCString())

Definition at line 251 of file il_test_helper.h.

EXPECT_PROPERTY

#define EXPECT_PROPERTY	(		entity,
			property
	)

Value:

  do {                                                                         \
    auto& it = *entity;                                                        \
    if (!(property)) {                                                         \
      dart::Expect(__FILE__, __LINE__)                                         \
          .Fail("expected " #property " for " #entity " which is %s.\n",       \
                ENTITY_TOCSTRING(entity));                                     \
    }                                                                          \
  } while (0)

Definition at line 261 of file il_test_helper.h.

     {                                                                         \
    auto& it = *entity;                                                        \
    if (!(property)) {                                                         \
      dart::Expect(__FILE__, __LINE__)                                         \
          .Fail("expected " #property " for " #entity " which is %s.\n",       \
                ENTITY_TOCSTRING(entity));                                     \
    }                                                                          \
  } while (0)