kernel.h

Go to the documentation of this file.

// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
 
#ifndef RUNTIME_VM_KERNEL_H_
#define RUNTIME_VM_KERNEL_H_
 
#include <memory>
 
#include "platform/assert.h"
#include "vm/allocation.h"
#include "vm/globals.h"
#include "vm/growable_array.h"
#include "vm/object.h"
#include "vm/token_position.h"
 
namespace dart {
namespace kernel {
class NameIndex {
 public:
  static constexpr int kInvalidName = -1;
 
  NameIndex() : value_(kInvalidName) {}
  explicit NameIndex(int value) : value_(value) {}
 
  operator int() const { return value_; }
 
 private:
  int value_;
};
}  // namespace kernel
}  // namespace dart
 
#if !defined(DART_PRECOMPILED_RUNTIME)
namespace dart {
 
class BitVector;
class Field;
class ParsedFunction;
class Zone;
 
namespace kernel {
 
class Reader;
struct ProcedureAttributesMetadata;
class TableSelectorMetadata;
class UnboxingInfoMetadata;
 
class StringIndex {
 public:
  StringIndex() : value_(-1) {}
  explicit StringIndex(int value) : value_(value) {}
 
  operator int() const { return value_; }
 
 private:
  int value_;
};
 
enum LogicalOperator { kAnd, kOr };
 
class Program {
 public:
  // Read a kernel Program from the given Reader. Note the returned Program
  // can potentially contain several "sub programs", though the library count
  // etc will reference the last "sub program" only.
  static std::unique_ptr<Program> ReadFrom(Reader* reader,
                                           const char** error = nullptr);
 
  static std::unique_ptr<Program> ReadFromFile(const char* script_uri,
                                               const char** error = nullptr);
  static std::unique_ptr<Program> ReadFromBuffer(const uint8_t* buffer,
                                                 intptr_t buffer_length,
                                                 const char** error = nullptr);
  static std::unique_ptr<Program> ReadFromTypedData(
      const ExternalTypedData& typed_data,
      const char** error = nullptr);
 
  bool is_single_program() { return single_program_; }
  NameIndex main_method() { return main_method_reference_; }
  intptr_t source_table_offset() const { return source_table_offset_; }
  intptr_t string_table_offset() const { return string_table_offset_; }
  intptr_t name_table_offset() const { return name_table_offset_; }
  intptr_t metadata_payloads_offset() const {
    return metadata_payloads_offset_;
  }
  intptr_t metadata_mappings_offset() const {
    return metadata_mappings_offset_;
  }
  intptr_t constant_table_offset() { return constant_table_offset_; }
  intptr_t component_index_offset() { return component_index_offset_; }
  intptr_t library_count() { return library_count_; }
 
  // The data of the kernel file (single or multiple encoded components).
  const TypedDataBase& binary() { return *binary_; }
 
 private:
  explicit Program(const TypedDataBase* binary) : binary_(binary) {}
 
  bool single_program_;
  NameIndex main_method_reference_;  // Procedure.
  intptr_t library_count_;
 
  // The offset from the start of the binary to the start of the source table.
  intptr_t source_table_offset_;
 
  // The offset from the start of the binary to the start of the constant table.
  intptr_t constant_table_offset_;
 
  // The offset from the start of the binary to the start of the ending-index.
  intptr_t component_index_offset_;
 
  // The offset from the start of the binary to the canonical name table.
  intptr_t name_table_offset_;
 
  // The offset from the start of the binary to the metadata payloads.
  intptr_t metadata_payloads_offset_;
 
  // The offset from the start of the binary to the metadata mappings.
  intptr_t metadata_mappings_offset_;
 
  // The offset from the start of the binary to the start of the string table.
  intptr_t string_table_offset_;
 
  const TypedDataBase* binary_ = nullptr;
 
  DISALLOW_COPY_AND_ASSIGN(Program);
};
 
class KernelLineStartsReader {
 public:
  KernelLineStartsReader(const dart::TypedData& line_starts_data,
                         dart::Zone* zone);
 
  ~KernelLineStartsReader() { delete helper_; }
 
  uint32_t At(intptr_t index) const {
    return helper_->At(line_starts_data_, index);
  }
 
  uint32_t MaxPosition() const;
 
  // Returns whether the given offset corresponds to a valid source offset
  // If it does, then *line and *column (if column is not nullptr) are set
  // to the line and column the token starts at.
  DART_WARN_UNUSED_RESULT bool LocationForPosition(
      intptr_t position,
      intptr_t* line,
      intptr_t* col = nullptr) const;
 
  // Returns whether any tokens were found for the given line. When found,
  // *first_token_index and *last_token_index are set to the first and
  // last token on the line, respectively.
  DART_WARN_UNUSED_RESULT bool TokenRangeAtLine(
      intptr_t line_number,
      dart::TokenPosition* first_token_index,
      dart::TokenPosition* last_token_index) const;
 
 private:
  class KernelLineStartsHelper {
   public:
    KernelLineStartsHelper() {}
    virtual ~KernelLineStartsHelper() {}
    virtual uint32_t At(const dart::TypedData& data, intptr_t index) const = 0;
 
   private:
    DISALLOW_COPY_AND_ASSIGN(KernelLineStartsHelper);
  };
 
  class KernelUint16LineStartsHelper : public KernelLineStartsHelper {
   public:
    KernelUint16LineStartsHelper() {}
    virtual uint32_t At(const dart::TypedData& data, intptr_t index) const;
 
   private:
    DISALLOW_COPY_AND_ASSIGN(KernelUint16LineStartsHelper);
  };
 
  class KernelUint32LineStartsHelper : public KernelLineStartsHelper {
   public:
    KernelUint32LineStartsHelper() {}
    virtual uint32_t At(const dart::TypedData& data, intptr_t index) const;
 
   private:
    DISALLOW_COPY_AND_ASSIGN(KernelUint32LineStartsHelper);
  };
 
  const dart::TypedData& line_starts_data_;
  KernelLineStartsHelper* helper_;
 
  DISALLOW_COPY_AND_ASSIGN(KernelLineStartsReader);
};
 
ObjectPtr EvaluateStaticConstFieldInitializer(const Field& field);
ObjectPtr EvaluateMetadata(const Library& library,
                           intptr_t kernel_offset,
                           bool is_annotations_offset);
ObjectPtr BuildParameterDescriptor(const Function& function);
 
// Fills in [is_covariant] and [is_generic_covariant_impl] vectors
// according to covariance attributes of [function] parameters.
//
// [is_covariant] and [is_generic_covariant_impl] should contain bitvectors
// of function.NumParameters() length.
void ReadParameterCovariance(const Function& function,
                             BitVector* is_covariant,
                             BitVector* is_generic_covariant_impl);
 
// Returns true if the given function needs dynamic invocation forwarder:
// that is if any of the arguments require checking on the dynamic
// call-site: if function has no parameters or has only covariant parameters
// as such function already checks all of its parameters.
bool NeedsDynamicInvocationForwarder(const Function& function);
 
ProcedureAttributesMetadata ProcedureAttributesOf(const Function& function,
                                                  Zone* zone);
 
ProcedureAttributesMetadata ProcedureAttributesOf(const Field& field,
                                                  Zone* zone);
 
UnboxingInfoMetadata* UnboxingInfoMetadataOf(const Function& function,
                                             Zone* zone);
 
TableSelectorMetadata* TableSelectorMetadataForProgram(
    const KernelProgramInfo& info,
    Zone* zone);
 
}  // namespace kernel
}  // namespace dart
 
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
#endif  // RUNTIME_VM_KERNEL_H_