dart::bin::DFE Class Reference

#include <dfe.h>

Public Member Functions
	DFE ()
	~DFE ()
void	Init ()
char *	frontend_filename () const
void	set_frontend_filename (const char *name)
void	set_use_dfe (bool value=true)
bool	UseDartFrontend () const
void	set_use_incremental_compiler (bool value)
bool	use_incremental_compiler () const
void	set_verbosity (Dart_KernelCompilationVerbosityLevel verbosity)
Dart_KernelCompilationVerbosityLevel	verbosity () const
const char *	GetPlatformBinaryFilename ()
void	set_application_kernel_buffer (uint8_t *buffer, intptr_t size)
void	application_kernel_buffer (const uint8_t **buffer, intptr_t *size) const
Dart_KernelCompilationResult	CompileScript (const char *script_uri, bool incremental, const char *package_config, bool for_snapshot, bool embedd_sources)
void	CompileAndReadScript (const char *script_uri, uint8_t **kernel_buffer, intptr_t *kernel_buffer_size, char **error, int *exit_code, const char *package_config, bool for_snapshot, bool embed_sources)
void	ReadScript (const char *script_uri, const AppSnapshot *app_snapshot, uint8_t **kernel_buffer, intptr_t *kernel_buffer_size, bool decode_uri=true, std::shared_ptr< uint8_t > *kernel_blob_ptr=nullptr)
bool	KernelServiceDillAvailable () const
bool	TryReadKernelFile (const char *script_uri, const AppSnapshot *app_snapshot, uint8_t **kernel_buffer, intptr_t *kernel_buffer_size, bool decode_uri=true, std::shared_ptr< uint8_t > *kernel_blob_ptr=nullptr)
bool	CanUseDartFrontend () const
void	LoadPlatform (const uint8_t **kernel_buffer, intptr_t *kernel_buffer_size)
void	LoadKernelService (const uint8_t **kernel_service_buffer, intptr_t *kernel_service_buffer_size)
const char *	RegisterKernelBlob (const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
std::shared_ptr< uint8_t >	TryFindKernelBlob (const char *uri, intptr_t *kernel_length)
void	UnregisterKernelBlob (const char *uri)

Detailed Description

Definition at line 23 of file dfe.h.

Constructor & Destructor Documentation

DFE()

dart::bin::DFE::DFE

(

)

Definition at line 65 of file dfe.cc.

    : use_dfe_(false),
      use_incremental_compiler_(false),
      frontend_filename_(nullptr),
      application_kernel_buffer_(nullptr),
      application_kernel_buffer_size_(0),
      kernel_blobs_(&SimpleHashMap::SameStringValue, 4),
      kernel_blobs_lock_() {}

~DFE()

dart::bin::DFE::~DFE

(

)

Definition at line 74 of file dfe.cc.

          {
  if (frontend_filename_ != nullptr) {
    free(frontend_filename_);
  }
  frontend_filename_ = nullptr;
 
  free(application_kernel_buffer_);
  application_kernel_buffer_ = nullptr;
  application_kernel_buffer_size_ = 0;
 
  kernel_blobs_.Clear(
      [](void* value) { delete reinterpret_cast<KernelBlob*>(value); });
}

Member Function Documentation

application_kernel_buffer()

void dart::bin::DFE::application_kernel_buffer ( const uint8_t **  buffer, intptr_t *  size  ) const

inline

Definition at line 64 of file dfe.h.

                                                                               {
    *buffer = application_kernel_buffer_;
    *size = application_kernel_buffer_size_;
  }

CanUseDartFrontend()

bool dart::bin::DFE::CanUseDartFrontend

(

)

const

Definition at line 143 of file dfe.cc.

                                   {
  return (platform_strong_dill != nullptr) &&
         (KernelServiceDillAvailable() || (frontend_filename() != nullptr));
}

CompileAndReadScript()

void dart::bin::DFE::CompileAndReadScript	(	const char *	script_uri,
		uint8_t **	kernel_buffer,
		intptr_t *	kernel_buffer_size,
		char **	error,
		int *	exit_code,
		const char *	package_config,
		bool	for_snapshot,
		bool	embed_sources
	)

Definition at line 204 of file dfe.cc.

                                                   {
  Dart_KernelCompilationResult result =
      CompileScript(script_uri, use_incremental_compiler(), package_config,
                    for_snapshot, embed_sources);
  switch (result.status) {
    case Dart_KernelCompilationStatus_Ok:
      *kernel_buffer = result.kernel;
      *kernel_buffer_size = result.kernel_size;
      *error = nullptr;
      *exit_code = 0;
      break;
    case Dart_KernelCompilationStatus_Error:
      free(result.kernel);
      *error = result.error;  // Copy error message.
      *exit_code = kCompilationErrorExitCode;
      break;
    case Dart_KernelCompilationStatus_Crash:
      free(result.kernel);
      *error = result.error;  // Copy error message.
      *exit_code = kDartFrontendErrorExitCode;
      break;
    case Dart_KernelCompilationStatus_Unknown:
    case Dart_KernelCompilationStatus_MsgFailed:
      free(result.kernel);
      *error = result.error;  // Copy error message.
      *exit_code = kErrorExitCode;
      break;
  }
}

CompileScript()

Dart_KernelCompilationResult dart::bin::DFE::CompileScript	(	const char *	script_uri,
		bool	incremental,
		const char *	package_config,
		bool	for_snapshot,
		bool	embedd_sources
	)

Definition at line 189 of file dfe.cc.

                                                                    {
  // TODO(aam): When Frontend is ready, VM should be passing vm_outline.dill
  // instead of vm_platform.dill to Frontend for compilation.
  PathSanitizer path_sanitizer(script_uri);
  const char* sanitized_uri = path_sanitizer.sanitized_uri();
 
  return Dart_CompileToKernel(
      sanitized_uri, platform_strong_dill, platform_strong_dill_size,
      incremental, for_snapshot, embed_sources, package_config, verbosity());
}

frontend_filename()

char * dart::bin::DFE::frontend_filename ( ) const

inline

Definition at line 32 of file dfe.h.

{ return frontend_filename_; }

GetPlatformBinaryFilename()

const char * dart::bin::DFE::GetPlatformBinaryFilename

(

)

Init()

void dart::bin::DFE::Init

(

)

Definition at line 88 of file dfe.cc.

               {
  if (platform_strong_dill == nullptr) {
    return;
  }
 
  InitKernelServiceAndPlatformDills();
  Dart_SetDartLibrarySourcesKernel(platform_strong_dill,
                                   platform_strong_dill_size);
}

KernelServiceDillAvailable()

bool dart::bin::DFE::KernelServiceDillAvailable

(

)

const

Definition at line 127 of file dfe.cc.

                                           {
  return kernel_service_dill != nullptr;
}

LoadKernelService()

void dart::bin::DFE::LoadKernelService	(	const uint8_t **	kernel_service_buffer,
		intptr_t *	kernel_service_buffer_size
	)

Definition at line 131 of file dfe.cc.

                                                                  {
  *kernel_service_buffer = kernel_service_dill;
  *kernel_service_buffer_size = kernel_service_dill_size;
}

LoadPlatform()

void dart::bin::DFE::LoadPlatform	(	const uint8_t **	kernel_buffer,
		intptr_t *	kernel_buffer_size
	)

Definition at line 137 of file dfe.cc.

                                                     {
  *kernel_buffer = platform_strong_dill;
  *kernel_buffer_size = platform_strong_dill_size;
}

ReadScript()

void dart::bin::DFE::ReadScript	(	const char *	script_uri,
		const AppSnapshot *	app_snapshot,
		uint8_t **	kernel_buffer,
		intptr_t *	kernel_buffer_size,
		bool	decode_uri = true,
		std::shared_ptr< uint8_t > *	kernel_blob_ptr = nullptr
	)

Definition at line 241 of file dfe.cc.

                                                              {
  int64_t start = Dart_TimelineGetMicros();
  if (!TryReadKernelFile(script_uri, app_snapshot, kernel_buffer,
                         kernel_buffer_size, decode_uri, kernel_blob_ptr)) {
    return;
  }
  if (!Dart_IsKernel(*kernel_buffer, *kernel_buffer_size)) {
    if (kernel_blob_ptr != nullptr && *kernel_blob_ptr) {
      *kernel_blob_ptr = nullptr;
    } else {
      free(*kernel_buffer);
    }
    *kernel_buffer = nullptr;
    *kernel_buffer_size = -1;
  }
  int64_t end = Dart_TimelineGetMicros();
  Dart_RecordTimelineEvent("DFE::ReadScript", start, end, /*flow_id_count=*/0,
                           nullptr, Dart_Timeline_Event_Duration,
                           /*argument_count=*/0, nullptr, nullptr);
}

RegisterKernelBlob()

const char * dart::bin::DFE::RegisterKernelBlob	(	const uint8_t *	kernel_buffer,
		intptr_t	kernel_buffer_size
	)

Definition at line 482 of file dfe.cc.

                                                                 {
  ASSERT(DartUtils::SniffForMagicNumber(kernel_buffer, kernel_buffer_size) ==
         DartUtils::kKernelMagicNumber);
  uint8_t* buffer_copy = reinterpret_cast<uint8_t*>(malloc(kernel_buffer_size));
  if (buffer_copy == nullptr) {
    return nullptr;
  }
  memmove(buffer_copy, kernel_buffer, kernel_buffer_size);
 
  MutexLocker ml(&kernel_blobs_lock_);
  ++kernel_blob_counter_;
  char* uri =
      Utils::SCreate("dart-kernel-blob://blob%" Pd, kernel_blob_counter_);
  KernelBlob* blob = new KernelBlob(uri, buffer_copy, kernel_buffer_size);
 
  const uint32_t hash = SimpleHashMap::StringHash(uri);
  SimpleHashMap::Entry* entry =
      kernel_blobs_.Lookup(uri, hash, /*insert=*/true);
  ASSERT(entry != nullptr);
  ASSERT(entry->value == nullptr);
  entry->value = blob;
 
  return uri;
}

set_application_kernel_buffer()

void dart::bin::DFE::set_application_kernel_buffer ( uint8_t *  buffer, intptr_t  size  )

inline

Definition at line 60 of file dfe.h.

                                                                     {
    application_kernel_buffer_ = buffer;
    application_kernel_buffer_size_ = size;
  }

set_frontend_filename()

void dart::bin::DFE::set_frontend_filename ( const char *  name )

inline

Definition at line 34 of file dfe.h.

                                               {
    if (frontend_filename_ != nullptr) {
      free(frontend_filename_);
    }
    frontend_filename_ = Utils::StrDup(name);
    set_use_dfe();
  }

set_use_dfe()

void dart::bin::DFE::set_use_dfe ( bool  value = true )

inline

Definition at line 41 of file dfe.h.

{ use_dfe_ = value; }

set_use_incremental_compiler()

void dart::bin::DFE::set_use_incremental_compiler ( bool  value )

inline

Definition at line 44 of file dfe.h.

                                                {
    use_incremental_compiler_ = value;
  }

set_verbosity()

void dart::bin::DFE::set_verbosity ( Dart_KernelCompilationVerbosityLevel  verbosity )

inline

Definition at line 49 of file dfe.h.

                                                                     {
    verbosity_ = verbosity;
  }

TryFindKernelBlob()

std::shared_ptr< uint8_t > dart::bin::DFE::TryFindKernelBlob	(	const char *	uri,
		intptr_t *	kernel_length
	)

Definition at line 508 of file dfe.cc.

                                                                         {
  *kernel_length = -1;
 
  MutexLocker ml(&kernel_blobs_lock_);
  if (kernel_blob_counter_ == 0) {
    return nullptr;
  }
 
  // This const_cast is safe as this 'key' is only used to find entry, not add.
  void* key = const_cast<char*>(uri);
  const uint32_t hash = SimpleHashMap::StringHash(uri);
  SimpleHashMap::Entry* entry =
      kernel_blobs_.Lookup(key, hash, /*insert=*/false);
  if (entry == nullptr) {
    return nullptr;
  }
 
  KernelBlob* blob = reinterpret_cast<KernelBlob*>(entry->value);
  *kernel_length = blob->size();
  return blob->buffer();
}

TryReadKernelFile()

bool dart::bin::DFE::TryReadKernelFile	(	const char *	script_uri,
		const AppSnapshot *	app_snapshot,
		uint8_t **	kernel_buffer,
		intptr_t *	kernel_buffer_size,
		bool	decode_uri = true,
		std::shared_ptr< uint8_t > *	kernel_blob_ptr = nullptr
	)

Definition at line 437 of file dfe.cc.

                                                                     {
  *kernel_ir = nullptr;
  *kernel_ir_size = -1;
 
  if (decode_uri && kernel_blob_ptr != nullptr) {
    *kernel_blob_ptr = TryFindKernelBlob(script_uri, kernel_ir_size);
    if (*kernel_blob_ptr) {
      *kernel_ir = kernel_blob_ptr->get();
      ASSERT(DartUtils::SniffForMagicNumber(*kernel_ir, *kernel_ir_size) ==
             DartUtils::kKernelMagicNumber);
      return true;
    }
  }
  if (app_snapshot == nullptr || app_snapshot->IsKernel() ||
      app_snapshot->IsKernelList()) {
    uint8_t* buffer;
    if (!TryReadFile(script_uri, &buffer, kernel_ir_size, decode_uri)) {
      return false;
    }
    auto magic_number = DartUtils::kUnknownMagicNumber;
    if (app_snapshot == nullptr) {
      magic_number = DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size);
    } else if (app_snapshot->IsKernel()) {
      magic_number = DartUtils::kKernelMagicNumber;
      ASSERT(DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size) ==
             DartUtils::kKernelMagicNumber);
    } else {
      magic_number = DartUtils::kKernelListMagicNumber;
      ASSERT(DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size) ==
             DartUtils::kKernelListMagicNumber);
    }
    if (magic_number == DartUtils::kKernelListMagicNumber) {
      return TryReadKernelListBuffer(script_uri, buffer, *kernel_ir_size,
                                     kernel_ir, kernel_ir_size);
    }
    return TryReadSimpleKernelBuffer(buffer, kernel_ir, kernel_ir_size);
  }
  return false;
}

UnregisterKernelBlob()

void dart::bin::DFE::UnregisterKernelBlob

(

const char *

uri

)

Definition at line 531 of file dfe.cc.

                                              {
  MutexLocker ml(&kernel_blobs_lock_);
 
  // This const_cast is safe as this 'key' is only used to find entry, not add.
  void* key = const_cast<char*>(uri);
  const uint32_t hash = SimpleHashMap::StringHash(uri);
  SimpleHashMap::Entry* entry =
      kernel_blobs_.Lookup(key, hash, /*insert=*/false);
  if (entry == nullptr) {
    return;
  }
 
  KernelBlob* blob = reinterpret_cast<KernelBlob*>(entry->value);
  entry->value = nullptr;
  kernel_blobs_.Remove(key, hash);
  delete blob;
}

use_incremental_compiler()

bool dart::bin::DFE::use_incremental_compiler ( ) const

inline

Definition at line 47 of file dfe.h.

{ return use_incremental_compiler_; }

UseDartFrontend()

bool dart::bin::DFE::UseDartFrontend ( ) const

inline

Definition at line 42 of file dfe.h.

{ return use_dfe_; }

verbosity()

Dart_KernelCompilationVerbosityLevel dart::bin::DFE::verbosity ( ) const

inline

Definition at line 52 of file dfe.h.

{ return verbosity_; }

---

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

• third_party/dart-lang/sdk/runtime/bin/dfe.h
• third_party/dart-lang/sdk/runtime/bin/dfe.cc