dart::SnapshotHeaderReader Class Reference

#include <app_snapshot.h>

Public Member Functions
	SnapshotHeaderReader (const Snapshot *snapshot)
	SnapshotHeaderReader (Snapshot::Kind kind, const uint8_t *buffer, intptr_t size)
void	SetCoverageFromSnapshotFeatures (IsolateGroup *isolate_group)
char *	VerifyVersionAndFeatures (IsolateGroup *isolate_group, intptr_t *offset)

Static Public Member Functions
static char *	InitializeGlobalVMFlagsFromSnapshot (const Snapshot *snapshot)

Detailed Description

Definition at line 72 of file app_snapshot.h.

Constructor & Destructor Documentation

SnapshotHeaderReader() [1/2]

dart::SnapshotHeaderReader::SnapshotHeaderReader ( const Snapshot *  snapshot )

inlineexplicit

Definition at line 76 of file app_snapshot.h.

      : SnapshotHeaderReader(snapshot->kind(),
                             snapshot->Addr(),
                             snapshot->length()) {}

SnapshotHeaderReader() [2/2]

dart::SnapshotHeaderReader::SnapshotHeaderReader ( Snapshot::Kind  kind, const uint8_t *  buffer, intptr_t  size  )

inline

Definition at line 81 of file app_snapshot.h.

      : kind_(kind), stream_(buffer, size) {
    stream_.SetPosition(Snapshot::kHeaderSize);
  }

Member Function Documentation

InitializeGlobalVMFlagsFromSnapshot()

char * dart::SnapshotHeaderReader::InitializeGlobalVMFlagsFromSnapshot ( const Snapshot *  snapshot )

static

Definition at line 9838 of file app_snapshot.cc.

                              {
  SnapshotHeaderReader header_reader(snapshot);
 
  char* error = header_reader.VerifyVersion();
  if (error != nullptr) {
    return error;
  }
 
  const char* features = nullptr;
  intptr_t features_length = 0;
  error = header_reader.ReadFeatures(&features, &features_length);
  if (error != nullptr) {
    return error;
  }
 
  ASSERT(features[features_length] == '\0');
  const char* cursor = features;
  while (*cursor != '\0') {
    while (*cursor == ' ') {
      cursor++;
    }
 
    const char* end = strstr(cursor, " ");
    if (end == nullptr) {
      end = features + features_length;
    }
 
#define SET_FLAG(name)                                                         \
  if (strncmp(cursor, #name, end - cursor) == 0) {                             \
    FLAG_##name = true;                                                        \
    cursor = end;                                                              \
    continue;                                                                  \
  }                                                                            \
  if (strncmp(cursor, "no-" #name, end - cursor) == 0) {                       \
    FLAG_##name = false;                                                       \
    cursor = end;                                                              \
    continue;                                                                  \
  }
 
#define CHECK_FLAG(name, mode)                                                 \
  if (strncmp(cursor, #name, end - cursor) == 0) {                             \
    if (!FLAG_##name) {                                                        \
      return header_reader.BuildError("Flag " #name                            \
                                      " is true in snapshot, "                 \
                                      "but " #name                             \
                                      " is always false in " mode);            \
    }                                                                          \
    cursor = end;                                                              \
    continue;                                                                  \
  }                                                                            \
  if (strncmp(cursor, "no-" #name, end - cursor) == 0) {                       \
    if (FLAG_##name) {                                                         \
      return header_reader.BuildError("Flag " #name                            \
                                      " is false in snapshot, "                \
                                      "but " #name                             \
                                      " is always true in " mode);             \
    }                                                                          \
    cursor = end;                                                              \
    continue;                                                                  \
  }
 
#define SET_P(name, T, DV, C) SET_FLAG(name)
 
#if defined(PRODUCT)
#define SET_OR_CHECK_R(name, PV, T, DV, C) CHECK_FLAG(name, "product mode")
#else
#define SET_OR_CHECK_R(name, PV, T, DV, C) SET_FLAG(name)
#endif
 
#if defined(PRODUCT)
#define SET_OR_CHECK_C(name, PCV, PV, T, DV, C) CHECK_FLAG(name, "product mode")
#elif defined(DART_PRECOMPILED_RUNTIME)
#define SET_OR_CHECK_C(name, PCV, PV, T, DV, C)                                \
  CHECK_FLAG(name, "the precompiled runtime")
#else
#define SET_OR_CHECK_C(name, PV, T, DV, C) SET_FLAG(name)
#endif
 
#if !defined(DEBUG)
#define SET_OR_CHECK_D(name, T, DV, C) CHECK_FLAG(name, "non-debug mode")
#else
#define SET_OR_CHECK_D(name, T, DV, C) SET_FLAG(name)
#endif
 
    VM_GLOBAL_FLAG_LIST(SET_P, SET_OR_CHECK_R, SET_OR_CHECK_C, SET_OR_CHECK_D)
 
#undef SET_OR_CHECK_D
#undef SET_OR_CHECK_C
#undef SET_OR_CHECK_R
#undef SET_P
#undef CHECK_FLAG
#undef SET_FLAG
 
    cursor = end;
  }
 
  return nullptr;
}

SetCoverageFromSnapshotFeatures()

void dart::SnapshotHeaderReader::SetCoverageFromSnapshotFeatures

(

IsolateGroup *

isolate_group

)

Definition at line 9283 of file app_snapshot.cc.

                                 {
  auto prev_position = stream_.Position();
  char* error = VerifyVersion();
  if (error == nullptr) {
    const char* features = nullptr;
    intptr_t features_length = 0;
    char* error = ReadFeatures(&features, &features_length);
    if (error == nullptr) {
      if (strstr(features, " no-coverage") != nullptr) {
        isolate_group->set_coverage(false);
      } else if (strstr(features, " coverage") != nullptr) {
        isolate_group->set_coverage(true);
      }
    }
  }
 
  stream_.SetPosition(prev_position);
}

VerifyVersionAndFeatures()

char * dart::SnapshotHeaderReader::VerifyVersionAndFeatures	(	IsolateGroup *	isolate_group,
		intptr_t *	offset
	)

Definition at line 9303 of file app_snapshot.cc.

                      {
  char* error = VerifyVersion();
  if (error == nullptr) {
    error = VerifyFeatures(isolate_group);
  }
  if (error == nullptr) {
    *offset = stream_.Position();
  }
  return error;
}

---

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

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