Add files using upload-large-folder tool

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/context.cc

@@ -0,0 +1,115 @@
+#include "context.h"
+#include <assert.h>
+#include <sched.h>
+#include <stdlib.h>
+
+static __thread context_t* cur;
+
+context_t::context_t()
+  : creator(NULL), func(NULL), arg(NULL),
+#ifndef USE_UCONTEXT
+    mutex(PTHREAD_MUTEX_INITIALIZER),
+    cond(PTHREAD_COND_INITIALIZER), flag(0)
+#else
+    context(new ucontext_t)
+#endif
+{
+}
+
+#ifdef USE_UCONTEXT
+#ifndef GLIBC_64BIT_PTR_BUG
+void context_t::wrapper(context_t* ctx)
+{
+#else
+void context_t::wrapper(unsigned int hi, unsigned int lo)
+{
+  context_t* ctx = reinterpret_cast<context_t*>(static_cast<unsigned long>(lo) | (static_cast<unsigned long>(hi) << 32));
+#endif
+  ctx->creator->switch_to();
+  ctx->func(ctx->arg);
+}
+#else
+void* context_t::wrapper(void* a)
+{
+  context_t* ctx = static_cast<context_t*>(a);
+  cur = ctx;
+  ctx->creator->switch_to();
+
+  ctx->func(ctx->arg);
+  return NULL;
+}
+#endif
+
+void context_t::init(void (*f)(void*), void* a)
+{
+  func = f;
+  arg = a;
+  creator = current();
+
+#ifdef USE_UCONTEXT
+  getcontext(context.get());
+  context->uc_link = creator->context.get();
+  context->uc_stack.ss_size = 64*1024;
+  context->uc_stack.ss_sp = new void*[context->uc_stack.ss_size/sizeof(void*)];
+#ifndef GLIBC_64BIT_PTR_BUG
+  makecontext(context.get(), (void(*)(void))&context_t::wrapper, 1, this);
+#else
+  unsigned int hi(reinterpret_cast<unsigned long>(this) >> 32);
+  unsigned int lo(reinterpret_cast<unsigned long>(this));
+  makecontext(context.get(), (void(*)(void))&context_t::wrapper, 2, hi, lo);
+#endif
+  switch_to();
+#else
+  assert(flag == 0);
+
+  pthread_mutex_lock(&creator->mutex);
+  creator->flag = 0;
+  if (pthread_create(&thread, NULL, &context_t::wrapper, this) != 0)
+    abort();
+  pthread_detach(thread);
+  while (!creator->flag)
+    pthread_cond_wait(&creator->cond, &creator->mutex);
+  pthread_mutex_unlock(&creator->mutex);
+#endif
+}
+
+context_t::~context_t()
+{
+  assert(this != cur);
+}
+
+void context_t::switch_to()
+{
+  assert(this != cur);
+#ifdef USE_UCONTEXT
+  context_t* prev = cur;
+  cur = this;
+  if (swapcontext(prev->context.get(), context.get()) != 0)
+    abort();
+#else
+  cur->flag = 0;
+  this->flag = 1;
+  pthread_mutex_lock(&this->mutex);
+  pthread_cond_signal(&this->cond);
+  pthread_mutex_unlock(&this->mutex);
+  pthread_mutex_lock(&cur->mutex);
+  while (!cur->flag)
+    pthread_cond_wait(&cur->cond, &cur->mutex);
+  pthread_mutex_unlock(&cur->mutex);
+#endif
+}
+
+context_t* context_t::current()
+{
+  if (cur == NULL)
+  {
+    cur = new context_t;
+#ifdef USE_UCONTEXT
+    getcontext(cur->context.get());
+#else
+    cur->thread = pthread_self();
+    cur->flag = 1;
+#endif
+  }
+  return cur;
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/device.cc

@@ -0,0 +1,155 @@
+#include "device.h"
+#include "term.h"
+#include "memif.h"
+#include <cassert>
+#include <algorithm>
+#include <climits>
+#include <iostream>
+#include <thread>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+using namespace std::placeholders;
+
+device_t::device_t()
+  : command_handlers(command_t::MAX_COMMANDS),
+    command_names(command_t::MAX_COMMANDS)
+{
+  for (size_t cmd = 0; cmd < command_t::MAX_COMMANDS; cmd++)
+    register_command(cmd, std::bind(&device_t::handle_null_command, this, _1), "");
+  register_command(command_t::MAX_COMMANDS-1, std::bind(&device_t::handle_identify, this, _1), "identity");
+}
+
+void device_t::register_command(size_t cmd, command_func_t handler, const char* name)
+{
+  assert(cmd < command_t::MAX_COMMANDS);
+  assert(strlen(name) < IDENTITY_SIZE);
+  command_handlers[cmd] = handler;
+  command_names[cmd] = name;
+}
+
+void device_t::handle_command(command_t cmd)
+{
+  command_handlers[cmd.cmd()](cmd);
+}
+
+void device_t::handle_null_command(command_t cmd)
+{
+}
+
+void device_t::handle_identify(command_t cmd)
+{
+  size_t what = cmd.payload() % command_t::MAX_COMMANDS;
+  uint64_t addr = cmd.payload() / command_t::MAX_COMMANDS;
+  assert(addr % IDENTITY_SIZE == 0);
+
+  char id[IDENTITY_SIZE] = {0};
+  if (what == command_t::MAX_COMMANDS-1)
+  {
+    assert(strlen(identity()) < IDENTITY_SIZE);
+    strcpy(id, identity());
+  }
+  else
+    strcpy(id, command_names[what].c_str());
+
+  cmd.memif().write(addr, IDENTITY_SIZE, id);
+  cmd.respond(1);
+}
+
+bcd_t::bcd_t()
+{
+  register_command(0, std::bind(&bcd_t::handle_read, this, _1), "read");
+  register_command(1, std::bind(&bcd_t::handle_write, this, _1), "write");
+}
+
+void bcd_t::handle_read(command_t cmd)
+{
+  pending_reads.push(cmd);
+}
+
+void bcd_t::handle_write(command_t cmd)
+{
+  canonical_terminal_t::write(cmd.payload());
+}
+
+void bcd_t::tick()
+{
+  int ch;
+  if (!pending_reads.empty() && (ch = canonical_terminal_t::read()) != -1)
+  {
+    pending_reads.front().respond(0x100 | ch);
+    pending_reads.pop();
+  }
+}
+
+disk_t::disk_t(const char* fn)
+{
+  fd = ::open(fn, O_RDWR);
+  if (fd < 0)
+    throw std::runtime_error("could not open " + std::string(fn));
+
+  register_command(0, std::bind(&disk_t::handle_read, this, _1), "read");
+  register_command(1, std::bind(&disk_t::handle_write, this, _1), "write");
+
+  struct stat st;
+  if (fstat(fd, &st) < 0)
+    throw std::runtime_error("could not stat " + std::string(fn));
+
+  size = st.st_size;
+  id = "disk size=" + std::to_string(size);
+}
+
+disk_t::~disk_t()
+{
+  close(fd);
+}
+
+void disk_t::handle_read(command_t cmd)
+{
+  request_t req;
+  cmd.memif().read(cmd.payload(), sizeof(req), &req);
+
+  std::vector<uint8_t> buf(req.size);
+  if ((size_t)::pread(fd, &buf[0], buf.size(), req.offset) != req.size)
+    throw std::runtime_error("could not read " + id + " @ " + std::to_string(req.offset));
+
+  cmd.memif().write(req.addr, buf.size(), &buf[0]);
+  cmd.respond(req.tag);
+}
+
+void disk_t::handle_write(command_t cmd)
+{
+  request_t req;
+  cmd.memif().read(cmd.payload(), sizeof(req), &req);
+
+  std::vector<uint8_t> buf(req.size);
+  cmd.memif().read(req.addr, buf.size(), &buf[0]);
+
+  if ((size_t)::pwrite(fd, &buf[0], buf.size(), req.offset) != req.size)
+    throw std::runtime_error("could not write " + id + " @ " + std::to_string(req.offset));
+
+  cmd.respond(req.tag);
+}
+
+device_list_t::device_list_t()
+  : devices(command_t::MAX_COMMANDS, &null_device), num_devices(0)
+{
+}
+
+void device_list_t::register_device(device_t* dev)
+{
+  num_devices++;
+  assert(num_devices < command_t::MAX_DEVICES);
+  devices[num_devices-1] = dev;
+}
+
+void device_list_t::handle_command(command_t cmd)
+{
+  devices[cmd.device()]->handle_command(cmd);
+}
+
+void device_list_t::tick()
+{
+  for (size_t i = 0; i < num_devices; i++)
+    devices[i]->tick();
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/dtm.h

@@ -0,0 +1,115 @@
+#ifndef _ROCKET_DTM_H
+#define _ROCKET_DTM_H
+
+#include "htif.h"
+#include "context.h"
+#include <stdint.h>
+#include <queue>
+#include <semaphore.h>
+#include <vector>
+#include <string>
+#include <stdlib.h>
+
+// abstract debug transport module
+class dtm_t : public htif_t
+{
+ public:
+  dtm_t(int argc, char**argv);
+  ~dtm_t();
+
+  struct req {
+    uint32_t addr;
+    uint32_t op;
+    uint32_t data;
+  };
+
+  struct resp {
+    uint32_t resp;
+    uint32_t data;
+  };
+
+  void tick(
+    bool  req_ready,
+    bool  resp_valid,
+    resp  resp_bits
+  );
+  // Akin to tick, but the target thread returns a response on every invocation
+  void return_resp(
+    resp  resp_bits
+  );
+
+  
+  bool req_valid() { return req_wait; }
+  req req_bits() { return req_buf; }
+  bool resp_ready() { return true; }
+
+  uint32_t read(uint32_t addr);
+  uint32_t write(uint32_t addr, uint32_t data);
+  void nop();
+
+  uint64_t read_csr(unsigned which);
+  uint64_t write_csr(unsigned which, uint64_t data);
+  uint64_t clear_csr(unsigned which, uint64_t data);
+  uint64_t set_csr(unsigned which, uint64_t data);
+  void fence_i();
+
+  void producer_thread();
+
+ protected:
+  virtual void read_chunk(addr_t taddr, size_t len, void* dst) override;
+  virtual void write_chunk(addr_t taddr, size_t len, const void* src) override;
+  virtual void clear_chunk(addr_t taddr, size_t len) override;
+  virtual size_t chunk_align() override;
+  virtual size_t chunk_max_size() override;
+  virtual void reset() override;
+  virtual void idle() override;
+
+ private:
+  context_t host;
+  context_t* target;
+  pthread_t producer;
+  sem_t req_produce;
+  sem_t req_consume;
+  sem_t resp_produce;
+  sem_t resp_consume;
+  req req_buf;
+  resp resp_buf;
+  bool running;
+
+  uint32_t run_abstract_command(uint32_t command, const uint32_t program[], size_t program_n,
+                                uint32_t data[], size_t data_n);
+
+  void die(uint32_t cmderr);
+  void halt(int);
+  int enumerate_harts();
+  void select_hart(int);
+  void resume(int);
+  uint64_t save_reg(unsigned regno);
+  void restore_reg(unsigned regno, uint64_t val);
+  
+  uint64_t modify_csr(unsigned which, uint64_t data, uint32_t type);
+
+  bool req_wait;
+  bool resp_wait;
+  uint32_t data_base;
+  
+  uint32_t xlen;
+
+  static const int max_idle_cycles = 10000;
+
+  size_t ram_words;
+  size_t data_words;
+  int num_harts;
+  int current_hart;
+  
+  uint32_t get_xlen();
+  uint32_t do_command(dtm_t::req r);
+
+  void parse_args(const std::vector<std::string>& args);
+  void register_devices();
+  void start_host_thread();
+
+  friend class memif_t;
+};
+
+#endif

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/dummy.cc

@@ -0,0 +1,4 @@
+// See LICENSE for license details.
+
+// help out poor, C-centric autoconf
+extern "C" void libfesvr_is_present() {}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/elfloader.cc

@@ -0,0 +1,89 @@
+// See LICENSE for license details.
+
+#include "elf.h"
+#include "memif.h"
+#include <cstring>
+#include <string>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <assert.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <vector>
+#include <map>
+
+std::map<std::string, uint64_t> load_elf(const char* fn, memif_t* memif, reg_t* entry)
+{
+  int fd = open(fn, O_RDONLY);
+  struct stat s;
+  assert(fd != -1);
+  if (fstat(fd, &s) < 0)
+    abort();
+  size_t size = s.st_size;
+
+  char* buf = (char*)mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
+  assert(buf != MAP_FAILED);
+  close(fd);
+
+  assert(size >= sizeof(Elf64_Ehdr));
+  const Elf64_Ehdr* eh64 = (const Elf64_Ehdr*)buf;
+  assert(IS_ELF32(*eh64) || IS_ELF64(*eh64));
+
+  std::vector<uint8_t> zeros;
+  std::map<std::string, uint64_t> symbols;
+
+  #define LOAD_ELF(ehdr_t, phdr_t, shdr_t, sym_t) do { \
+    ehdr_t* eh = (ehdr_t*)buf; \
+    phdr_t* ph = (phdr_t*)(buf + eh->e_phoff); \
+    *entry = eh->e_entry; \
+    assert(size >= eh->e_phoff + eh->e_phnum*sizeof(*ph)); \
+    for (unsigned i = 0; i < eh->e_phnum; i++) { \
+      if(ph[i].p_type == PT_LOAD && ph[i].p_memsz) { \
+        if (ph[i].p_filesz) { \
+          assert(size >= ph[i].p_offset + ph[i].p_filesz); \
+          memif->write(ph[i].p_paddr, ph[i].p_filesz, (uint8_t*)buf + ph[i].p_offset); \
+        } \
+        zeros.resize(ph[i].p_memsz - ph[i].p_filesz); \
+        memif->write(ph[i].p_paddr + ph[i].p_filesz, ph[i].p_memsz - ph[i].p_filesz, &zeros[0]); \
+      } \
+    } \
+    shdr_t* sh = (shdr_t*)(buf + eh->e_shoff); \
+    assert(size >= eh->e_shoff + eh->e_shnum*sizeof(*sh)); \
+    assert(eh->e_shstrndx < eh->e_shnum); \
+    assert(size >= sh[eh->e_shstrndx].sh_offset + sh[eh->e_shstrndx].sh_size); \
+    char *shstrtab = buf + sh[eh->e_shstrndx].sh_offset; \
+    unsigned strtabidx = 0, symtabidx = 0; \
+    for (unsigned i = 0; i < eh->e_shnum; i++) { \
+      unsigned max_len = sh[eh->e_shstrndx].sh_size - sh[i].sh_name; \
+      assert(sh[i].sh_name < sh[eh->e_shstrndx].sh_size); \
+      assert(strnlen(shstrtab + sh[i].sh_name, max_len) < max_len); \
+      if (sh[i].sh_type & SHT_NOBITS) continue; \
+      assert(size >= sh[i].sh_offset + sh[i].sh_size); \
+      if (strcmp(shstrtab + sh[i].sh_name, ".strtab") == 0) \
+        strtabidx = i; \
+      if (strcmp(shstrtab + sh[i].sh_name, ".symtab") == 0) \
+        symtabidx = i; \
+    } \
+    if (strtabidx && symtabidx) { \
+      char* strtab = buf + sh[strtabidx].sh_offset; \
+      sym_t* sym = (sym_t*)(buf + sh[symtabidx].sh_offset); \
+      for (unsigned i = 0; i < sh[symtabidx].sh_size/sizeof(sym_t); i++) { \
+        unsigned max_len = sh[strtabidx].sh_size - sym[i].st_name; \
+        assert(sym[i].st_name < sh[strtabidx].sh_size); \
+        assert(strnlen(strtab + sym[i].st_name, max_len) < max_len); \
+        symbols[strtab + sym[i].st_name] = sym[i].st_value; \
+      } \
+    } \
+  } while(0)
+
+  if (IS_ELF32(*eh64))
+    LOAD_ELF(Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr, Elf32_Sym);
+  else
+    LOAD_ELF(Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr, Elf64_Sym);
+
+  munmap(buf, size);
+
+  return symbols;
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/fesvr.pc.in

@@ -0,0 +1,26 @@
+#=========================================================================
+# Modular C++ Build System Subproject Package Config
+#=========================================================================
+# Please read the documenation in 'mcppbs-uguide.txt' for more details
+# on how the Modular C++ Build System works.
+
+#-------------------------------------------------------------------------
+# Generic variables 
+#-------------------------------------------------------------------------
+
+prefix=@prefix@
+include_dir=${prefix}/include/fesvr
+lib_dir=${prefix}/lib
+
+#-------------------------------------------------------------------------
+# Keywords
+#-------------------------------------------------------------------------
+
+Name        : fesvr
+Version     : @PACKAGE_VERSION@
+Description : Frontend Server C/C++ API
+Requires    : @fesvr_pkcdeps@
+Cflags      : -I${include_dir} @CPPFLAGS@ @fesvr_extra_cppflags@
+Libs        : -L${lib_dir} @LDFLAGS@ @fesvr_extra_ldflags@ \
+              -lfesvr @fesvr_extra_libs@
+

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/htif.h

@@ -0,0 +1,114 @@
+// See LICENSE for license details.
+
+#ifndef __HTIF_H
+#define __HTIF_H
+
+#include "memif.h"
+#include "syscall.h"
+#include "device.h"
+#include <string.h>
+#include <vector>
+
+class htif_t : public chunked_memif_t
+{
+ public:
+  htif_t();
+  htif_t(int argc, char** argv);
+  htif_t(const std::vector<std::string>& args);
+  virtual ~htif_t();
+
+  virtual void start();
+  virtual void stop();
+
+  int run();
+  bool done();
+  int exit_code();
+
+  virtual memif_t& memif() { return mem; }
+
+ protected:
+  virtual void reset() = 0;
+
+  virtual void read_chunk(addr_t taddr, size_t len, void* dst) = 0;
+  virtual void write_chunk(addr_t taddr, size_t len, const void* src) = 0;
+  virtual void clear_chunk(addr_t taddr, size_t len);
+
+  virtual size_t chunk_align() = 0;
+  virtual size_t chunk_max_size() = 0;
+
+  virtual void load_program();
+  virtual void idle() {}
+
+  const std::vector<std::string>& host_args() { return hargs; }
+
+  reg_t get_entry_point() { return entry; }
+
+  // indicates that the initial program load can skip writing this address
+  // range to memory, because it has already been loaded through a sideband
+  virtual bool is_address_preloaded(addr_t taddr, size_t len) { return false; }
+
+ private:
+  void parse_arguments(int argc, char ** argv);
+  void register_devices();
+  void usage(const char * program_name);
+
+  memif_t mem;
+  reg_t entry;
+  bool writezeros;
+  std::vector<std::string> hargs;
+  std::vector<std::string> targs;
+  std::string sig_file;
+  addr_t sig_addr; // torture
+  addr_t sig_len; // torture
+  addr_t tohost_addr;
+  addr_t fromhost_addr;
+  int exitcode;
+  bool stopped;
+
+  device_list_t device_list;
+  syscall_t syscall_proxy;
+  bcd_t bcd;
+  std::vector<device_t*> dynamic_devices;
+
+  const std::vector<std::string>& target_args() { return targs; }
+
+  friend class memif_t;
+  friend class syscall_t;
+};
+
+/* Alignment guide for emulator.cc options:
+  -x, --long-option        Description with max 80 characters --------------->\n\
+       +plus-arg-equivalent\n\
+ */
+#define HTIF_USAGE_OPTIONS \
+"HOST OPTIONS\n\
+  -h, --help               Display this help and exit\n\
+       +permissive         The host will ignore any unparsed options up until\n\
+                             +permissive-off (Only needed for VCS)\n\
+       +permissive-off     Stop ignoring options. This is mandatory if using\n\
+                             +permissive (Only needed for VCS)\n\
+      --rfb=DISPLAY        Add new remote frame buffer on display DISPLAY\n\
+       +rfb=DISPLAY          to be accessible on 5900 + DISPLAY (default = 0)\n\
+      --signature=FILE     Write torture test signature to FILE\n\
+       +signature=FILE\n\
+      --chroot=PATH        Use PATH as location of syscall-servicing binaries\n\
+       +chroot=PATH\n\
+\n\
+HOST OPTIONS (currently unsupported)\n\
+      --disk=DISK          Add DISK device. Use a ramdisk since this isn't\n\
+       +disk=DISK            supported\n\
+\n\
+TARGET (RISC-V BINARY) OPTIONS\n\
+  These are the options passed to the program executing on the emulated RISC-V\n\
+  microprocessor.\n"
+
+#define HTIF_LONG_OPTIONS_OPTIND 1024
+#define HTIF_LONG_OPTIONS                                               \
+{"help",      no_argument,       0, 'h'                          },     \
+{"rfb",       optional_argument, 0, HTIF_LONG_OPTIONS_OPTIND     },     \
+{"disk",      required_argument, 0, HTIF_LONG_OPTIONS_OPTIND + 1 },     \
+{"signature", required_argument, 0, HTIF_LONG_OPTIONS_OPTIND + 2 },     \
+{"chroot",    required_argument, 0, HTIF_LONG_OPTIONS_OPTIND + 3 },     \
+{0, 0, 0, 0}
+
+#endif // __HTIF_H

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/htif_hexwriter.cc

@@ -0,0 +1,76 @@
+// See LICENSE for license details.
+
+#include <iostream>
+#include <assert.h>
+#include "htif_hexwriter.h"
+
+htif_hexwriter_t::htif_hexwriter_t(size_t b, size_t w, size_t d)
+  : base(b), width(w), depth(d)
+{
+}
+
+void htif_hexwriter_t::read_chunk(addr_t taddr, size_t len, void* vdst)
+{
+  taddr -= base;
+
+  assert(len % chunk_align() == 0);
+  assert(taddr < width*depth);
+  assert(taddr+len <= width*depth);
+
+  uint8_t* dst = (uint8_t*)vdst;
+  while(len)
+  {
+    if(mem[taddr/width].size() == 0)
+      mem[taddr/width].resize(width,0);
+
+    for(size_t j = 0; j < width; j++)
+      dst[j] = mem[taddr/width][j];
+
+    len -= width;
+    taddr += width;
+    dst += width;
+  }
+}
+
+void htif_hexwriter_t::write_chunk(addr_t taddr, size_t len, const void* vsrc)
+{
+  taddr -= base;
+
+  assert(len % chunk_align() == 0);
+  assert(taddr < width*depth);
+  assert(taddr+len <= width*depth);
+
+  const uint8_t* src = (const uint8_t*)vsrc;
+  while(len)
+  {
+    if(mem[taddr/width].size() == 0)
+      mem[taddr/width].resize(width,0);
+
+    for(size_t j = 0; j < width; j++)
+      mem[taddr/width][j] = src[j];
+
+    len -= width;
+    taddr += width;
+  }
+}
+
+std::ostream& operator<< (std::ostream& o, const htif_hexwriter_t& h)
+{
+  std::ios_base::fmtflags flags = o.setf(std::ios::hex,std::ios::basefield);
+
+  for(size_t addr = 0; addr < h.depth; addr++)
+  {
+    std::map<addr_t,std::vector<char> >::const_iterator i = h.mem.find(addr);
+    if(i == h.mem.end())
+      for(size_t j = 0; j < h.width; j++)
+        o << "00";
+    else
+      for(size_t j = 0; j < h.width; j++)
+        o << ((i->second[h.width-j-1] >> 4) & 0xF) << (i->second[h.width-j-1] & 0xF);
+    o << std::endl;
+  }
+
+  o.setf(flags);
+
+  return o;
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/htif_hexwriter.h

@@ -0,0 +1,32 @@
+// See LICENSE for license details.
+
+#ifndef __HTIF_HEXWRITER_H
+#define __HTIF_HEXWRITER_H
+
+#include <map>
+#include <vector>
+#include <stdlib.h>
+#include "memif.h"
+
+class htif_hexwriter_t : public chunked_memif_t
+{
+public:
+  htif_hexwriter_t(size_t b, size_t w, size_t d);
+
+protected:
+  size_t base;
+  size_t width;
+  size_t depth;
+  std::map<addr_t,std::vector<char> > mem;
+
+  void read_chunk(addr_t taddr, size_t len, void* dst);
+  void write_chunk(addr_t taddr, size_t len, const void* src);
+  void clear_chunk(addr_t taddr, size_t len) {}
+
+  size_t chunk_max_size() { return width; }
+  size_t chunk_align() { return width; }
+
+  friend std::ostream& operator<< (std::ostream&, const htif_hexwriter_t&);
+};
+
+#endif // __HTIF_HEXWRITER_H

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/htif_pthread.cc

@@ -0,0 +1,66 @@
+// See LICENSE for license details.
+
+#include "htif_pthread.h"
+#include <algorithm>
+#include <stdio.h>
+
+void htif_pthread_t::thread_main(void* arg)
+{
+  htif_pthread_t* htif = static_cast<htif_pthread_t*>(arg);
+  htif->run();
+  while (true)
+    htif->target->switch_to();
+}
+
+htif_pthread_t::htif_pthread_t(int argc, char** argv)
+    : htif_t(argc, argv)
+{
+  target = context_t::current();
+  host.init(thread_main, this);
+}
+
+htif_pthread_t::~htif_pthread_t()
+{
+}
+
+ssize_t htif_pthread_t::read(void* buf, size_t max_size)
+{
+  while (th_data.size() == 0)
+    target->switch_to();
+
+  size_t s = std::min(max_size, th_data.size());
+  std::copy(th_data.begin(), th_data.begin() + s, (char*)buf);
+  th_data.erase(th_data.begin(), th_data.begin() + s);
+
+  return s;
+}
+
+ssize_t htif_pthread_t::write(const void* buf, size_t size)
+{
+  ht_data.insert(ht_data.end(), (const char*)buf, (const char*)buf + size);
+  return size;
+}
+
+void htif_pthread_t::send(const void* buf, size_t size)
+{
+  th_data.insert(th_data.end(), (const char*)buf, (const char*)buf + size);
+}
+
+void htif_pthread_t::recv(void* buf, size_t size)
+{
+  while (!this->recv_nonblocking(buf, size))
+    ;
+}
+
+bool htif_pthread_t::recv_nonblocking(void* buf, size_t size)
+{
+  if (ht_data.size() < size)
+  {
+    host.switch_to();
+    return false;
+  }
+
+  std::copy(ht_data.begin(), ht_data.begin() + size, (char*)buf);
+  ht_data.erase(ht_data.begin(), ht_data.begin() + size);
+  return true;
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/htif_pthread.h

@@ -0,0 +1,38 @@
+// See LICENSE for license details.
+
+#ifndef _HTIF_PTHREAD_H
+#define _HTIF_PTHREAD_H
+
+#include "htif.h"
+#include "context.h"
+#include <deque>
+
+class htif_pthread_t : public htif_t
+{
+ public:
+  htif_pthread_t(int argc, char** argv);
+  virtual ~htif_pthread_t();
+
+  // target inteface
+  void send(const void* buf, size_t size);
+  void recv(void* buf, size_t size);
+  bool recv_nonblocking(void* buf, size_t size);
+
+ protected:
+  // host interface
+  virtual ssize_t read(void* buf, size_t max_size);
+  virtual ssize_t write(const void* buf, size_t size);
+
+  virtual size_t chunk_align() { return 64; }
+  virtual size_t chunk_max_size() { return 1024; }
+
+ private:
+  context_t host;
+  context_t* target;
+  std::deque<char> th_data;
+  std::deque<char> ht_data;
+
+  static void thread_main(void* htif);
+};
+
+#endif

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/memif.cc

@@ -0,0 +1,183 @@
+// See LICENSE for license details.
+
+#include <algorithm>
+#include <stdlib.h>
+#include <string.h>
+#include <stdexcept>
+#include "memif.h"
+
+void memif_t::read(addr_t addr, size_t len, void* bytes)
+{
+  size_t align = cmemif->chunk_align();
+  if (len && (addr & (align-1)))
+  {
+    size_t this_len = std::min(len, align - size_t(addr & (align-1)));
+    uint8_t chunk[align];
+
+    cmemif->read_chunk(addr & ~(align-1), align, chunk);
+    memcpy(bytes, chunk + (addr & (align-1)), this_len);
+
+    bytes = (char*)bytes + this_len;
+    addr += this_len;
+    len -= this_len;
+  }
+
+  if (len & (align-1))
+  {
+    size_t this_len = len & (align-1);
+    size_t start = len - this_len;
+    uint8_t chunk[align];
+
+    cmemif->read_chunk(addr + start, align, chunk);
+    memcpy((char*)bytes + start, chunk, this_len);
+
+    len -= this_len;
+  }
+
+  // now we're aligned
+  for (size_t pos = 0; pos < len; pos += cmemif->chunk_max_size())
+    cmemif->read_chunk(addr + pos, std::min(cmemif->chunk_max_size(), len - pos), (char*)bytes + pos);
+}
+
+void memif_t::write(addr_t addr, size_t len, const void* bytes)
+{
+  size_t align = cmemif->chunk_align();
+  if (len && (addr & (align-1)))
+  {
+    size_t this_len = std::min(len, align - size_t(addr & (align-1)));
+    uint8_t chunk[align];
+
+    cmemif->read_chunk(addr & ~(align-1), align, chunk);
+    memcpy(chunk + (addr & (align-1)), bytes, this_len);
+    cmemif->write_chunk(addr & ~(align-1), align, chunk);
+
+    bytes = (char*)bytes + this_len;
+    addr += this_len;
+    len -= this_len;
+  }
+
+  if (len & (align-1))
+  {
+    size_t this_len = len & (align-1);
+    size_t start = len - this_len;
+    uint8_t chunk[align];
+
+    cmemif->read_chunk(addr + start, align, chunk);
+    memcpy(chunk, (char*)bytes + start, this_len);
+    cmemif->write_chunk(addr + start, align, chunk);
+
+    len -= this_len;
+  }
+
+  // now we're aligned
+  bool all_zero = len != 0;
+  for (size_t i = 0; i < len; i++)
+    all_zero &= ((const char*)bytes)[i] == 0;
+
+  if (all_zero) {
+    cmemif->clear_chunk(addr, len);
+  } else {
+    size_t max_chunk = cmemif->chunk_max_size();
+    for (size_t pos = 0; pos < len; pos += max_chunk)
+      cmemif->write_chunk(addr + pos, std::min(max_chunk, len - pos), (char*)bytes + pos);
+  }
+}
+
+#define MEMIF_READ_FUNC \
+  if(addr & (sizeof(val)-1)) \
+    throw std::runtime_error("misaligned address"); \
+  this->read(addr, sizeof(val), &val); \
+  return val
+
+#define MEMIF_WRITE_FUNC \
+  if(addr & (sizeof(val)-1)) \
+    throw std::runtime_error("misaligned address"); \
+  this->write(addr, sizeof(val), &val)
+
+uint8_t memif_t::read_uint8(addr_t addr)
+{
+  uint8_t val;
+  MEMIF_READ_FUNC;
+}
+
+int8_t memif_t::read_int8(addr_t addr)
+{
+  int8_t val;
+  MEMIF_READ_FUNC;
+}
+
+void memif_t::write_uint8(addr_t addr, uint8_t val)
+{
+  MEMIF_WRITE_FUNC;
+}
+
+void memif_t::write_int8(addr_t addr, int8_t val)
+{
+  MEMIF_WRITE_FUNC;
+}
+
+uint16_t memif_t::read_uint16(addr_t addr)
+{
+  uint16_t val;
+  MEMIF_READ_FUNC;
+}
+
+int16_t memif_t::read_int16(addr_t addr)
+{
+  int16_t val;
+  MEMIF_READ_FUNC;
+}
+
+void memif_t::write_uint16(addr_t addr, uint16_t val)
+{
+  MEMIF_WRITE_FUNC;
+}
+
+void memif_t::write_int16(addr_t addr, int16_t val)
+{
+  MEMIF_WRITE_FUNC;
+}
+
+uint32_t memif_t::read_uint32(addr_t addr)
+{
+  uint32_t val;
+  MEMIF_READ_FUNC;
+}
+
+int32_t memif_t::read_int32(addr_t addr)
+{
+  int32_t val;
+  MEMIF_READ_FUNC;
+}
+
+void memif_t::write_uint32(addr_t addr, uint32_t val)
+{
+  MEMIF_WRITE_FUNC;
+}
+
+void memif_t::write_int32(addr_t addr, int32_t val)
+{
+  MEMIF_WRITE_FUNC;
+}
+
+uint64_t memif_t::read_uint64(addr_t addr)
+{
+  uint64_t val;
+  MEMIF_READ_FUNC;
+}
+
+int64_t memif_t::read_int64(addr_t addr)
+{
+  int64_t val;
+  MEMIF_READ_FUNC;
+}
+
+void memif_t::write_uint64(addr_t addr, uint64_t val)
+{
+  MEMIF_WRITE_FUNC;
+}
+
+void memif_t::write_int64(addr_t addr, int64_t val)
+{
+  MEMIF_WRITE_FUNC;
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/memif.h

@@ -0,0 +1,62 @@
+// See LICENSE for license details.
+
+#ifndef __MEMIF_H
+#define __MEMIF_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef uint64_t reg_t;
+typedef int64_t sreg_t;
+typedef reg_t addr_t;
+
+class chunked_memif_t
+{
+public:
+  virtual void read_chunk(addr_t taddr, size_t len, void* dst) = 0;
+  virtual void write_chunk(addr_t taddr, size_t len, const void* src) = 0;
+  virtual void clear_chunk(addr_t taddr, size_t len) = 0;
+
+  virtual size_t chunk_align() = 0;
+  virtual size_t chunk_max_size() = 0;
+};
+
+class memif_t
+{
+public:
+  memif_t(chunked_memif_t* _cmemif) : cmemif(_cmemif) {}
+  virtual ~memif_t(){}
+
+  // read and write byte arrays
+  virtual void read(addr_t addr, size_t len, void* bytes);
+  virtual void write(addr_t addr, size_t len, const void* bytes);
+
+  // read and write 8-bit words
+  virtual uint8_t read_uint8(addr_t addr);
+  virtual int8_t read_int8(addr_t addr);
+  virtual void write_uint8(addr_t addr, uint8_t val);
+  virtual void write_int8(addr_t addr, int8_t val);
+
+  // read and write 16-bit words
+  virtual uint16_t read_uint16(addr_t addr);
+  virtual int16_t read_int16(addr_t addr);
+  virtual void write_uint16(addr_t addr, uint16_t val);
+  virtual void write_int16(addr_t addr, int16_t val);
+
+  // read and write 32-bit words
+  virtual uint32_t read_uint32(addr_t addr);
+  virtual int32_t read_int32(addr_t addr);
+  virtual void write_uint32(addr_t addr, uint32_t val);
+  virtual void write_int32(addr_t addr, int32_t val);
+
+  // read and write 64-bit words
+  virtual uint64_t read_uint64(addr_t addr);
+  virtual int64_t read_int64(addr_t addr);
+  virtual void write_uint64(addr_t addr, uint64_t val);
+  virtual void write_int64(addr_t addr, int64_t val);
+
+protected:
+  chunked_memif_t* cmemif;
+};
+
+#endif // __MEMIF_H

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/rfb.h

@@ -0,0 +1,53 @@
+#ifndef _RFB_H
+#define _RFB_H
+
+#include "device.h"
+#include "memif.h"
+#include <pthread.h>
+
+// remote frame buffer
+class rfb_t : public device_t
+{
+ public:
+  rfb_t(int display = 0);
+  ~rfb_t();
+  void tick();
+  std::string name() { return "RISC-V"; }
+  const char* identity() { return "rfb"; }
+
+ private:
+  template <typename T>
+  std::string str(T x)
+  {
+    return std::string((char*)&x, sizeof(x));
+  }
+  size_t fb_bytes() { return size_t(width) * height * bpp/8; }
+  void thread_main();
+  friend void* rfb_thread_main(void*);
+  std::string pixel_format();
+  void fb_update(const std::string& s);
+  void set_encodings(const std::string& s);
+  void set_pixel_format(const std::string& s);
+  void write(const std::string& s);
+  std::string read();
+  void handle_configure(command_t cmd);
+  void handle_set_address(command_t cmd);
+
+  int sockfd;
+  int afd;
+  memif_t* memif;
+  reg_t addr;
+  uint16_t width;
+  uint16_t height;
+  uint16_t bpp;
+  int display;
+  pthread_t thread;
+  volatile char* volatile fb1;
+  volatile char* volatile fb2;
+  size_t read_pos;
+  pthread_mutex_t lock;
+
+  static const int FB_ALIGN = 256;
+};
+
+#endif

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/syscall.cc

@@ -0,0 +1,394 @@
+// See LICENSE for license details.
+
+#include "syscall.h"
+#include "htif.h"
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <termios.h>
+#include <sstream>
+#include <iostream>
+using namespace std::placeholders;
+
+#define RISCV_AT_FDCWD -100
+
+struct riscv_stat
+{
+  uint64_t dev;
+  uint64_t ino;
+  uint32_t mode;
+  uint32_t nlink;
+  uint32_t uid;
+  uint32_t gid;
+  uint64_t rdev;
+  uint64_t __pad1;
+  uint64_t size;
+  uint32_t blksize;
+  uint32_t __pad2;
+  uint64_t blocks;
+  uint64_t atime;
+  uint64_t __pad3;
+  uint64_t mtime;
+  uint64_t __pad4;
+  uint64_t ctime;
+  uint64_t __pad5;
+  uint32_t __unused4;
+  uint32_t __unused5;
+
+  riscv_stat(const struct stat& s)
+    : dev(s.st_dev), ino(s.st_ino), mode(s.st_mode), nlink(s.st_nlink),
+      uid(s.st_uid), gid(s.st_gid), rdev(s.st_rdev), __pad1(0),
+      size(s.st_size), blksize(s.st_blksize), __pad2(0),
+      blocks(s.st_blocks), atime(s.st_atime), __pad3(0),
+      mtime(s.st_mtime), __pad4(0), ctime(s.st_ctime), __pad5(0),
+      __unused4(0), __unused5(0) {}
+};
+
+syscall_t::syscall_t(htif_t* htif)
+  : htif(htif), memif(&htif->memif()), table(2048)
+{
+  table[17] = &syscall_t::sys_getcwd;
+  table[25] = &syscall_t::sys_fcntl;
+  table[34] = &syscall_t::sys_mkdirat;
+  table[35] = &syscall_t::sys_unlinkat;
+  table[37] = &syscall_t::sys_linkat;
+  table[38] = &syscall_t::sys_renameat;
+  table[46] = &syscall_t::sys_ftruncate;
+  table[48] = &syscall_t::sys_faccessat;
+  table[49] = &syscall_t::sys_chdir;
+  table[56] = &syscall_t::sys_openat;
+  table[57] = &syscall_t::sys_close;
+  table[62] = &syscall_t::sys_lseek;
+  table[63] = &syscall_t::sys_read;
+  table[64] = &syscall_t::sys_write;
+  table[67] = &syscall_t::sys_pread;
+  table[68] = &syscall_t::sys_pwrite;
+  table[79] = &syscall_t::sys_fstatat;
+  table[80] = &syscall_t::sys_fstat;
+  table[93] = &syscall_t::sys_exit;
+  table[1039] = &syscall_t::sys_lstat;
+  table[2011] = &syscall_t::sys_getmainvars;
+
+  register_command(0, std::bind(&syscall_t::handle_syscall, this, _1), "syscall");
+
+  int stdin_fd = dup(0), stdout_fd0 = dup(1), stdout_fd1 = dup(1);
+  if (stdin_fd < 0 || stdout_fd0 < 0 || stdout_fd1 < 0)
+    throw std::runtime_error("could not dup stdin/stdout");
+
+  fds.alloc(stdin_fd); // stdin -> stdin
+  fds.alloc(stdout_fd0); // stdout -> stdout
+  fds.alloc(stdout_fd1); // stderr -> stdout
+}
+
+std::string syscall_t::do_chroot(const char* fn)
+{
+  if (!chroot.empty() && *fn == '/')
+    return chroot + fn;
+  return fn;
+}
+
+std::string syscall_t::undo_chroot(const char* fn)
+{
+  if (chroot.empty())
+    return fn;
+  if (strncmp(fn, chroot.c_str(), chroot.size()) == 0
+      && (chroot.back() == '/' || fn[chroot.size()] == '/'))
+    return fn + chroot.size() - (chroot.back() == '/');
+  return "/";
+}
+
+void syscall_t::handle_syscall(command_t cmd)
+{
+  if (cmd.payload() & 1) // test pass/fail
+  {
+    htif->exitcode = cmd.payload();
+    if (htif->exit_code())
+      std::cerr << "*** FAILED *** (tohost = " << htif->exit_code() << ")" << std::endl;
+    return;
+  }
+  else // proxied system call
+    dispatch(cmd.payload());
+
+  cmd.respond(1);
+}
+
+reg_t syscall_t::sys_exit(reg_t code, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  htif->exitcode = code << 1 | 1;
+  return 0;
+}
+
+static reg_t sysret_errno(sreg_t ret)
+{
+  return ret == -1 ? -errno : ret;
+}
+
+reg_t syscall_t::sys_read(reg_t fd, reg_t pbuf, reg_t len, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> buf(len);
+  ssize_t ret = read(fds.lookup(fd), &buf[0], len);
+  reg_t ret_errno = sysret_errno(ret);
+  if (ret > 0)
+    memif->write(pbuf, ret, &buf[0]);
+  return ret_errno;
+}
+
+reg_t syscall_t::sys_pread(reg_t fd, reg_t pbuf, reg_t len, reg_t off, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> buf(len);
+  ssize_t ret = pread(fds.lookup(fd), &buf[0], len, off);
+  reg_t ret_errno = sysret_errno(ret);
+  if (ret > 0)
+    memif->write(pbuf, ret, &buf[0]);
+  return ret_errno;
+}
+
+reg_t syscall_t::sys_write(reg_t fd, reg_t pbuf, reg_t len, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> buf(len);
+  memif->read(pbuf, len, &buf[0]);
+  reg_t ret = sysret_errno(write(fds.lookup(fd), &buf[0], len));
+  return ret;
+}
+
+reg_t syscall_t::sys_pwrite(reg_t fd, reg_t pbuf, reg_t len, reg_t off, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> buf(len);
+  memif->read(pbuf, len, &buf[0]);
+  reg_t ret = sysret_errno(pwrite(fds.lookup(fd), &buf[0], len, off));
+  return ret;
+}
+
+reg_t syscall_t::sys_close(reg_t fd, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  if (close(fds.lookup(fd)) < 0)
+    return sysret_errno(-1);
+  fds.dealloc(fd);
+  return 0;
+}
+
+reg_t syscall_t::sys_lseek(reg_t fd, reg_t ptr, reg_t dir, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  return sysret_errno(lseek(fds.lookup(fd), ptr, dir));
+}
+
+reg_t syscall_t::sys_fstat(reg_t fd, reg_t pbuf, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  struct stat buf;
+  reg_t ret = sysret_errno(fstat(fds.lookup(fd), &buf));
+  if (ret != (reg_t)-1)
+  {
+    riscv_stat rbuf(buf);
+    memif->write(pbuf, sizeof(rbuf), &rbuf);
+  }
+  return ret;
+}
+
+reg_t syscall_t::sys_fcntl(reg_t fd, reg_t cmd, reg_t arg, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  return sysret_errno(fcntl(fds.lookup(fd), cmd, arg));
+}
+
+reg_t syscall_t::sys_ftruncate(reg_t fd, reg_t len, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  return sysret_errno(ftruncate(fds.lookup(fd), len));
+}
+
+reg_t syscall_t::sys_lstat(reg_t pname, reg_t len, reg_t pbuf, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> name(len);
+  memif->read(pname, len, &name[0]);
+
+  struct stat buf;
+  reg_t ret = sysret_errno(lstat(do_chroot(&name[0]).c_str(), &buf));
+  riscv_stat rbuf(buf);
+  if (ret != (reg_t)-1)
+  {
+    riscv_stat rbuf(buf);
+    memif->write(pbuf, sizeof(rbuf), &rbuf);
+  }
+  return ret;
+}
+
+#define AT_SYSCALL(syscall, fd, name, ...) \
+  (syscall(fds.lookup(fd), int(fd) == RISCV_AT_FDCWD ? do_chroot(name).c_str() : (name), __VA_ARGS__))
+
+reg_t syscall_t::sys_openat(reg_t dirfd, reg_t pname, reg_t len, reg_t flags, reg_t mode, reg_t a5, reg_t a6)
+{
+  std::vector<char> name(len);
+  memif->read(pname, len, &name[0]);
+  int fd = sysret_errno(AT_SYSCALL(openat, dirfd, &name[0], flags, mode));
+  if (fd < 0)
+    return sysret_errno(-1);
+  return fds.alloc(fd);
+}
+
+reg_t syscall_t::sys_fstatat(reg_t dirfd, reg_t pname, reg_t len, reg_t pbuf, reg_t flags, reg_t a5, reg_t a6)
+{
+  std::vector<char> name(len);
+  memif->read(pname, len, &name[0]);
+
+  struct stat buf;
+  reg_t ret = sysret_errno(AT_SYSCALL(fstatat, dirfd, &name[0], &buf, flags));
+  if (ret != (reg_t)-1)
+  {
+    riscv_stat rbuf(buf);
+    memif->write(pbuf, sizeof(rbuf), &rbuf);
+  }
+  return ret;
+}
+
+reg_t syscall_t::sys_faccessat(reg_t dirfd, reg_t pname, reg_t len, reg_t mode, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> name(len);
+  memif->read(pname, len, &name[0]);
+  return sysret_errno(AT_SYSCALL(faccessat, dirfd, &name[0], mode, 0));
+}
+
+reg_t syscall_t::sys_renameat(reg_t odirfd, reg_t popath, reg_t olen, reg_t ndirfd, reg_t pnpath, reg_t nlen, reg_t a6)
+{
+  std::vector<char> opath(olen), npath(nlen);
+  memif->read(popath, olen, &opath[0]);
+  memif->read(pnpath, nlen, &npath[0]);
+  return sysret_errno(renameat(fds.lookup(odirfd), int(odirfd) == RISCV_AT_FDCWD ? do_chroot(&opath[0]).c_str() : &opath[0],
+                             fds.lookup(ndirfd), int(ndirfd) == RISCV_AT_FDCWD ? do_chroot(&npath[0]).c_str() : &npath[0]));
+}
+
+reg_t syscall_t::sys_linkat(reg_t odirfd, reg_t poname, reg_t olen, reg_t ndirfd, reg_t pnname, reg_t nlen, reg_t flags)
+{
+  std::vector<char> oname(olen), nname(nlen);
+  memif->read(poname, olen, &oname[0]);
+  memif->read(pnname, nlen, &nname[0]);
+  return sysret_errno(linkat(fds.lookup(odirfd), int(odirfd) == RISCV_AT_FDCWD ? do_chroot(&oname[0]).c_str() : &oname[0],
+                             fds.lookup(ndirfd), int(ndirfd) == RISCV_AT_FDCWD ? do_chroot(&nname[0]).c_str() : &nname[0],
+                             flags));
+}
+
+reg_t syscall_t::sys_unlinkat(reg_t dirfd, reg_t pname, reg_t len, reg_t flags, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> name(len);
+  memif->read(pname, len, &name[0]);
+  return sysret_errno(AT_SYSCALL(unlinkat, dirfd, &name[0], flags));
+}
+
+reg_t syscall_t::sys_mkdirat(reg_t dirfd, reg_t pname, reg_t len, reg_t mode, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> name(len);
+  memif->read(pname, len, &name[0]);
+  return sysret_errno(AT_SYSCALL(mkdirat, dirfd, &name[0], mode));
+}
+
+reg_t syscall_t::sys_getcwd(reg_t pbuf, reg_t size, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<char> buf(size);
+  char* ret = getcwd(&buf[0], size);
+  if (ret == NULL)
+    return sysret_errno(-1);
+  std::string tmp = undo_chroot(&buf[0]);
+  if (size <= tmp.size())
+    return -ENOMEM;
+  memif->write(pbuf, tmp.size() + 1, &tmp[0]);
+  return tmp.size() + 1;
+}
+
+reg_t syscall_t::sys_getmainvars(reg_t pbuf, reg_t limit, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  std::vector<std::string> args = htif->target_args();
+  std::vector<uint64_t> words(args.size() + 3);
+  words[0] = args.size();
+  words[args.size()+1] = 0; // argv[argc] = NULL
+  words[args.size()+2] = 0; // envp[0] = NULL
+
+  size_t sz = (args.size() + 3) * sizeof(words[0]);
+  for (size_t i = 0; i < args.size(); i++)
+  {
+    words[i+1] = sz + pbuf;
+    sz += args[i].length() + 1;
+  }
+
+  std::vector<char> bytes(sz);
+  memcpy(&bytes[0], &words[0], sizeof(words[0]) * words.size());
+  for (size_t i = 0; i < args.size(); i++)
+    strcpy(&bytes[words[i+1] - pbuf], args[i].c_str());
+
+  if (bytes.size() > limit)
+    return -ENOMEM;
+
+  memif->write(pbuf, bytes.size(), &bytes[0]);
+  return 0;
+}
+
+reg_t syscall_t::sys_chdir(reg_t path, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
+{
+  size_t size = 0;
+  while (memif->read_uint8(path + size++))
+    ;
+  std::vector<char> buf(size);
+  for (size_t offset = 0;; offset++)
+  {
+    buf[offset] = memif->read_uint8(path + offset);
+    if (!buf[offset])
+      break;
+  }
+  return sysret_errno(chdir(buf.data()));
+}
+
+void syscall_t::dispatch(reg_t mm)
+{
+  reg_t magicmem[8];
+  memif->read(mm, sizeof(magicmem), magicmem);
+
+  reg_t n = magicmem[0];
+  if (n >= table.size() || !table[n])
+    throw std::runtime_error("bad syscall #" + std::to_string(n));
+
+  magicmem[0] = (this->*table[n])(magicmem[1], magicmem[2], magicmem[3], magicmem[4], magicmem[5], magicmem[6], magicmem[7]);
+
+  memif->write(mm, sizeof(magicmem), magicmem);
+}
+
+reg_t fds_t::alloc(int fd)
+{
+  reg_t i;
+  for (i = 0; i < fds.size(); i++)
+    if (fds[i] == -1)
+      break;
+
+  if (i == fds.size())
+    fds.resize(i+1);
+
+  fds[i] = fd;
+  return i;
+}
+
+void fds_t::dealloc(reg_t fd)
+{
+  fds[fd] = -1;
+}
+
+int fds_t::lookup(reg_t fd)
+{
+  if (int(fd) == RISCV_AT_FDCWD)
+    return AT_FDCWD;
+  return fd >= fds.size() ? -1 : fds[fd];
+}
+
+void syscall_t::set_chroot(const char* where)
+{
+  char buf1[PATH_MAX], buf2[PATH_MAX];
+
+  if (getcwd(buf1, sizeof(buf1)) == NULL
+      || chdir(where) != 0
+      || getcwd(buf2, sizeof(buf2)) == NULL
+      || chdir(buf1) != 0)
+  {
+    fprintf(stderr, "could not chroot to %s\n", where);
+    exit(-1);
+  }
+
+  chroot = buf2;
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/term.cc

@@ -0,0 +1,53 @@
+#include "term.h"
+#include <termios.h>
+#include <unistd.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdlib.h>
+
+class canonical_termios_t
+{
+ public:
+  canonical_termios_t()
+   : restore_tios(false)
+  {
+    if (tcgetattr(0, &old_tios) == 0)
+    {
+      struct termios new_tios = old_tios;
+      new_tios.c_lflag &= ~(ICANON | ECHO);
+      if (tcsetattr(0, TCSANOW, &new_tios) == 0)
+        restore_tios = true;
+    }
+  }
+
+  ~canonical_termios_t()
+  {
+    if (restore_tios)
+      tcsetattr(0, TCSANOW, &old_tios);
+  }
+ private:
+  struct termios old_tios;
+  bool restore_tios;
+};
+
+static canonical_termios_t tios; // exit() will clean up for us
+
+int canonical_terminal_t::read()
+{
+  struct pollfd pfd;
+  pfd.fd = 0;
+  pfd.events = POLLIN;
+  int ret = poll(&pfd, 1, 0);
+  if (ret <= 0 || !(pfd.revents & POLLIN))
+    return -1;
+
+  unsigned char ch;
+  ret = ::read(0, &ch, 1);
+  return ret <= 0 ? -1 : ch;
+}
+
+void canonical_terminal_t::write(char ch)
+{
+  if (::write(1, &ch, 1) != 1)
+    abort();
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/tsi.cc

@@ -0,0 +1,115 @@
+#include "tsi.h"
+#include <cstdio>
+#include <cstdlib>
+
+#define NHARTS_MAX 16
+
+void tsi_t::host_thread(void *arg)
+{
+  tsi_t *tsi = static_cast<tsi_t*>(arg);
+  tsi->run();
+
+  while (true)
+    tsi->target->switch_to();
+}
+
+tsi_t::tsi_t(int argc, char** argv) : htif_t(argc, argv)
+{
+  target = context_t::current();
+  host.init(host_thread, this);
+}
+
+tsi_t::~tsi_t(void)
+{
+}
+
+#define MSIP_BASE 0x2000000
+
+// Interrupt core 0 to make it start executing the program in DRAM
+void tsi_t::reset()
+{
+  uint32_t one = 1;
+
+  write_chunk(MSIP_BASE, sizeof(uint32_t), &one);
+}
+
+void tsi_t::push_addr(addr_t addr)
+{
+  for (int i = 0; i < SAI_ADDR_CHUNKS; i++) {
+    in_data.push_back(addr & 0xffffffff);
+    addr = addr >> 32;
+  }
+}
+
+void tsi_t::push_len(addr_t len)
+{
+  for (int i = 0; i < SAI_LEN_CHUNKS; i++) {
+    in_data.push_back(len & 0xffffffff);
+    len = len >> 32;
+  }
+}
+
+void tsi_t::read_chunk(addr_t taddr, size_t nbytes, void* dst)
+{
+  uint32_t *result = static_cast<uint32_t*>(dst);
+  size_t len = nbytes / sizeof(uint32_t);
+
+  in_data.push_back(SAI_CMD_READ);
+  push_addr(taddr);
+  push_len(len - 1);
+
+  for (size_t i = 0; i < len; i++) {
+    while (out_data.empty())
+      switch_to_target();
+    result[i] = out_data.front();
+    out_data.pop_front();
+  }
+}
+
+void tsi_t::write_chunk(addr_t taddr, size_t nbytes, const void* src)
+{
+  const uint32_t *src_data = static_cast<const uint32_t*>(src);
+  size_t len = nbytes / sizeof(uint32_t);
+
+  in_data.push_back(SAI_CMD_WRITE);
+  push_addr(taddr);
+  push_len(len - 1);
+
+  in_data.insert(in_data.end(), src_data, src_data + len);
+}
+
+void tsi_t::send_word(uint32_t word)
+{
+  out_data.push_back(word);
+}
+
+uint32_t tsi_t::recv_word(void)
+{
+  uint32_t word = in_data.front();
+  in_data.pop_front();
+  return word;
+}
+
+bool tsi_t::data_available(void)
+{
+  return !in_data.empty();
+}
+
+void tsi_t::switch_to_host(void)
+{
+  host.switch_to();
+}
+
+void tsi_t::switch_to_target(void)
+{
+  target->switch_to();
+}
+
+void tsi_t::tick(bool out_valid, uint32_t out_bits, bool in_ready)
+{
+  if (out_valid && out_ready())
+    out_data.push_back(out_bits);
+
+  if (in_valid() && in_ready)
+    in_data.pop_front();
+}

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/fesvr/tsi.h

@@ -0,0 +1,57 @@
+#ifndef __SAI_H
+#define __SAI_H
+
+#include "htif.h"
+#include "context.h"
+
+#include <string>
+#include <vector>
+#include <deque>
+#include <stdint.h>
+
+#define SAI_CMD_READ 0
+#define SAI_CMD_WRITE 1
+
+#define SAI_ADDR_CHUNKS 2
+#define SAI_LEN_CHUNKS 2
+
+class tsi_t : public htif_t
+{
+ public:
+  tsi_t(int argc, char** argv);
+  virtual ~tsi_t();
+
+  bool data_available();
+  void send_word(uint32_t word);
+  uint32_t recv_word();
+  void switch_to_host();
+
+  uint32_t in_bits() { return in_data.front(); }
+  bool in_valid() { return !in_data.empty(); }
+  bool out_ready() { return true; }
+  void tick(bool out_valid, uint32_t out_bits, bool in_ready);
+
+ protected:
+  void reset() override;
+  void read_chunk(addr_t taddr, size_t nbytes, void* dst) override;
+  void write_chunk(addr_t taddr, size_t nbytes, const void* src) override;
+  void switch_to_target();
+
+  size_t chunk_align() { return 4; }
+  size_t chunk_max_size() { return 1024; }
+
+  int get_ipi_addrs(addr_t *addrs);
+
+ private:
+  context_t host;
+  context_t* target;
+  std::deque<uint32_t> in_data;
+  std::deque<uint32_t> out_data;
+
+  void push_addr(addr_t addr);
+  void push_len(addr_t len);
+
+  static void host_thread(void *tsi);
+};
+
+#endif

snapshots/pulp-platform_snitch_pr436/sw/vendor/riscv-isa-sim/tests/testlib.py

@@ -0,0 +1,116 @@
+import os.path
+import pexpect
+import subprocess
+import tempfile
+import testlib
+import unittest
+
+# Note that gdb comes with its own testsuite. I was unable to figure out how to
+# run that testsuite against the spike simulator.
+
+def find_file(path):
+    for directory in (os.getcwd(), os.path.dirname(testlib.__file__)):
+        fullpath = os.path.join(directory, path)
+        if os.path.exists(fullpath):
+            return fullpath
+    return None
+
+def compile(*args):
+    """Compile a single .c file into a binary."""
+    dst = os.path.splitext(args[0])[0]
+    cc = os.path.expandvars("$RISCV/bin/riscv64-unknown-elf-gcc")
+    cmd = [cc, "-g", "-O", "-o", dst]
+    for arg in args:
+        found = find_file(arg)
+        if found:
+            cmd.append(found)
+        else:
+            cmd.append(arg)
+    cmd = " ".join(cmd)
+    result = os.system(cmd)
+    assert result == 0, "%r failed" % cmd
+    return dst
+
+def unused_port():
+    # http://stackoverflow.com/questions/2838244/get-open-tcp-port-in-python/2838309#2838309
+    import socket
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind(("",0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+class Spike(object):
+    def __init__(self, binary, halted=False, with_gdb=True, timeout=None):
+        """Launch spike. Return tuple of its process and the port it's running on."""
+        cmd = []
+        if timeout:
+            cmd += ["timeout", str(timeout)]
+
+        cmd += [find_file("spike")]
+        if halted:
+            cmd.append('-H')
+        if with_gdb:
+            self.port = unused_port()
+            cmd += ['--gdb-port', str(self.port)]
+        cmd.append('pk')
+        if binary:
+            cmd.append(binary)
+        logfile = open("spike.log", "w")
+        self.process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=logfile,
+                stderr=logfile)
+
+    def __del__(self):
+        try:
+            self.process.kill()
+            self.process.wait()
+        except OSError:
+            pass
+
+    def wait(self, *args, **kwargs):
+        return self.process.wait(*args, **kwargs)
+
+class Gdb(object):
+    def __init__(self):
+        path = os.path.expandvars("$RISCV/bin/riscv64-unknown-elf-gdb")
+        self.child = pexpect.spawn(path)
+        self.child.logfile = file("gdb.log", "w")
+        self.wait()
+        self.command("set width 0")
+        self.command("set height 0")
+        # Force consistency.
+        self.command("set print entry-values no")
+
+    def wait(self):
+        """Wait for prompt."""
+        self.child.expect("\(gdb\)")
+
+    def command(self, command, timeout=-1):
+        self.child.sendline(command)
+        self.child.expect("\n", timeout=timeout)
+        self.child.expect("\(gdb\)", timeout=timeout)
+        return self.child.before.strip()
+
+    def c(self, wait=True):
+        if wait:
+            return self.command("c")
+        else:
+            self.child.sendline("c")
+            self.child.expect("Continuing")
+
+    def interrupt(self):
+        self.child.send("\003");
+        self.child.expect("\(gdb\)")
+
+    def x(self, address, size='w'):
+        output = self.command("x/%s %s" % (size, address))
+        value = int(output.split(':')[1].strip(), 0)
+        return value
+
+    def p(self, obj):
+        output = self.command("p %s" % obj)
+        value = int(output.split('=')[-1].strip())
+        return value
+
+    def stepi(self):
+        return self.command("stepi")