Standalone MIRI - Refactor Value/Allocation handling to allow deref to work.

7 files changed, 459 insertions, 318 deletions

diff --git a/tools/standalone_miri/debug.cpp b/tools/standalone_miri/debug.cpp
index 503d775a..d2cfb63e 100644
--- a/tools/standalone_miri/debug.cpp
+++ b/tools/standalone_miri/debug.cpp
@@ -35,7 +35,7 @@ DebugSink DebugSink::get(const char* fcn_name, const char* file, unsigned line,
         ::std::cout << "FATAL: ";
         break;
     case DebugLevel::Bug:
-        ::std::cout << "BUG: " << fcn_name << ": ";
+        ::std::cout << "BUG: " << file << ":" << line << ": ";
         break;
     }
     return DebugSink(::std::cout);
diff --git a/tools/standalone_miri/debug.hpp b/tools/standalone_miri/debug.hpp
index 77295aa2..6102b014 100644
--- a/tools/standalone_miri/debug.hpp
+++ b/tools/standalone_miri/debug.hpp
@@ -35,4 +35,4 @@ public:
 #define LOG_FATAL(strm) do { DebugSink::get(__FUNCTION__,__FILE__,__LINE__,DebugLevel::Fatal) << strm; exit(1); } while(0)
 #define LOG_TODO(strm) do { DebugSink::get(__FUNCTION__,__FILE__,__LINE__,DebugLevel::Bug) << "TODO: " << strm; abort(); } while(0)
 #define LOG_BUG(strm) do { DebugSink::get(__FUNCTION__,__FILE__,__LINE__,DebugLevel::Bug) << "BUG: " << strm; abort(); } while(0)
-#define LOG_ASSERT(cnd) do { if( !(cnd) ) { LOG_BUG("Assertion failure: " #cnd); } } while(0)
+#define LOG_ASSERT(cnd,strm) do { if( !(cnd) ) { LOG_BUG("Assertion failure: " #cnd " - " << strm); } } while(0)
diff --git a/tools/standalone_miri/hir_sim.cpp b/tools/standalone_miri/hir_sim.cpp
index d3ccddc7..4ff3f191 100644
--- a/tools/standalone_miri/hir_sim.cpp
+++ b/tools/standalone_miri/hir_sim.cpp
@@ -6,8 +6,6 @@
 #include "hir_sim.hpp"
 #include "module_tree.hpp"
 
-const size_t POINTER_SIZE = 8;
-
 //::HIR::Path::Path(::HIR::SimplePath sp)
 //{
 //}
diff --git a/tools/standalone_miri/hir_sim.hpp b/tools/standalone_miri/hir_sim.hpp
index d0f04578..a81a3f9d 100644
--- a/tools/standalone_miri/hir_sim.hpp
+++ b/tools/standalone_miri/hir_sim.hpp
@@ -6,6 +6,8 @@
 #include <vector>
 #include <memory>
 
+const size_t POINTER_SIZE = 8;
+
 #define __NE(fld)  if(this->fld != x.fld) return true
 #define __LT(fld)  if(this->fld != x.fld) return this->fld < x.fld
 
diff --git a/tools/standalone_miri/main.cpp b/tools/standalone_miri/main.cpp
index d1163c14..eb571c64 100644
--- a/tools/standalone_miri/main.cpp
+++ b/tools/standalone_miri/main.cpp
@@ -86,40 +86,37 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
             }
         }
 
-        Value& get_value_type_and_ofs(const ::MIR::LValue& lv, size_t& ofs, ::HIR::TypeRef& ty)
+        ValueRef get_value_and_type(const ::MIR::LValue& lv, ::HIR::TypeRef& ty)
         {
             switch(lv.tag())
             {
             case ::MIR::LValue::TAGDEAD:    throw "";
             TU_ARM(lv, Return, _e) {
-                ofs = 0;
                 ty = fcn.ret_ty;
-                return ret;
+                return ValueRef(ret, 0, ret.size());
                 } break;
             TU_ARM(lv, Local, e) {
-                ofs = 0;
                 ty = fcn.m_mir.locals.at(e);
-                return locals.at(e);
+                return ValueRef(locals.at(e), 0, locals.at(e).size());
                 } break;
             TU_ARM(lv, Argument, e) {
-                ofs = 0;
                 ty = fcn.args.at(e.idx);
-                return args.at(e.idx);
+                return ValueRef(args.at(e.idx), 0, args.at(e.idx).size());
                 } break;
             TU_ARM(lv, Static, e) {
                 // TODO: Type!
-                return modtree.get_static(e);
+                return ValueRef(modtree.get_static(e), 0, modtree.get_static(e).size());
                 } break;
             TU_ARM(lv, Index, e) {
-                auto idx = read_lvalue(*e.idx).as_usize();
+                auto idx = get_value_ref(*e.idx).read_usize(0);
                 ::HIR::TypeRef  array_ty;
-                auto& base_val = get_value_type_and_ofs(*e.val, ofs, array_ty);
+                auto base_val = get_value_and_type(*e.val, array_ty);
                 if( array_ty.wrappers.empty() )
                     throw "ERROR";
                 if( array_ty.wrappers.front().type == TypeWrapper::Ty::Array )
                 {
                     ty = array_ty.get_inner();
-                    ofs += ty.get_size() * idx;
+                    base_val.m_offset += ty.get_size() * idx;
                     return base_val;
                 }
                 else if( array_ty.wrappers.front().type == TypeWrapper::Ty::Slice )
@@ -133,55 +130,58 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                 } break;
             TU_ARM(lv, Field, e) {
                 ::HIR::TypeRef  composite_ty;
-                auto& base_val = get_value_type_and_ofs(*e.val, ofs, composite_ty);
+                auto base_val = get_value_and_type(*e.val, composite_ty);
                 LOG_DEBUG("Field - " << composite_ty);
                 size_t inner_ofs;
                 ty = composite_ty.get_field(e.field_index, inner_ofs);
-                ofs += inner_ofs;
+                base_val.m_offset += inner_ofs;
                 return base_val;
                 }
             TU_ARM(lv, Downcast, e) {
                 ::HIR::TypeRef  composite_ty;
-                auto& base_val = get_value_type_and_ofs(*e.val, ofs, composite_ty);
+                auto base_val = get_value_and_type(*e.val, composite_ty);
 
                 size_t inner_ofs;
                 ty = composite_ty.get_field(e.variant_index, inner_ofs);
                 LOG_TODO("Read from Downcast - " << lv);
-                ofs += inner_ofs;
+                base_val.m_offset += inner_ofs;
                 return base_val;
                 }
             TU_ARM(lv, Deref, e) {
                 ::HIR::TypeRef  ptr_ty;
-                auto addr = read_lvalue_with_ty(*e.val, ptr_ty);
+                auto val = get_value_and_type(*e.val, ptr_ty);
+                LOG_ASSERT(val.m_size == POINTER_SIZE, "Deref of a value that isn't a pointer-sized value");
                 // There MUST be a relocation at this point with a valid allocation.
-                auto& reloc = addr.allocation.alloc().relocations.at(0);
-                assert(reloc.slot_ofs == 0);
-                ofs = addr.read_usize(0);
-                // Need to make a new Value to return as the base value.
-                // - This value needs to be stored somewhere.
-                // - Shoudl the value directly reference into the pointer?
-                //auto rv = Value(ptr_ty.get_inner(), reloc.backing_alloc, ofs);
-                LOG_TODO("Read from deref - " << lv << " - " << addr);
-
+                auto& val_alloc = val.m_alloc ? val.m_alloc : val.m_value->allocation;
+                LOG_ASSERT(val_alloc, "Deref of a value with no allocation (hence no relocations)");
+                LOG_TRACE("Deref " << val_alloc.alloc());
+                auto alloc = val_alloc.alloc().get_relocation(val.m_offset);
+                LOG_ASSERT(alloc, "Deref of a value with no relocation");
+                size_t ofs = val.read_usize(0);
+                ty = ptr_ty.get_inner();
+                return ValueRef(::std::move(alloc), ofs, ty.get_size());
                 } break;
             }
             throw "";
         }
+        ValueRef get_value_ref(const ::MIR::LValue& lv)
+        {
+            ::HIR::TypeRef  tmp;
+            return get_value_and_type(lv, tmp);
+        }
 
         ::HIR::TypeRef get_lvalue_ty(const ::MIR::LValue& lv)
         {
             ::HIR::TypeRef  ty;
-            size_t ofs = 0;
-            get_value_type_and_ofs(lv, ofs, ty);
+            get_value_and_type(lv, ty);
             return ty;
         }
 
         Value read_lvalue_with_ty(const ::MIR::LValue& lv, ::HIR::TypeRef& ty)
         {
-            size_t ofs = 0;
-            Value&  base_value = get_value_type_and_ofs(lv, ofs, ty);
+            auto base_value = get_value_and_type(lv, ty);
 
-            return base_value.read_value(ofs, ty.get_size());
+            return base_value.read_value(0, ty.get_size());
         }
         Value read_lvalue(const ::MIR::LValue& lv)
         {
@@ -192,10 +192,14 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
         {
             //LOG_DEBUG(lv << " = " << val);
             ::HIR::TypeRef  ty;
-            size_t ofs = 0;
-            Value&  base_value = get_value_type_and_ofs(lv, ofs, ty);
+            auto base_value = get_value_and_type(lv, ty);
 
-            base_value.write_value(ofs, val);
+            if(base_value.m_alloc) {
+                base_value.m_alloc.alloc().write_value(base_value.m_offset, ::std::move(val));
+            }
+            else {
+                base_value.m_value->write_value(base_value.m_offset, ::std::move(val));
+            }
         }
 
         Value const_to_value(const ::MIR::Constant& c, ::HIR::TypeRef& ty)
@@ -291,41 +295,37 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
             {
             case ::MIR::Statement::TAGDEAD: throw "";
             TU_ARM(stmt, Assign, se) {
-                Value   val;
+                Value   new_val;
                 switch(se.src.tag())
                 {
                 case ::MIR::RValue::TAGDEAD: throw "";
                 TU_ARM(se.src, Use, re) {
-                    state.write_lvalue(se.dst, state.read_lvalue(re));
+                    new_val = state.read_lvalue(re);
                     } break;
                 TU_ARM(se.src, Constant, re) {
-                    state.write_lvalue(se.dst, state.const_to_value(re));
+                    new_val = state.const_to_value(re);
                     } break;
                 TU_ARM(se.src, Borrow, re) {
                     ::HIR::TypeRef  src_ty;
-                    size_t ofs = 0;
-                    Value&  src_base_value = state.get_value_type_and_ofs(re.val, ofs, src_ty);
-                    if( !src_base_value.allocation )
+                    ValueRef src_base_value = state.get_value_and_type(re.val, src_ty);
+                    auto alloc = src_base_value.m_alloc;
+                    if( !alloc )
                     {
-                        // TODO: Need to convert this value into an allocation version
-                        ::std::cerr << "TODO: RValue::Borrow - " << se.src << " - convert to non-inline" << ::std::endl;
-                        throw "TODO";
-                        //base_value.to_allocation();
+                        if( !src_base_value.m_value->allocation )
+                        {
+                            src_base_value.m_value->create_allocation();
+                        }
+                        alloc = AllocationPtr(src_base_value.m_value->allocation);
                     }
-                    ofs += src_base_value.meta.indirect_meta.offset;
+                    LOG_DEBUG("- alloc=" << alloc << " (" << alloc.alloc() << ")");
+                    size_t ofs = src_base_value.m_offset;
                     src_ty.wrappers.insert(src_ty.wrappers.begin(), TypeWrapper { TypeWrapper::Ty::Borrow, static_cast<size_t>(re.type) });
-                    Value new_val = Value(src_ty);
-                    // ^ Pointer value
-                    new_val.allocation.alloc().relocations.push_back(Relocation { 0, src_base_value.allocation });
-                    new_val.write_bytes(0, &ofs, src_ty.get_size());
-                    LOG_DEBUG("- " << new_val);
 
-                    ::HIR::TypeRef  dst_ty;
-                    // TODO: Check type equality
-                    size_t dst_ofs = 0;
-                    Value&  dst_base_value = state.get_value_type_and_ofs(se.dst, dst_ofs, dst_ty);
-                    dst_base_value.write_value(dst_ofs, ::std::move(new_val));
-                    LOG_DEBUG("- " << dst_base_value);
+                    new_val = Value(src_ty);
+                    // ^ Pointer value
+                    new_val.write_usize(0, ofs);
+                    // - Add the relocation after writing the value (writing clears the relocations)
+                    new_val.allocation.alloc().relocations.push_back(Relocation { 0, ::std::move(alloc) });
                     } break;
                 TU_ARM(se.src, SizedArray, re) {
                     throw "TODO";
@@ -334,17 +334,13 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                     // Determine the type of cast, is it a reinterpret or is it a value transform?
                     // - Float <-> integer is a transform, anything else should be a reinterpret.
                     ::HIR::TypeRef  src_ty;
-                    Value src_value = state.read_lvalue_with_ty(re.val, src_ty);
+                    auto src_value = state.get_value_and_type(re.val, src_ty);
 
-                    ::HIR::TypeRef  dst_ty;
-                    size_t dst_ofs = 0;
-                    Value&  dst_base_value = state.get_value_type_and_ofs(se.dst, dst_ofs, dst_ty);
-
-                    Value new_val = Value(re.type);
+                    new_val = Value(re.type);
                     if( re.type == src_ty )
                     {
                         // No-op cast
-                        new_val = ::std::move(src_value);
+                        new_val = src_value.read_value(0, re.type.get_size());
                     }
                     else if( !re.type.wrappers.empty() )
                     {
@@ -366,7 +362,7 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                             }
                             else 
                             {
-                                new_val = ::std::move(src_value);
+                                new_val = src_value.read_value(0, re.type.get_size());
                             }
                         }
                         else
@@ -382,7 +378,7 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                                 ::std::cerr << "ERROR: Trying to pointer (" << re.type <<" ) from invalid type (" << src_ty << ")\n";
                                 throw "ERROR";
                             }
-                            new_val = ::std::move(src_value);
+                            new_val = src_value.read_value(0, re.type.get_size());
                         }
                     }
                     else if( !src_ty.wrappers.empty() )
@@ -395,10 +391,11 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                         // TODO: MUST be a thin pointer
 
                         // TODO: MUST be an integer (usize only?)
-                        if( src_ty != RawType::USize ) {
+                        if( re.type != RawType::USize ) {
+                            LOG_ERROR("Casting from a pointer to non-usize - " << re.type << " to " << src_ty);
                             throw "ERROR";
                         }
-                        new_val = ::std::move(src_value);
+                        new_val = src_value.read_value(0, re.type.get_size());
                     }
                     else
                     {
@@ -490,8 +487,6 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                             throw "TODO";
                         }
                     }
-                        
-                    dst_base_value.write_value(dst_ofs, ::std::move(new_val));
                     } break;
                 TU_ARM(se.src, BinOp, re) {
                     throw "TODO";
@@ -510,42 +505,40 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                     } break;
                 TU_ARM(se.src, Tuple, re) {
                     ::HIR::TypeRef  dst_ty;
-                    size_t ofs = 0;
-                    Value&  base_value = state.get_value_type_and_ofs(se.dst, ofs, dst_ty);
+                    state.get_value_and_type(se.dst, dst_ty);
+                    new_val = Value(dst_ty);
 
                     for(size_t i = 0; i < re.vals.size(); i++)
                     {
                         auto fld_ofs = dst_ty.composite_type->fields.at(i).first;
-                        base_value.write_value(ofs + fld_ofs, state.param_to_value(re.vals[i]));
+                        new_val.write_value(fld_ofs, state.param_to_value(re.vals[i]));
                     }
                     } break;
                 TU_ARM(se.src, Array, re) {
                     throw "TODO";
                     } break;
                 TU_ARM(se.src, Variant, re) {
-                    ::HIR::TypeRef  dst_ty;
-                    size_t dst_ofs = 0;
-                    Value&  dst_base_value = state.get_value_type_and_ofs(se.dst, dst_ofs, dst_ty);
-
                     // 1. Get the composite by path.
-                    const auto& ty = state.modtree.get_composite(re.path);
+                    const auto& data_ty = state.modtree.get_composite(re.path);
+                    auto dst_ty = ::HIR::TypeRef(&data_ty);
+                    new_val = Value(dst_ty);
                     // Three cases:
                     // - Unions (no tag)
                     // - Data enums (tag and data)
                     // - Value enums (no data)
-                    const auto& var = ty.variants.at(re.index);
+                    const auto& var = data_ty.variants.at(re.index);
                     if( var.data_field != SIZE_MAX )
                     {
-                        const auto& fld = ty.fields.at(re.index);
+                        const auto& fld = data_ty.fields.at(re.index);
 
-                        dst_base_value.write_value(dst_ofs + fld.first, state.param_to_value(re.val));
+                        new_val.write_value(fld.first, state.param_to_value(re.val));
                     }
                     if( var.base_field != SIZE_MAX )
                     {
                         ::HIR::TypeRef  tag_ty;
                         size_t tag_ofs = dst_ty.get_field_ofs(var.base_field, var.field_path, tag_ty);
-                        LOG_ASSERT(tag_ty.get_size() == var.tag_data.size());
-                        dst_base_value.write_bytes(dst_ofs + tag_ofs, var.tag_data.data(), var.tag_data.size());
+                        LOG_ASSERT(tag_ty.get_size() == var.tag_data.size(), "");
+                        new_val.write_bytes(tag_ofs, var.tag_data.data(), var.tag_data.size());
                     }
                     else
                     {
@@ -556,6 +549,8 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                     throw "TODO";
                     } break;
                 }
+                LOG_DEBUG("- " << new_val);
+                state.write_lvalue(se.dst, ::std::move(new_val));
                 } break;
             case ::MIR::Statement::TAG_Asm:
                 throw "TODO";
@@ -577,25 +572,25 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
         {
         case ::MIR::Terminator::TAGDEAD:    throw "";
         TU_ARM(bb.terminator, Incomplete, _te)
-            throw ::std::runtime_error("BUG: Terminator::Incomplete hit");
+            LOG_TODO("Terminator::Incomplete hit");
         TU_ARM(bb.terminator, Diverge, _te)
-            throw ::std::runtime_error("BUG: Terminator::Diverge hit");
+            LOG_TODO("Terminator::Diverge hit");
         TU_ARM(bb.terminator, Panic, _te)
-            throw ::std::runtime_error("TODO: Terminator::Panic");
+            LOG_TODO("Terminator::Panic");
         TU_ARM(bb.terminator, Goto, te)
             bb_idx = te;
             continue;
         TU_ARM(bb.terminator, Return, _te)
             return state.ret;
         TU_ARM(bb.terminator, If, _te)
-            throw ::std::runtime_error("TODO: Terminator::If");
+            LOG_TODO("Terminator::If");
         TU_ARM(bb.terminator, Switch, _te)
-            throw ::std::runtime_error("TODO: Terminator::Switch");
+            LOG_TODO("Terminator::Switch");
         TU_ARM(bb.terminator, SwitchValue, _te)
-            throw ::std::runtime_error("TODO: Terminator::SwitchValue");
+            LOG_TODO("Terminator::SwitchValue");
         TU_ARM(bb.terminator, Call, te) {
             if( te.fcn.is_Intrinsic() ) {
-                throw ::std::runtime_error("TODO: Terminator::Call - intrinsic");
+                LOG_TODO("Terminator::Call - intrinsic");
             }
             else {
                 const ::HIR::Path* fcn_p;
@@ -604,11 +599,15 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                 }
                 else {
                     ::HIR::TypeRef ty;
-                    auto v = state.read_lvalue_with_ty(te.fcn.as_Value(), ty);
+                    auto v = state.get_value_and_type(te.fcn.as_Value(), ty);
                     // TODO: Assert type
                     // TODO: Assert offset/content.
-                    assert(v.read_usize(0) == 0);
-                    fcn_p = &v.allocation.alloc().relocations.at(0).backing_alloc.fcn();
+                    assert(v.read_usize(v.m_offset) == 0);
+                    auto& alloc_ptr = v.m_alloc ? v.m_alloc : v.m_value->allocation;
+                    LOG_ASSERT(alloc_ptr, "");
+                    auto& fcn_alloc_ptr = alloc_ptr.alloc().get_relocation(v.m_offset);
+                    LOG_ASSERT(fcn_alloc_ptr, "");
+                    fcn_p = &fcn_alloc_ptr.fcn();
                 }
 
                 ::std::vector<Value>    sub_args; sub_args.reserve(te.args.size());
@@ -616,10 +615,9 @@ Value MIRI_Invoke(ModuleTree& modtree, ::HIR::Path path, ::std::vector<Value> ar
                 {
                     sub_args.push_back( state.param_to_value(a) );
                 }
-                ::std::cout << "TODO: Call " << *fcn_p << ::std::endl;
+                ::std::cout << "Call " << *fcn_p << ::std::endl;
                 MIRI_Invoke(modtree, *fcn_p, ::std::move(sub_args));
             }
-            throw ::std::runtime_error("TODO: Terminator::Call");
             } break;
         }
         throw "";
diff --git a/tools/standalone_miri/value.cpp b/tools/standalone_miri/value.cpp
index e4a19196..44fd2d02 100644
--- a/tools/standalone_miri/value.cpp
+++ b/tools/standalone_miri/value.cpp
@@ -108,18 +108,194 @@ AllocationPtr::~AllocationPtr()
     return os;
 }
 
+
+void Allocation::check_bytes_valid(size_t ofs, size_t size) const
+{
+    if( !(ofs + size <= this->size()) ) {
+        LOG_FATAL("Out of range - " << ofs << "+" << size << " > " << this->size());
+    }
+    for(size_t i = ofs; i < ofs + size; i++)
+    {
+        if( !(this->mask[i/8] & (1 << i%8)) )
+        {
+            ::std::cerr << "ERROR: Invalid bytes in value" << ::std::endl;
+            throw "ERROR";
+        }
+    }
+}
+void Allocation::mark_bytes_valid(size_t ofs, size_t size)
+{
+    assert( ofs+size <= this->mask.size() * 8 );
+    for(size_t i = ofs; i < ofs + size; i++)
+    {
+        this->mask[i/8] |= (1 << i%8);
+    }
+}
+Value Allocation::read_value(size_t ofs, size_t size) const
+{
+    Value rv;
+    // TODO: Determine if this can become an inline allocation.
+    bool has_reloc = false;
+    for(const auto& r : this->relocations)
+    {
+        if( ofs <= r.slot_ofs && r.slot_ofs < ofs + size )
+        {
+            has_reloc = true;
+        }
+    }
+    if( has_reloc || size > sizeof(rv.direct_data.data) )
+    {
+        rv.allocation = Allocation::new_alloc(size);
+
+        rv.write_bytes(0, this->data_ptr() + ofs, size);
+
+        for(const auto& r : this->relocations)
+        {
+            if( ofs <= r.slot_ofs && r.slot_ofs < ofs + size )
+            {
+                rv.allocation.alloc().relocations.push_back({ r.slot_ofs - ofs, r.backing_alloc });
+            }
+        }
+    }
+    else
+    {
+        rv.direct_data.size = static_cast<uint8_t>(size);
+        rv.write_bytes(0, this->data_ptr() + ofs, size);
+    }
+    return rv;
+}
+void Allocation::read_bytes(size_t ofs, void* dst, size_t count) const
+{
+    if(ofs >= this->size() ) {
+        ::std::cerr << "Value::write_bytes - Out of bounds read, " << ofs << " >= " << this->size() << ::std::endl;
+        throw "ERROR";
+    }
+    if(count > this->size() ) {
+        ::std::cerr << "Value::write_bytes - Out of bounds read, count " << count << " > size " << this->size() << ::std::endl;
+        throw "ERROR";
+    }
+    if(ofs+count > this->size() ) {
+        ::std::cerr << "Value::write_bytes - Out of bounds read, " << ofs << "+" << count << " > size " << this->size() << ::std::endl;
+        throw "ERROR";
+    }
+    check_bytes_valid(ofs, count);
+
+
+    ::std::memcpy(dst, this->data_ptr() + ofs, count);
+}
+void Allocation::write_value(size_t ofs, Value v)
+{
+    if( v.allocation )
+    {
+        size_t  v_size = v.allocation.alloc().size();
+        const auto& src_alloc = v.allocation.alloc();
+        // TODO: Just copy the validity from the source.
+        v.check_bytes_valid(0, v_size);
+
+        // Save relocations first, because `Foo = Foo` is valid.
+        ::std::vector<Relocation>   new_relocs = src_alloc.relocations;
+        // - write_bytes removes any relocations in this region.
+        write_bytes(ofs, src_alloc.data_ptr(), v_size);
+
+        // Find any relocations that apply and copy those in.
+        // - Any relocations in the source within `v.meta.indirect_meta.offset` .. `v.meta.indirect_meta.offset + v_size`
+        if( !new_relocs.empty() )
+        {
+            // 2. Move the new relocations into this allocation
+            for(auto& r : new_relocs)
+            {
+                LOG_TRACE("Insert " << r.backing_alloc);
+                r.slot_ofs += ofs;
+                this->relocations.push_back( ::std::move(r) );
+            }
+        }
+    }
+    else
+    {
+        // TODO: Check validity of input, OR just copy the validity
+        v.check_bytes_valid(0, v.direct_data.size);
+        this->write_bytes(ofs, v.direct_data.data, v.direct_data.size);
+    }
+}
+void Allocation::write_bytes(size_t ofs, const void* src, size_t count)
+{
+    if(ofs >= this->size() ) {
+        ::std::cerr << "Value::write_bytes - Out of bounds write, " << ofs << " >= " << this->size() << ::std::endl;
+        throw "ERROR";
+    }
+    if(count > this->size() ) {
+        ::std::cerr << "Value::write_bytes - Out of bounds write, count " << count << " > size " << this->size() << ::std::endl;
+        throw "ERROR";
+    }
+    if(ofs+count > this->size() ) {
+        ::std::cerr << "Value::write_bytes - Out of bounds write, " << ofs << "+" << count << " > size " << this->size() << ::std::endl;
+        throw "ERROR";
+    }
+
+
+    // - Remove any relocations already within this region
+    auto& this_relocs = this->relocations;
+    for(auto it = this_relocs.begin(); it != this_relocs.end(); )
+    {
+        if( ofs <= it->slot_ofs && it->slot_ofs < ofs + count)
+        {
+            LOG_TRACE("Delete " << it->backing_alloc);
+            it = this_relocs.erase(it);
+        }
+        else 
+        {
+            ++it;
+        }
+    }
+
+    ::std::memcpy(this->data_ptr() + ofs, src, count);
+    mark_bytes_valid(ofs, count);
+}
+void Allocation::write_usize(size_t ofs, uint64_t v)
+{
+    this->write_bytes(0, &v, POINTER_SIZE);
+}
+::std::ostream& operator<<(::std::ostream& os, const Allocation& x)
+{
+    for(size_t i = 0; i < x.size(); i++)
+    {
+        if( i != 0 )
+            os << " ";
+
+        if( x.mask[i/8] & (1 << i%8) )
+        {
+            os << ::std::setw(2) << ::std::setfill('0') << (int)x.data_ptr()[i];
+        }
+        else
+        {
+            os << "--";
+        }
+    }
+
+    os << " {";
+    for(const auto& r : x.relocations)
+    {
+        if( 0 <= r.slot_ofs && r.slot_ofs < x.size() )
+        {
+            os << " @" << r.slot_ofs << "=" << r.backing_alloc;
+        }
+    }
+    os << " }";
+    return os;
+}
+
 Value::Value()
 {
-    this->meta.direct_data.size = 0;
-    this->meta.direct_data.mask[0] = 0;
-    this->meta.direct_data.mask[1] = 0;
+    this->direct_data.size = 0;
+    this->direct_data.mask[0] = 0;
+    this->direct_data.mask[1] = 0;
 }
 Value::Value(::HIR::TypeRef ty)
 {
     size_t size = ty.get_size();
 #if 1
     // Support inline data if the data will fit within the inline region (which is the size of the metadata)
-    if( ty.get_size() <= sizeof(this->meta.direct_data.data) )
+    if( ty.get_size() <= sizeof(this->direct_data.data) )
     {
         struct H
         {
@@ -152,9 +328,9 @@ Value::Value(::HIR::TypeRef ty)
         {
             // Will fit in a inline allocation, nice.
             //LOG_TRACE("No pointers in " << ty << ", storing inline");
-            this->meta.direct_data.size = static_cast<uint8_t>(size);
-            this->meta.direct_data.mask[0] = 0;
-            this->meta.direct_data.mask[1] = 0;
+            this->direct_data.size = static_cast<uint8_t>(size);
+            this->direct_data.mask[0] = 0;
+            this->direct_data.mask[1] = 0;
             return ;
         }
     }
@@ -163,8 +339,6 @@ Value::Value(::HIR::TypeRef ty)
     // Fallback: Make a new allocation
     //LOG_TRACE(" Creating allocation for " << ty);
     this->allocation = Allocation::new_alloc(size);
-    this->meta.indirect_meta.offset = 0;
-    this->meta.indirect_meta.size = size;
 }
 Value Value::new_fnptr(const ::HIR::Path& fn_path)
 {
@@ -176,44 +350,40 @@ Value Value::new_fnptr(const ::HIR::Path& fn_path)
     return rv;
 }
 
+void Value::create_allocation()
+{
+    assert(!this->allocation);
+    this->allocation = Allocation::new_alloc(this->direct_data.size);
+    this->allocation.alloc().mask[0] = this->direct_data.mask[0];
+    this->allocation.alloc().mask[1] = this->direct_data.mask[1];
+    ::std::memcpy(this->allocation.alloc().data.data(), this->direct_data.data, this->direct_data.size);
+}
 void Value::check_bytes_valid(size_t ofs, size_t size) const
 {
+    if( size == 0 )
+        return ;
     if( this->allocation )
     {
-        const auto& alloc = this->allocation.alloc();
-        if( ofs >= this->meta.indirect_meta.size || ofs+size > this->meta.indirect_meta.size ) {
-            ::std::cerr << "ERROR: OOB read" << ::std::endl;
-            throw "ERROR";
-        }
-        ofs += this->meta.indirect_meta.offset;
-        //assert(ofs + size < alloc.size());
-        for(size_t i = ofs; i < ofs + size; i++)
-        {
-            if( !(alloc.mask[i/8] & (1 << i%8)) )
-            {
-                ::std::cerr << "ERROR: Invalid bytes in value" << ::std::endl;
-                throw "ERROR";
-            }
-        }
+        this->allocation.alloc().check_bytes_valid(ofs, size);
     }
     else
     {
-        if( size == 0 && this->meta.direct_data.size > 0 ) {
+        if( size == 0 && this->direct_data.size > 0 ) {
             return ;
         }
-        if( ofs >= this->meta.direct_data.size ) {
-            ::std::cerr << "ERROR: OOB read" << ::std::endl;
+        if( ofs >= this->direct_data.size ) {
+            LOG_ERROR("Read out of bounds " << ofs << "+" << size << " > " << int(this->direct_data.size));
             throw "ERROR";
         }
-        if( ofs+size > this->meta.direct_data.size ) {
-            ::std::cerr << "ERROR: OOB read" << ::std::endl;
+        if( ofs+size > this->direct_data.size ) {
+            LOG_ERROR("Read out of bounds " << ofs+size << " >= " << int(this->direct_data.size));
             throw "ERROR";
         }
         for(size_t i = ofs; i < ofs + size; i++)
         {
-            if( !(this->meta.direct_data.mask[i/8] & (1 << i%8)) )
+            if( !(this->direct_data.mask[i/8] & (1 << i%8)) )
             {
-                ::std::cerr << "ERROR: Invalid bytes in value" << ::std::endl;
+                LOG_ERROR("Accessing invalid bytes in value");
                 throw "ERROR";
             }
         }
@@ -223,20 +393,13 @@ void Value::mark_bytes_valid(size_t ofs, size_t size)
 {
     if( this->allocation )
     {
-        auto& alloc = this->allocation.alloc();
-        // TODO: Assert range.
-        ofs += this->meta.indirect_meta.offset;
-        assert( ofs+size <= alloc.mask.size() * 8 );
-        for(size_t i = ofs; i < ofs + size; i++)
-        {
-            alloc.mask[i/8] |= (1 << i%8);
-        }
+        this->allocation.alloc().mark_bytes_valid(ofs, size);
     }
     else
     {
-        for(size_t i = 0; i < this->meta.direct_data.size; i++)
+        for(size_t i = 0; i < this->direct_data.size; i++)
         {
-            this->meta.direct_data.mask[i/8] |= (1 << i%8);
+            this->direct_data.mask[i/8] |= (1 << i%8);
         }
     }
 }
@@ -248,211 +411,113 @@ Value Value::read_value(size_t ofs, size_t size) const
     check_bytes_valid(ofs, size);
     if( this->allocation )
     {
-        const auto& alloc = this->allocation.alloc();
-        // TODO: Determine if this can become an inline allocation.
-        bool has_reloc = false;
-        for(const auto& r : alloc.relocations)
-        {
-            if( this->meta.indirect_meta.offset+ofs <= r.slot_ofs && r.slot_ofs < this->meta.indirect_meta.offset + ofs + size )
-            {
-                has_reloc = true;
-            }
-        }
-        if( has_reloc || size > sizeof(this->meta.direct_data.data) )
-        {
-            rv.allocation = Allocation::new_alloc(size);
-            rv.meta.indirect_meta.offset = 0;
-            rv.meta.indirect_meta.size = size;
-
-            for(const auto& r : alloc.relocations)
-            {
-                if( this->meta.indirect_meta.offset+ofs <= r.slot_ofs && r.slot_ofs < this->meta.indirect_meta.offset + ofs + size )
-                {
-                    rv.allocation.alloc().relocations.push_back({ r.slot_ofs - (this->meta.indirect_meta.offset+ofs), r.backing_alloc });
-                }
-            }
-        }
-        else
-        {
-            rv.meta.direct_data.size = static_cast<uint8_t>(size);
-        }
-        rv.write_bytes(0, this->data_ptr() + ofs, size);
+        rv = this->allocation.alloc().read_value(ofs, size);
     }
     else
     {
         // Inline can become inline.
-        rv.meta.direct_data.size = static_cast<uint8_t>(size);
-        rv.write_bytes(0, this->meta.direct_data.data+ofs, size);
+        rv.direct_data.size = static_cast<uint8_t>(size);
+        rv.write_bytes(0, this->direct_data.data+ofs, size);
     }
     LOG_DEBUG("RETURN " << rv);
     return rv;
 }
 void Value::read_bytes(size_t ofs, void* dst, size_t count) const
 {
-    check_bytes_valid(ofs, count);
-    throw "TODO";
-}
-
-void Value::write_bytes(size_t ofs, const void* src, size_t count)
-{
     if( this->allocation )
     {
-        if(ofs >= this->meta.indirect_meta.size ) {
-            ::std::cerr << "Value::write_bytes - Out of bounds write, " << ofs << " >= " << this->meta.indirect_meta.size << ::std::endl;
+        this->allocation.alloc().read_bytes(ofs, dst, count);
+    }
+    else
+    {
+        check_bytes_valid(ofs, count);
+
+        if(ofs >= this->direct_data.size )
             throw "ERROR";
-        }
-        if(count > this->meta.indirect_meta.size ) {
-            ::std::cerr << "Value::write_bytes - Out of bounds write, count " << count << " > size " << this->meta.indirect_meta.size << ::std::endl;
+        if(count > this->direct_data.size )
             throw "ERROR";
-        }
-        if(ofs+count > this->meta.indirect_meta.size ) {
-            ::std::cerr << "Value::write_bytes - Out of bounds write, " << ofs << "+" << count << " > size " << this->meta.indirect_meta.size << ::std::endl;
+        if(ofs+count > this->direct_data.size )
             throw "ERROR";
-        }
-
-
-        // - Remove any relocations already within this region
-        auto& this_relocs = this->allocation.alloc().relocations;
-        for(auto it = this_relocs.begin(); it != this_relocs.end(); )
-        {
-            if( this->meta.indirect_meta.offset + ofs <= it->slot_ofs && it->slot_ofs < this->meta.indirect_meta.offset + ofs + count)
-            {
-                LOG_TRACE("Delete " << it->backing_alloc);
-                it = this_relocs.erase(it);
-            }
-            else 
-            {
-                ++it;
-            }
-        }
+        ::std::memcpy(dst, this->direct_data.data + ofs, count);
+    }
+}
 
+void Value::write_bytes(size_t ofs, const void* src, size_t count)
+{
+    if( count == 0 )
+        return ;
+    if( this->allocation )
+    {
+        this->allocation.alloc().write_bytes(ofs, src, count);
     }
     else
     {
-        if(ofs >= this->meta.direct_data.size )
+        if(ofs >= this->direct_data.size )
             throw "ERROR";
-        if(count > this->meta.direct_data.size )
+        if(count > this->direct_data.size )
             throw "ERROR";
-        if(ofs+count > this->meta.direct_data.size )
+        if(ofs+count > this->direct_data.size )
             throw "ERROR";
+        ::std::memcpy(this->direct_data.data + ofs, src, count);
+        mark_bytes_valid(ofs, count);
     }
-    ::std::memcpy(this->data_ptr() + ofs, src, count);
-    mark_bytes_valid(ofs, count);
 }
 void Value::write_value(size_t ofs, Value v)
 {
-    if( v.allocation )
+    if( this->allocation )
     {
-        size_t  v_size = v.meta.indirect_meta.size;
-        v.check_bytes_valid(0, v_size);
-        const auto& src_alloc = v.allocation.alloc();
-        write_bytes(ofs, v.data_ptr(), v_size);
-        // Find any relocations that apply and copy those in.
-        // - Any relocations in the source within `v.meta.indirect_meta.offset` .. `v.meta.indirect_meta.offset + v_size`
-        ::std::vector<Relocation>   new_relocs;
-        for(const auto& r : src_alloc.relocations)
+        this->allocation.alloc().write_value(ofs, ::std::move(v));
+    }
+    else
+    {
+        if( v.allocation && !v.allocation.alloc().relocations.empty() )
         {
-            // TODO: Negative offsets in destination?
-            if( v.meta.indirect_meta.offset <= r.slot_ofs && r.slot_ofs < v.meta.indirect_meta.offset + v_size )
-            {
-                LOG_TRACE("Copy " << r.backing_alloc);
-                // Applicable, save for later
-                new_relocs.push_back( r );
-            }
+            this->create_allocation();
+            this->allocation.alloc().write_value(ofs, ::std::move(v));
         }
-        if( !new_relocs.empty() )
+        else
         {
-            if( !this->allocation ) {
-                throw ::std::runtime_error("TODO: Writing value with a relocation into a slot without a relocation");
-            }
-            // 1. Remove any relocations already within this region
-            auto& this_relocs = this->allocation.alloc().relocations;
-            for(auto it = this_relocs.begin(); it != this_relocs.end(); )
-            {
-                if( this->meta.indirect_meta.offset + ofs <= it->slot_ofs && it->slot_ofs < this->meta.indirect_meta.offset + ofs + v_size)
-                {
-                    LOG_TRACE("Delete " << it->backing_alloc);
-                    it = this_relocs.erase(it);
-                }
-                else 
-                {
-                    ++it;
-                }
-            }
-            // 2. Move the new relocations into this allocation
-            for(auto& r : new_relocs)
-            {
-                LOG_TRACE("Insert " << r.backing_alloc);
-                r.slot_ofs -= v.meta.indirect_meta.offset;
-                r.slot_ofs += this->meta.indirect_meta.offset + ofs;
-                this_relocs.push_back( ::std::move(r) );
-            }
+            v.check_bytes_valid(0, v.direct_data.size);
+            write_bytes(ofs, v.direct_data.data, v.direct_data.size);
         }
     }
-    else
-    {
-        v.check_bytes_valid(0, v.meta.direct_data.size);
-        write_bytes(ofs, v.meta.direct_data.data, v.meta.direct_data.size);
-    }
 }
-
-uint64_t Value::read_usize(size_t ofs) const
+void Value::write_usize(size_t ofs, uint64_t v)
 {
-    uint64_t    v = 0;
-    // TODO: Handle different pointer sizes
-    this->read_bytes(0, &v, 8);
-    return v;
+    this->write_bytes(0, &v, POINTER_SIZE);
 }
 
 ::std::ostream& operator<<(::std::ostream& os, const Value& v)
 {
-    auto flags = os.flags();
-    os << ::std::hex;
     if( v.allocation )
     {
-        const auto& alloc = v.allocation.alloc();
-        for(size_t i = 0; i < v.meta.indirect_meta.size; i++)
-        {
-            if( i != 0 )
-                os << " ";
-            size_t j = i + v.meta.indirect_meta.offset;
-
-            if( alloc.mask[j/8] & (1 << i%8) )
-            {
-                os << ::std::setw(2) << ::std::setfill('0') << (int)alloc.data_ptr()[j];
-            }
-            else
-            {
-                os << "--";
-            }
-        }
-
-        os << " {";
-        for(const auto& r : alloc.relocations)
-        {
-            if( v.meta.indirect_meta.offset <= r.slot_ofs && r.slot_ofs < v.meta.indirect_meta.offset + v.meta.indirect_meta.size )
-            {
-                os << " @" << (r.slot_ofs - v.meta.indirect_meta.offset) << "=" << r.backing_alloc;
-            }
-        }
-        os << " }";
+        os << v.allocation.alloc();
     }
     else
     {
-        for(size_t i = 0; i < v.meta.direct_data.size; i++)
+        auto flags = os.flags();
+        os << ::std::hex;
+        for(size_t i = 0; i < v.direct_data.size; i++)
         {
             if( i != 0 )
                 os << " ";
-            if( v.meta.direct_data.mask[i/8] & (1 << i%8) )
+            if( v.direct_data.mask[i/8] & (1 << i%8) )
             {
-                os << ::std::setw(2) << ::std::setfill('0') << (int)v.meta.direct_data.data[i];
+                os << ::std::setw(2) << ::std::setfill('0') << (int)v.direct_data.data[i];
             }
             else
             {
                 os << "--";
             }
         }
+        os.setf(flags);
     }
-    os.setf(flags);
     return os;
+}
+
+uint64_t ValueRef::read_usize(size_t ofs) const
+{
+    uint64_t    v = 0;
+    this->read_bytes(0, &v, POINTER_SIZE);
+    return v;
 }
\ No newline at end of file
diff --git a/tools/standalone_miri/value.hpp b/tools/standalone_miri/value.hpp
index b0c649fc..1971bb6d 100644
--- a/tools/standalone_miri/value.hpp
+++ b/tools/standalone_miri/value.hpp
@@ -13,7 +13,7 @@ namespace HIR {
     struct Path;
 }
 class Allocation;
-
+struct Value;
 
 class AllocationPtr
 {
@@ -56,14 +56,17 @@ public:
         return *this && get_ty() == Ty::Allocation;
     }
     Allocation& alloc() {
+        assert(*this);
         assert(get_ty() == Ty::Allocation);
         return *static_cast<Allocation*>(get_ptr());
     }
     const Allocation& alloc() const {
+        assert(*this);
         assert(get_ty() == Ty::Allocation);
         return *static_cast<Allocation*>(get_ptr());
     }
     const ::HIR::Path& fcn() const {
+        assert(*this);
         assert(get_ty() == Ty::Function);
         return *static_cast<const ::HIR::Path*>(get_ptr());
     }
@@ -95,32 +98,62 @@ public:
 
     const uint8_t* data_ptr() const { return reinterpret_cast<const uint8_t*>(this->data.data()); }
           uint8_t* data_ptr()       { return reinterpret_cast<      uint8_t*>(this->data.data()); }
+    size_t size() const { return this->data.size() * 8; }
 
     ::std::vector<uint64_t> data;
     ::std::vector<uint8_t> mask;
     ::std::vector<Relocation>   relocations;
+
+    AllocationPtr get_relocation(size_t ofs) const {
+        for(const auto& r : relocations) {
+            if(r.slot_ofs == ofs)
+                return r.backing_alloc;
+        }
+        return AllocationPtr();
+    }
+
+    void check_bytes_valid(size_t ofs, size_t size) const;
+    void mark_bytes_valid(size_t ofs, size_t size);
+
+    Value read_value(size_t ofs, size_t size) const;
+    void read_bytes(size_t ofs, void* dst, size_t count) const;
+
+    void write_value(size_t ofs, Value v);
+    void write_bytes(size_t ofs, const void* src, size_t count);
+
+    // TODO: Make this block common
+    void write_u8 (size_t ofs, uint8_t  v) { write_bytes(ofs, &v, 1); }
+    void write_u16(size_t ofs, uint16_t v) { write_bytes(ofs, &v, 2); }
+    void write_u32(size_t ofs, uint32_t v) { write_bytes(ofs, &v, 4); }
+    void write_u64(size_t ofs, uint64_t v) { write_bytes(ofs, &v, 8); }
+    void write_i8 (size_t ofs, int8_t  v) { write_u8 (ofs, static_cast<uint8_t >(v)); }
+    void write_i16(size_t ofs, int16_t v) { write_u16(ofs, static_cast<uint16_t>(v)); }
+    void write_i32(size_t ofs, int32_t v) { write_u32(ofs, static_cast<uint32_t>(v)); }
+    void write_i64(size_t ofs, int64_t v) { write_u64(ofs, static_cast<uint64_t>(v)); }
+    void write_f32(size_t ofs, float  v) { write_bytes(ofs, &v, 4); }
+    void write_f64(size_t ofs, double v) { write_bytes(ofs, &v, 8); }
+    void write_usize(size_t ofs, uint64_t v);
+    void write_isize(size_t ofs, int64_t v) { write_usize(ofs, static_cast<uint64_t>(v)); }
 };
+extern ::std::ostream& operator<<(::std::ostream& os, const Allocation& x);
 
 struct Value
 {
     // If NULL, data is direct
     AllocationPtr   allocation;
-    union {
-        struct {
-            size_t  size;
-            size_t  offset;
-        } indirect_meta;
-        struct {
-            uint8_t data[2*sizeof(size_t)-3];   // 16-3 = 13, fits in 16 bits of mask
-            uint8_t mask[2];
-            uint8_t size;
-        } direct_data;
-    } meta;
+    struct {
+        uint8_t data[2*sizeof(size_t)-3];   // 16-3 = 13, fits in 16 bits of mask
+        uint8_t mask[2];
+        uint8_t size;
+    } direct_data;
 
     Value();
     Value(::HIR::TypeRef ty);
     static Value new_fnptr(const ::HIR::Path& fn_path);
 
+    void create_allocation();
+    size_t size() const { return allocation ? allocation.alloc().size() : direct_data.size; }
+
     void check_bytes_valid(size_t ofs, size_t size) const;
     void mark_bytes_valid(size_t ofs, size_t size);
 
@@ -130,19 +163,7 @@ struct Value
     void write_value(size_t ofs, Value v);
     void write_bytes(size_t ofs, const void* src, size_t count);
 
-    uint8_t read_u8(size_t ofs) const { uint8_t rv; read_bytes(ofs, &rv, 1); return rv; }
-     int8_t read_i8(size_t ofs) const { return static_cast<int8_t>(read_u8(ofs)); }
-    uint16_t read_u16(size_t ofs) const { uint16_t rv; read_bytes(ofs, &rv, 2); return rv; }
-     int16_t read_i16(size_t ofs) const { return static_cast<int16_t>(read_u16(ofs)); }
-    uint32_t read_u32(size_t ofs) const { uint32_t rv; read_bytes(ofs, &rv, 4); return rv; }
-     int32_t read_i32(size_t ofs) const { return static_cast<int32_t>(read_u32(ofs)); }
-    uint64_t read_u64(size_t ofs) const { uint64_t rv; read_bytes(ofs, &rv, 8); return rv; }
-     int64_t read_i64(size_t ofs) const { return static_cast<int64_t>(read_u64(ofs)); }
-    float  read_f32(size_t ofs) const { float rv; read_bytes(ofs, &rv, 4); return rv; }
-    double read_f64(size_t ofs) const { double rv; read_bytes(ofs, &rv, 8); return rv; }
-    uint64_t read_usize(size_t ofs) const;
-     int64_t read_isize(size_t ofs) const { return static_cast<int64_t>(read_usize(ofs)); }
-
+    // TODO: Make this block common
     void write_u8 (size_t ofs, uint8_t  v) { write_bytes(ofs, &v, 1); }
     void write_u16(size_t ofs, uint16_t v) { write_bytes(ofs, &v, 2); }
     void write_u32(size_t ofs, uint32_t v) { write_bytes(ofs, &v, 4); }
@@ -153,8 +174,65 @@ struct Value
     void write_i64(size_t ofs, int64_t v) { write_u64(ofs, static_cast<uint64_t>(v)); }
     void write_f32(size_t ofs, float  v) { write_bytes(ofs, &v, 4); }
     void write_f64(size_t ofs, double v) { write_bytes(ofs, &v, 8); }
-private:
-    const uint8_t* data_ptr() const { return allocation ? allocation.alloc().data_ptr() + meta.indirect_meta.offset : meta.direct_data.data; }
-          uint8_t* data_ptr()       { return allocation ? allocation.alloc().data_ptr() + meta.indirect_meta.offset : meta.direct_data.data; }
+    void write_usize(size_t ofs, uint64_t v);
+    void write_isize(size_t ofs, int64_t v) { write_usize(ofs, static_cast<uint64_t>(v)); }
 };
 extern ::std::ostream& operator<<(::std::ostream& os, const Value& v);
+
+// A read-only reference to a value (to write, you have to go through it)
+struct ValueRef
+{
+    // Either an AllocationPtr, or a Value pointer
+    AllocationPtr   m_alloc;
+    Value*  m_value;
+    size_t  m_offset;
+    size_t  m_size;
+
+    ValueRef(AllocationPtr ptr, size_t ofs, size_t size):
+        m_alloc(ptr),
+        m_offset(ofs),
+        m_size(size)
+    {
+    }
+    ValueRef(Value& val, size_t ofs, size_t size):
+        m_value(&val),
+        m_offset(ofs),
+        m_size(size)
+    {
+    }
+
+    Value read_value(size_t ofs, size_t size) const {
+        assert(ofs < m_size);
+        assert(size <= m_size);
+        assert(ofs+size <= m_size);
+        if( m_alloc ) {
+            return m_alloc.alloc().read_value(m_offset + ofs, size);
+        }
+        else {
+            return m_value->read_value(m_offset + ofs, size);
+        }
+    }
+    void read_bytes(size_t ofs, void* dst, size_t size) const {
+        assert(ofs < m_size);
+        assert(size <= m_size);
+        assert(ofs+size <= m_size);
+        if( m_alloc ) {
+            m_alloc.alloc().read_bytes(m_offset + ofs, dst, size);
+        }
+        else {
+            m_value->read_bytes(m_offset + ofs, dst, size);
+        }
+    }
+    uint8_t read_u8(size_t ofs) const { uint8_t rv; read_bytes(ofs, &rv, 1); return rv; }
+    uint16_t read_u16(size_t ofs) const { uint16_t rv; read_bytes(ofs, &rv, 2); return rv; }
+    uint32_t read_u32(size_t ofs) const { uint32_t rv; read_bytes(ofs, &rv, 4); return rv; }
+    uint64_t read_u64(size_t ofs) const { uint64_t rv; read_bytes(ofs, &rv, 8); return rv; }
+    int8_t read_i8(size_t ofs) const { return static_cast<int8_t>(read_u8(ofs)); }
+    int16_t read_i16(size_t ofs) const { return static_cast<int16_t>(read_u16(ofs)); }
+    int32_t read_i32(size_t ofs) const { return static_cast<int32_t>(read_u32(ofs)); }
+    int64_t read_i64(size_t ofs) const { return static_cast<int64_t>(read_u64(ofs)); }
+    float  read_f32(size_t ofs) const { float rv; read_bytes(ofs, &rv, 4); return rv; }
+    double read_f64(size_t ofs) const { double rv; read_bytes(ofs, &rv, 8); return rv; }
+    uint64_t read_usize(size_t ofs) const;
+    int64_t read_isize(size_t ofs) const { return static_cast<int64_t>(read_usize(ofs)); }
+};