return cache;
 }
 
-static ssize_t
-dso_cache__memcpy(struct dso_cache *cache, u64 offset,
-                 u8 *data, u64 size)
+static ssize_t dso_cache__memcpy(struct dso_cache *cache, u64 offset, u8 *data,
+                                u64 size, bool out)
 {
        u64 cache_offset = offset - cache->offset;
        u64 cache_size   = min(cache->size - cache_offset, size);
 
-       memcpy(data, cache->data + cache_offset, cache_size);
+       if (out)
+               memcpy(data, cache->data + cache_offset, cache_size);
+       else
+               memcpy(cache->data + cache_offset, data, cache_size);
        return cache_size;
 }
 
        return cache ? cache : dso_cache__populate(dso, machine, offset, ret);
 }
 
-static ssize_t dso_cache_read(struct dso *dso, struct machine *machine,
-                             u64 offset, u8 *data, ssize_t size)
+static ssize_t dso_cache_io(struct dso *dso, struct machine *machine,
+                           u64 offset, u8 *data, ssize_t size, bool out)
 {
        struct dso_cache *cache;
        ssize_t ret = 0;
        if (!cache)
                return ret;
 
-       return dso_cache__memcpy(cache, offset, data, size);
+       return dso_cache__memcpy(cache, offset, data, size, out);
 }
 
 /*
  * Reads and caches dso data DSO__DATA_CACHE_SIZE size chunks
  * in the rb_tree. Any read to already cached data is served
- * by cached data.
+ * by cached data. Writes update the cache only, not the backing file.
  */
-static ssize_t cached_read(struct dso *dso, struct machine *machine,
-                          u64 offset, u8 *data, ssize_t size)
+static ssize_t cached_io(struct dso *dso, struct machine *machine,
+                        u64 offset, u8 *data, ssize_t size, bool out)
 {
        ssize_t r = 0;
        u8 *p = data;
        do {
                ssize_t ret;
 
-               ret = dso_cache_read(dso, machine, offset, p, size);
+               ret = dso_cache_io(dso, machine, offset, p, size, out);
                if (ret < 0)
                        return ret;
 
        return dso->data.file_size;
 }
 
-static ssize_t data_read_offset(struct dso *dso, struct machine *machine,
-                               u64 offset, u8 *data, ssize_t size)
+static ssize_t data_read_write_offset(struct dso *dso, struct machine *machine,
+                                     u64 offset, u8 *data, ssize_t size,
+                                     bool out)
 {
        if (dso__data_file_size(dso, machine))
                return -1;
        if (offset + size < offset)
                return -1;
 
-       return cached_read(dso, machine, offset, data, size);
+       return cached_io(dso, machine, offset, data, size, out);
 }
 
 /**
        if (dso->data.status == DSO_DATA_STATUS_ERROR)
                return -1;
 
-       return data_read_offset(dso, machine, offset, data, size);
+       return data_read_write_offset(dso, machine, offset, data, size, true);
 }
 
 /**
        return dso__data_read_offset(dso, machine, offset, data, size);
 }
 
+/**
+ * dso__data_write_cache_offs - Write data to dso data cache at file offset
+ * @dso: dso object
+ * @machine: machine object
+ * @offset: file offset
+ * @data: buffer to write
+ * @size: size of the @data buffer
+ *
+ * Write into the dso file data cache, but do not change the file itself.
+ */
+ssize_t dso__data_write_cache_offs(struct dso *dso, struct machine *machine,
+                                  u64 offset, const u8 *data_in, ssize_t size)
+{
+       u8 *data = (u8 *)data_in; /* cast away const to use same fns for r/w */
+
+       if (dso->data.status == DSO_DATA_STATUS_ERROR)
+               return -1;
+
+       return data_read_write_offset(dso, machine, offset, data, size, false);
+}
+
+/**
+ * dso__data_write_cache_addr - Write data to dso data cache at dso address
+ * @dso: dso object
+ * @machine: machine object
+ * @add: virtual memory address
+ * @data: buffer to write
+ * @size: size of the @data buffer
+ *
+ * External interface to write into the dso file data cache, but do not change
+ * the file itself.
+ */
+ssize_t dso__data_write_cache_addr(struct dso *dso, struct map *map,
+                                  struct machine *machine, u64 addr,
+                                  const u8 *data, ssize_t size)
+{
+       u64 offset = map->map_ip(map, addr);
+       return dso__data_write_cache_offs(dso, machine, offset, data, size);
+}
+
 struct map *dso__new_map(const char *name)
 {
        struct map *map = NULL;