factor/vm/image.cpp

#include "master.hpp"

namespace factor {

/* Certain special objects in the image are known to the runtime */
void factor_vm::init_objects(image_header* h) {
  memcpy(special_objects, h->special_objects, sizeof(special_objects));

  true_object = h->true_object;
  bignum_zero = h->bignum_zero;
  bignum_pos_one = h->bignum_pos_one;
  bignum_neg_one = h->bignum_neg_one;
}

void factor_vm::load_data_heap(FILE* file, image_header* h, vm_parameters* p) {
  p->tenured_size = std::max((h->data_size * 3) / 2, p->tenured_size);

  init_data_heap(p->young_size, p->aging_size, p->tenured_size);

  fixnum bytes_read =
      safe_fread((void*)data->tenured->start, 1, h->data_size, file);

  if ((cell)bytes_read != h->data_size) {
    std::cout << "truncated image: " << bytes_read << " bytes read, ";
    std::cout << h->data_size << " bytes expected\n";
    fatal_error("load_data_heap failed", 0);
  }

  data->tenured->initial_free_list(h->data_size);
}

void factor_vm::load_code_heap(FILE* file, image_header* h, vm_parameters* p) {
  if (h->code_size > p->code_size)
    fatal_error("Code heap too small to fit image", h->code_size);

  init_code_heap(p->code_size);

  if (h->code_size != 0) {
    size_t bytes_read =
        safe_fread(code->allocator->first_block(), 1, h->code_size, file);
    if (bytes_read != h->code_size) {
      std::cout << "truncated image: " << bytes_read << " bytes read, ";
      std::cout << h->code_size << " bytes expected\n";
      fatal_error("load_code_heap failed", 0);
    }
  }

  code->allocator->initial_free_list(h->code_size);
  code->initialize_all_blocks_set();
}

struct startup_fixup {
  static const bool translated_code_block_map = true;

  cell data_offset;
  cell code_offset;

  startup_fixup(cell data_offset, cell code_offset)
      : data_offset(data_offset), code_offset(code_offset) {}

  object* fixup_data(object* obj) {
    return (object*)((cell)obj + data_offset);
  }

  code_block* fixup_code(code_block* obj) {
    return (code_block*)((cell)obj + code_offset);
  }

  object* translate_data(const object* obj) { return fixup_data((object*)obj); }

  code_block* translate_code(const code_block* compiled) {
    return fixup_code((code_block*)compiled);
  }

  cell size(const object* obj) { return obj->size(*this); }

  cell size(code_block* compiled) { return compiled->size(*this); }
};

struct start_object_updater {
  factor_vm* parent;
  startup_fixup fixup;
  slot_visitor<startup_fixup> data_visitor;
  code_block_visitor<startup_fixup> code_visitor;

  start_object_updater(factor_vm* parent, startup_fixup fixup)
      : parent(parent),
        fixup(fixup),
        data_visitor(slot_visitor<startup_fixup>(parent, fixup)),
        code_visitor(code_block_visitor<startup_fixup>(parent, fixup)) {}

  void operator()(object* obj, cell size) {
    parent->data->tenured->starts.record_object_start_offset(obj);

    data_visitor.visit_slots(obj);

    switch (obj->type()) {
      case ALIEN_TYPE: {

        alien* ptr = (alien*)obj;

        if (to_boolean(ptr->base))
          ptr->update_address();
        else
          ptr->expired = parent->true_object;
        break;
      }
      case DLL_TYPE: {
        parent->ffi_dlopen((dll*)obj);
        break;
      }
      default: {
        code_visitor.visit_object_code_block(obj);
        break;
      }
    }
  }
};

void factor_vm::fixup_data(cell data_offset, cell code_offset) {
  startup_fixup fixup(data_offset, code_offset);
  slot_visitor<startup_fixup> data_workhorse(this, fixup);
  data_workhorse.visit_roots();

  start_object_updater updater(this, fixup);
  data->tenured->iterate(updater, fixup);
}

struct startup_code_block_relocation_visitor {
  factor_vm* parent;
  startup_fixup fixup;
  slot_visitor<startup_fixup> data_visitor;

  startup_code_block_relocation_visitor(factor_vm* parent,
                                        startup_fixup fixup)
      : parent(parent),
        fixup(fixup),
        data_visitor(slot_visitor<startup_fixup>(parent, fixup)) {}

  void operator()(instruction_operand op) {
    code_block* compiled = op.compiled;
    cell old_offset =
        op.rel_offset() + (cell)compiled->entry_point() - fixup.code_offset;

    switch (op.rel_type()) {
      case RT_LITERAL: {
        cell value = op.load_value(old_offset);
        if (immediate_p(value))
          op.store_value(value);
        else
          op.store_value(
              RETAG(fixup.fixup_data(untag<object>(value)), TAG(value)));
        break;
      }
      case RT_ENTRY_POINT:
      case RT_ENTRY_POINT_PIC:
      case RT_ENTRY_POINT_PIC_TAIL:
      case RT_HERE: {
        cell value = op.load_value(old_offset);
        cell offset = TAG(value);
        code_block* compiled = (code_block*)UNTAG(value);
        op.store_value((cell)fixup.fixup_code(compiled) + offset);
        break;
      }
      case RT_UNTAGGED:
        break;
      default:
        parent->store_external_address(op);
        break;
    }
  }
};

struct startup_code_block_updater {
  factor_vm* parent;
  startup_fixup fixup;

  startup_code_block_updater(factor_vm* parent, startup_fixup fixup)
      : parent(parent), fixup(fixup) {}

  void operator()(code_block* compiled, cell size) {
    slot_visitor<startup_fixup> data_visitor(parent, fixup);
    data_visitor.visit_code_block_objects(compiled);

    startup_code_block_relocation_visitor code_visitor(parent, fixup);
    compiled->each_instruction_operand(code_visitor);
  }
};

void factor_vm::fixup_code(cell data_offset, cell code_offset) {
  startup_fixup fixup(data_offset, code_offset);
  startup_code_block_updater updater(this, fixup);
  code->allocator->iterate(updater, fixup);
}

bool factor_vm::read_embedded_image_footer(FILE* file,
                                           embedded_image_footer* footer) {
  safe_fseek(file, -(off_t)sizeof(embedded_image_footer), SEEK_END);
  safe_fread(footer, (off_t)sizeof(embedded_image_footer), 1, file);
  return footer->magic == image_magic;
}

FILE* factor_vm::open_image(vm_parameters* p) {
  if (p->embedded_image) {
    FILE* file = OPEN_READ(p->executable_path);
    if (file == NULL) {
      std::cout << "Cannot open embedded image" << std::endl;
      std::cout << strerror(errno) << std::endl;
      exit(1);
    }
    embedded_image_footer footer;
    if (!read_embedded_image_footer(file, &footer)) {
      std::cout << "No embedded image" << std::endl;
      exit(1);
    }
    safe_fseek(file, (off_t)footer.image_offset, SEEK_SET);
    return file;
  } else
    return OPEN_READ(p->image_path);
}

/* Read an image file from disk, only done once during startup */
/* This function also initializes the data and code heaps */
void factor_vm::load_image(vm_parameters* p) {
  FILE* file = open_image(p);
  if (file == NULL) {
    std::cout << "Cannot open image file: " << p->image_path << std::endl;
    std::cout << strerror(errno) << std::endl;
    exit(1);
  }

  image_header h;
  if (safe_fread(&h, sizeof(image_header), 1, file) != 1)
    fatal_error("Cannot read image header", 0);

  if (h.magic != image_magic)
    fatal_error("Bad image: magic number check failed", h.magic);

  if (h.version != image_version)
    fatal_error("Bad image: version number check failed", h.version);

  load_data_heap(file, &h, p);
  load_code_heap(file, &h, p);

  safe_fclose(file);

  init_objects(&h);

  cell data_offset = data->tenured->start - h.data_relocation_base;
  cell code_offset = code->allocator->start - h.code_relocation_base;

  fixup_data(data_offset, code_offset);
  fixup_code(data_offset, code_offset);

  /* Store image path name */
  special_objects[OBJ_IMAGE] = allot_alien(false_object, (cell)p->image_path);
}

/* Save the current image to disk */
bool factor_vm::save_image(const vm_char* saving_filename,
                           const vm_char* filename) {
  FILE* file;
  image_header h;

  file = OPEN_WRITE(saving_filename);
  if (file == NULL) {
    std::cout << "Cannot open image file: " << saving_filename << std::endl;
    std::cout << strerror(errno) << std::endl;
    return false;
  }

  h.magic = image_magic;
  h.version = image_version;
  h.data_relocation_base = data->tenured->start;
  h.data_size = data->tenured->occupied_space();
  h.code_relocation_base = code->allocator->start;
  h.code_size = code->allocator->occupied_space();

  h.true_object = true_object;
  h.bignum_zero = bignum_zero;
  h.bignum_pos_one = bignum_pos_one;
  h.bignum_neg_one = bignum_neg_one;

  for (cell i = 0; i < special_object_count; i++)
    h.special_objects[i] =
        (save_special_p(i) ? special_objects[i] : false_object);

  bool ok = true;

  if (safe_fwrite(&h, sizeof(image_header), 1, file) != 1)
    ok = false;
  if (safe_fwrite((void*)data->tenured->start, h.data_size, 1, file) != 1)
    ok = false;
  if (safe_fwrite(code->allocator->first_block(), h.code_size, 1, file) != 1)
    ok = false;
  safe_fclose(file);

  if (!ok)
    std::cout << "save-image failed: " << strerror(errno) << std::endl;
  else
    move_file(saving_filename, filename);

  return ok;
}

void factor_vm::primitive_save_image() {
  /* do a full GC to push everything into tenured space */
  primitive_compact_gc();

  data_root<byte_array> path2(ctx->pop(), this);
  path2.untag_check(this);
  data_root<byte_array> path1(ctx->pop(), this);
  path1.untag_check(this);
  save_image((vm_char*)(path1.untagged() + 1),
             (vm_char*)(path2.untagged() + 1));
}

void factor_vm::primitive_save_image_and_exit() {
  /* We unbox this before doing anything else. This is the only point
     where we might throw an error, so we have to throw an error here since
     later steps destroy the current image. */
  data_root<byte_array> path2(ctx->pop(), this);
  path2.untag_check(this);
  data_root<byte_array> path1(ctx->pop(), this);
  path1.untag_check(this);

  /* strip out special_objects data which is set on startup anyway */
  for (cell i = 0; i < special_object_count; i++)
    if (!save_special_p(i))
      special_objects[i] = false_object;

  gc(collect_compact_op, 0, /* requested size */
     false /* discard objects only reachable from stacks */);

  /* Save the image */
  if (save_image((vm_char*)(path1.untagged() + 1),
                 (vm_char*)(path2.untagged() + 1)))
    exit(0);
  else
    exit(1);
}

bool factor_vm::embedded_image_p() {
  const vm_char* vm_path = vm_executable_path();
  if (!vm_path)
    return false;
  FILE* file = OPEN_READ(vm_path);
  if (!file)
    return false;
  embedded_image_footer footer;
  bool embedded_p = read_embedded_image_footer(file, &footer);
  fclose(file);
  return embedded_p;
}

}