dart::compiler::Intrinsifier Class Reference

#include <intrinsifier.h>

Inheritance diagram for dart::compiler::Intrinsifier:

Static Public Member Functions
static bool	Intrinsify (const ParsedFunction &parsed_function, FlowGraphCompiler *compiler)
static void	InitializeState ()

Detailed Description

Definition at line 29 of file intrinsifier.h.

Member Function Documentation

InitializeState()

void dart::compiler::Intrinsifier::InitializeState ( )

static

Definition at line 115 of file intrinsifier.cc.

                                   {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  Library& lib = Library::Handle(zone);
  Class& cls = Class::Handle(zone);
  Function& func = Function::Handle(zone);
  String& str = String::Handle(zone);
  String& str2 = String::Handle(zone);
  Error& error = Error::Handle(zone);
 
  const intptr_t kNumLibs = 4;
  const LibraryIntrinsicsDesc intrinsics[kNumLibs] = {
      {Library::Handle(zone, Library::CoreLibrary()), core_intrinsics},
      {Library::Handle(zone, Library::TypedDataLibrary()),
       typed_data_intrinsics},
      {Library::Handle(zone, Library::DeveloperLibrary()),
       developer_intrinsics},
      {Library::Handle(zone, Library::InternalLibrary()), internal_intrinsics},
  };
 
  for (intptr_t i = 0; i < kNumLibs; i++) {
    lib = intrinsics[i].library.ptr();
    for (const IntrinsicDesc* intrinsic = intrinsics[i].intrinsics;
         intrinsic->class_name != nullptr; intrinsic++) {
      func = Function::null();
      if (strcmp(intrinsic->class_name, "::") == 0) {
        str = String::New(intrinsic->function_name);
        func = lib.LookupFunctionAllowPrivate(str);
      } else {
        str = String::New(intrinsic->class_name);
        cls = lib.LookupClassAllowPrivate(str);
        ASSERT(FLAG_precompiled_mode || !cls.IsNull());
        if (!cls.IsNull()) {
          error = cls.EnsureIsFinalized(thread);
          if (!error.IsNull()) {
            OS::PrintErr("%s\n", error.ToErrorCString());
          }
          ASSERT(error.IsNull());
          str = String::New(intrinsic->function_name);
          if (intrinsic->function_name[0] == '.') {
            str2 = String::New(intrinsic->class_name);
            str = String::Concat(str2, str);
          }
          func = cls.LookupFunctionAllowPrivate(str);
        }
      }
      if (!func.IsNull()) {
        func.set_is_intrinsic(true);
      } else if (!FLAG_precompiled_mode) {
        FATAL("Intrinsifier failed to find method %s in class %s\n",
              intrinsic->function_name, intrinsic->class_name);
      }
    }
  }
#undef SETUP_FUNCTION
}

Intrinsify()

bool dart::compiler::Intrinsifier::Intrinsify ( const ParsedFunction &  parsed_function, FlowGraphCompiler *  compiler  )

static

Definition at line 173 of file intrinsifier.cc.

                                                           {
  if (!CanIntrinsify(parsed_function)) {
    return false;
  }
 
  if (GraphIntrinsifier::GraphIntrinsify(parsed_function, compiler)) {
    return compiler->intrinsic_slow_path_label()->IsUnused();
  }
 
  const Function& function = parsed_function.function();
#if !defined(HASH_IN_OBJECT_HEADER)
  // These two are more complicated on 32 bit platforms, where the
  // identity hash is not stored in the header of the object.  We
  // therefore don't intrinsify them, falling back on the native C++
  // implementations.
  if (function.recognized_kind() == MethodRecognizer::kObject_getHash) {
    return false;
  }
#endif
 
#if !defined(PRODUCT)
#define EMIT_BREAKPOINT() compiler->assembler()->Breakpoint()
#else
#define EMIT_BREAKPOINT()
#endif
 
#define EMIT_CASE(class_name, function_name, enum_name, fp)                    \
  case MethodRecognizer::k##enum_name: {                                       \
    compiler->assembler()->Comment("Intrinsic");                               \
    Label normal_ir_body;                                                      \
    const auto size_before = compiler->assembler()->CodeSize();                \
    AsmIntrinsifier::enum_name(compiler->assembler(), &normal_ir_body);        \
    const auto size_after = compiler->assembler()->CodeSize();                 \
    if (size_before == size_after) return false;                               \
    if (function.HasUnboxedParameters()) {                                     \
      FATAL("Unsupported unboxed parameters in asm intrinsic %s",              \
            function.ToFullyQualifiedCString());                               \
    }                                                                          \
    if (function.HasUnboxedReturnValue()) {                                    \
      FATAL("Unsupported unboxed return value in asm intrinsic %s",            \
            function.ToFullyQualifiedCString());                               \
    }                                                                          \
    if (!normal_ir_body.IsBound()) {                                           \
      EMIT_BREAKPOINT();                                                       \
      return true;                                                             \
    }                                                                          \
    return false;                                                              \
  }
 
  switch (function.recognized_kind()) {
    ALL_INTRINSICS_NO_INTEGER_LIB_LIST(EMIT_CASE);
    default:
      break;
  }
  switch (function.recognized_kind()) {
    CORE_INTEGER_LIB_INTRINSIC_LIST(EMIT_CASE)
    default:
      break;
  }
 
#undef EMIT_BREAKPOINT
 
#undef EMIT_INTRINSIC
  return false;
}

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/compiler/intrinsifier.h
• third_party/dart-lang/sdk/runtime/vm/compiler/intrinsifier.cc