zeroc-ice 3.8.2 → 3.8.3

data/dist/IceRuby/Types.cpp

@@ -12,18 +12,6 @@
 #include <list>
 #include <math.h>
 
-//
-// Required for RHASH_SIZE to work properly with Ruby 1.8.x.
-// T_ZOMBIE is only defined in Ruby 1.9.
-//
-#ifndef T_ZOMBIE
-#    include "st.h"
-#endif
-
-#ifndef RHASH_SIZE
-#    define RHASH_SIZE(v) RHASH(v)->tbl->num_entries
-#endif
-
 using namespace std;
 using namespace IceRuby;
 using namespace Ice;
@@ -40,6 +28,11 @@ static ProxyInfoMap _proxyInfoMap;
 typedef map<string, ExceptionInfoPtr, std::less<>> ExceptionInfoMap;
 static ExceptionInfoMap _exceptionInfoMap;
 
+namespace
+{
+    StreamUtil* streamUtil(Ice::InputStream* is) { return reinterpret_cast<StreamUtil*>(is->getClosure()); }
+}
+
 namespace IceRuby
 {
     class InfoMapDestroyer
@@ -151,16 +144,26 @@ addExceptionInfo(const string& id, const ExceptionInfoPtr& info)
     _exceptionInfoMap.insert(ExceptionInfoMap::value_type(id, info));
 }
 
+//
+// PrintObjectHistory implementation
+//
+IceRuby::PrintObjectHistory::PrintObjectHistory() : objects(callRuby(rb_hash_new))
+{
+    callRuby(rb_funcall, objects, rb_intern("compare_by_identity"), 0);
+}
+
 //
 // StreamUtil implementation
 //
 VALUE IceRuby::StreamUtil::_slicedDataType = Qnil;
 VALUE IceRuby::StreamUtil::_sliceInfoType = Qnil;
 
-IceRuby::StreamUtil::StreamUtil() = default;
+IceRuby::StreamUtil::StreamUtil() : _held(Qnil) { rb_gc_register_address(&_held); }
 
 IceRuby::StreamUtil::~StreamUtil()
 {
+    rb_gc_unregister_address(&_held);
+
     //
     // Make sure we break any cycles among the ValueReaders in preserved slices.
     //
@@ -194,6 +197,24 @@ IceRuby::StreamUtil::add(const shared_ptr<ValueReader>& reader)
     _readers.insert(reader);
 }
 
+long
+IceRuby::StreamUtil::hold(VALUE value)
+{
+    if (NIL_P(_held))
+    {
+        _held = callRuby(rb_ary_new);
+    }
+    callRuby(rb_ary_push, _held, value);
+    return RARRAY_LEN(_held) - 1;
+}
+
+VALUE
+IceRuby::StreamUtil::getHeldValue(long index) const
+{
+    assert(!NIL_P(_held) && index >= 0 && index < RARRAY_LEN(_held));
+    return RARRAY_AREF(_held, index);
+}
+
 void
 IceRuby::StreamUtil::updateSlicedData()
 {
@@ -216,11 +237,13 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
     {
         _slicedDataType = callRuby(rb_path2class, "Ice::SlicedData");
         assert(!NIL_P(_slicedDataType));
+        rb_gc_register_mark_object(_slicedDataType);
     }
     if (_sliceInfoType == Qnil)
     {
         _sliceInfoType = callRuby(rb_path2class, "Ice::SliceInfo");
         assert(!NIL_P(_sliceInfoType));
+        rb_gc_register_mark_object(_sliceInfoType);
     }
 
     volatile VALUE sd = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), _slicedDataType);
@@ -337,7 +360,7 @@ IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ValueMap* valueMap)
 
                 auto info = std::make_shared<Ice::SliceInfo>(
                     getString(typeId),
-                    static_cast<int32_t>(getInteger(compactId)),
+                    getInteger(compactId),
                     std::move(vtmp),
                     hasOptionalMembers == Qtrue,
                     isLastSlice == Qtrue);
@@ -392,7 +415,7 @@ IceRuby::TypeInfo::usesClasses() const
 }
 
 void
-IceRuby::TypeInfo::unmarshaled(VALUE, VALUE, void*)
+IceRuby::TypeInfo::unmarshaled(VALUE, VALUE, void*, StreamUtil*)
 {
     assert(false);
 }
@@ -405,8 +428,6 @@ IceRuby::TypeInfo::destroy()
 //
 // PrimitiveInfo implementation.
 //
-IceRuby::PrimitiveInfo::PrimitiveInfo() = default;
-
 IceRuby::PrimitiveInfo::PrimitiveInfo(Kind k) : kind(k) {}
 
 string
@@ -516,33 +537,28 @@ IceRuby::PrimitiveInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap*, bool)
         }
         case PrimitiveInfo::KindByte:
         {
-            long i = getInteger(p);
+            int32_t i = getInteger(p);
             if (i >= 0 && i <= 255)
             {
                 os->write(static_cast<uint8_t>(i));
                 break;
             }
-            throw RubyException(rb_eTypeError, "value is out of range for a byte");
+            throw RubyException(rb_eRangeError, "value is out of range for a byte");
         }
         case PrimitiveInfo::KindShort:
         {
-            long i = getInteger(p);
+            int32_t i = getInteger(p);
             if (i >= SHRT_MIN && i <= SHRT_MAX)
             {
                 os->write(static_cast<int16_t>(i));
                 break;
             }
-            throw RubyException(rb_eTypeError, "value is out of range for a short");
+            throw RubyException(rb_eRangeError, "value is out of range for a short");
         }
         case PrimitiveInfo::KindInt:
         {
-            long i = getInteger(p);
-            if (i >= INT_MIN && i <= INT_MAX)
-            {
-                os->write(static_cast<int32_t>(i));
-                break;
-            }
-            throw RubyException(rb_eTypeError, "value is out of range for an int");
+            os->write(getInteger(p));
+            break;
         }
         case PrimitiveInfo::KindLong:
         {
@@ -558,7 +574,7 @@ IceRuby::PrimitiveInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap*, bool)
             }
             assert(TYPE(val) == T_FLOAT);
             double d = static_cast<double>(RFLOAT_VALUE(val));
-            if (isfinite(d) && (d > numeric_limits<float>::max() || d < -numeric_limits<float>::max()))
+            if (isfinite(d) && (d > numeric_limits<float>::max() || d < numeric_limits<float>::lowest()))
             {
                 throw RubyException(rb_eTypeError, "value is out of range for a float");
             }
@@ -653,7 +669,7 @@ IceRuby::PrimitiveInfo::unmarshal(
             break;
         }
     }
-    cb->unmarshaled(val, target, closure);
+    cb->unmarshaled(val, target, closure, streamUtil(is));
 }
 
 void
@@ -718,7 +734,7 @@ namespace
 
         virtual void element(VALUE key, VALUE value)
         {
-            const int32_t v = static_cast<int32_t>(getInteger(key));
+            const int32_t v = getInteger(key);
             assert(enumerators.find(v) == enumerators.end());
             enumerators[v] = value;
 
@@ -742,6 +758,13 @@ IceRuby::EnumInfo::EnumInfo(VALUE ident, VALUE t, VALUE e) : rubyClass(t), maxVa
 
     const_cast<int32_t&>(maxValue) = iter.maxValue;
     const_cast<EnumeratorMap&>(enumerators) = iter.enumerators;
+
+    // Pin these objects: the GC cannot see the VALUEs stored in this object, so they must never move.
+    rb_gc_register_mark_object(rubyClass);
+    for (const auto& p : enumerators)
+    {
+        rb_gc_register_mark_object(p.second);
+    }
 }
 
 string
@@ -783,10 +806,10 @@ IceRuby::EnumInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap*, bool)
     // Validate value.
     //
     volatile VALUE val = callRuby(rb_iv_get, p, "@value");
-    const int32_t ival = static_cast<int32_t>(getInteger(val));
+    const int32_t ival = getInteger(val);
     if (enumerators.find(ival) == enumerators.end())
     {
-        throw RubyException(rb_eRangeError, "invalid enumerator %ld for enum %s", ival, id.c_str());
+        throw RubyException(rb_eRangeError, "invalid enumerator %d for enum %s", ival, id.c_str());
     }
 
     os->writeEnum(ival, maxValue);
@@ -805,7 +828,7 @@ IceRuby::EnumInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& c
         throw Ice::MarshalException(__FILE__, __LINE__, ostr.str());
     }
 
-    cb->unmarshaled(p->second, target, closure);
+    cb->unmarshaled(p->second, target, closure, streamUtil(is));
 }
 
 void
@@ -824,7 +847,7 @@ IceRuby::EnumInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHisto
 // DataMember implementation.
 //
 void
-IceRuby::DataMember::unmarshaled(VALUE val, VALUE target, void*)
+IceRuby::DataMember::unmarshaled(VALUE val, VALUE target, void*, StreamUtil*)
 {
     callRuby(rb_ivar_set, target, rubyID, val);
 }
@@ -852,7 +875,7 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
         if (allowOptional)
         {
             member->optional = RTEST(RARRAY_AREF(m, 2));
-            member->tag = static_cast<int>(getInteger(RARRAY_AREF(m, 3)));
+            member->tag = getInteger(RARRAY_AREF(m, 3));
         }
         else
         {
@@ -888,6 +911,9 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
 //
 IceRuby::StructInfo::StructInfo(VALUE ident, VALUE t, VALUE m) : rubyClass(t)
 {
+    // Pin the class: the GC cannot see the VALUE stored in this object, so it must never move.
+    rb_gc_register_mark_object(rubyClass);
+
     const_cast<string&>(id) = getString(ident);
 
     DataMemberList opt;
@@ -1017,7 +1043,7 @@ IceRuby::StructInfo::unmarshal(
         member->type->unmarshal(is, member, obj, 0, false);
     }
 
-    cb->unmarshaled(obj, target, closure);
+    cb->unmarshaled(obj, target, closure, streamUtil(is));
 }
 
 void
@@ -1225,7 +1251,7 @@ IceRuby::SequenceInfo::unmarshal(
         return;
     }
 
-    int32_t sz = is->readSize();
+    int32_t sz = is->readAndCheckSeqSize(elementType->wireSize());
     volatile VALUE arr = createArray(sz);
 
     for (int32_t i = 0; i < sz; ++i)
@@ -1234,11 +1260,11 @@ IceRuby::SequenceInfo::unmarshal(
         elementType->unmarshal(is, shared_from_this(), arr, cl, false);
     }
 
-    cb->unmarshaled(arr, target, closure);
+    cb->unmarshaled(arr, target, closure, streamUtil(is));
 }
 
 void
-IceRuby::SequenceInfo::unmarshaled(VALUE val, VALUE target, void* closure)
+IceRuby::SequenceInfo::unmarshaled(VALUE val, VALUE target, void* closure, StreamUtil*)
 {
     static_assert(sizeof(long) == sizeof(void*), "long and void* must have the same size");
     long i = reinterpret_cast<long>(closure);
@@ -1352,7 +1378,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
                 const long len = RSTRING_LEN(str);
                 if (s == 0 || len == 0)
                 {
-                    os->write(int32_t(0));
+                    os->writeSize(0);
                 }
                 else
                 {
@@ -1365,10 +1391,10 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
                 Ice::ByteSeq seq(static_cast<size_t>(sz));
                 for (long i = 0; i < sz; ++i)
                 {
-                    long val = getInteger(RARRAY_AREF(arr, i));
+                    int32_t val = getInteger(RARRAY_AREF(arr, i));
                     if (val < 0 || val > 255)
                     {
-                        throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<byte>", i);
+                        throw RubyException(rb_eRangeError, "invalid value for element %ld of sequence<byte>", i);
                     }
                     seq[static_cast<size_t>(i)] = static_cast<byte>(val);
                 }
@@ -1382,10 +1408,10 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
             Ice::ShortSeq seq(static_cast<size_t>(sz));
             for (long i = 0; i < sz; ++i)
             {
-                long val = getInteger(RARRAY_AREF(arr, i));
+                int32_t val = getInteger(RARRAY_AREF(arr, i));
                 if (val < SHRT_MIN || val > SHRT_MAX)
                 {
-                    throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<short>", i);
+                    throw RubyException(rb_eRangeError, "invalid value for element %ld of sequence<short>", i);
                 }
                 seq[static_cast<size_t>(i)] = static_cast<int16_t>(val);
             }
@@ -1398,12 +1424,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
             Ice::IntSeq seq(static_cast<size_t>(sz));
             for (long i = 0; i < sz; ++i)
             {
-                long val = getInteger(RARRAY_AREF(arr, i));
-                if (val < INT_MIN || val > INT_MAX)
-                {
-                    throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<int>", i);
-                }
-                seq[static_cast<size_t>(i)] = static_cast<int32_t>(val);
+                seq[static_cast<size_t>(i)] = getInteger(RARRAY_AREF(arr, i));
             }
             os->write(seq);
             break;
@@ -1431,7 +1452,12 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
                     throw RubyException(rb_eTypeError, "unable to convert array element %ld to a float", i);
                 }
                 assert(TYPE(v) == T_FLOAT);
-                seq[static_cast<size_t>(i)] = static_cast<float>(RFLOAT_VALUE(v));
+                double d = static_cast<double>(RFLOAT_VALUE(v));
+                if (isfinite(d) && (d > numeric_limits<float>::max() || d < numeric_limits<float>::lowest()))
+                {
+                    throw RubyException(rb_eTypeError, "array element %ld is out of range for a float", i);
+                }
+                seq[static_cast<size_t>(i)] = static_cast<float>(d);
             }
             os->write(seq);
             break;
@@ -1467,7 +1493,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
             }
             else
             {
-                os->write(&seq[0], &seq[0] + seq.size(), false); // Bypass string conversion.
+                os->write(seq.data(), seq.data() + seq.size(), false); // Bypass string conversion.
             }
             break;
         }
@@ -1604,7 +1630,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(
             break;
         }
     }
-    cb->unmarshaled(result, target, closure);
+    cb->unmarshaled(result, target, closure, streamUtil(is));
 }
 
 //
@@ -1787,6 +1813,15 @@ IceRuby::DictionaryInfo::unmarshal(
         //
         keyType->unmarshal(is, keyCB, Qnil, 0, false);
         assert(!NIL_P(keyCB->key));
+
+        //
+        // The callback will set the dictionary entry with the unmarshaled value, so we
+        // pass it the key through the closure. When the value type uses classes, the
+        // callback can run after this frame is gone and a raw VALUE copy of the key
+        // would go stale if GC compaction moves the key, so we pass the key's index in
+        // the stream's holding array instead.
+        //
+        void* cl;
         if (valueType->usesClasses())
         {
             // Temporarily set the entry with a Qnil value to ensure the key is not GC
@@ -1795,25 +1830,38 @@ IceRuby::DictionaryInfo::unmarshal(
             {
                 // For string keys create a frozen string to ensure that the key used
                 // in the map matches the one keep in the closure
-                keyCB->key = rb_str_new_frozen(keyCB->key);
+                keyCB->key = callRuby(rb_str_new_frozen, keyCB->key);
             }
             callRuby(rb_hash_aset, hash, keyCB->key, Qnil);
+
+            StreamUtil* util = streamUtil(is);
+            assert(util);
+            cl = reinterpret_cast<void*>(util->hold(keyCB->key));
+        }
+        else
+        {
+            cl = reinterpret_cast<void*>(keyCB->key);
         }
-        //
-        // The callback will set the dictionary entry with the unmarshaled value,
-        // so we pass it the key.
-        //
-        void* cl = reinterpret_cast<void*>(keyCB->key);
         valueType->unmarshal(is, shared_from_this(), hash, cl, false);
     }
 
-    cb->unmarshaled(hash, target, closure);
+    cb->unmarshaled(hash, target, closure, streamUtil(is));
 }
 
 void
-IceRuby::DictionaryInfo::unmarshaled(VALUE val, VALUE target, void* closure)
+IceRuby::DictionaryInfo::unmarshaled(VALUE val, VALUE target, void* closure, StreamUtil* util)
 {
-    volatile VALUE key = reinterpret_cast<VALUE>(closure);
+    volatile VALUE key;
+    if (valueType->usesClasses())
+    {
+        assert(util);
+        static_assert(sizeof(long) == sizeof(void*), "long and void* must have the same size");
+        key = util->getHeldValue(reinterpret_cast<long>(closure));
+    }
+    else
+    {
+        key = reinterpret_cast<VALUE>(closure);
+    }
     callRuby(rb_hash_aset, target, key, val);
 }
 
@@ -1880,7 +1928,7 @@ IceRuby::DictionaryInfo::printElement(VALUE key, VALUE value, IceInternal::Outpu
 }
 
 void
-IceRuby::DictionaryInfo::KeyCallback::unmarshaled(VALUE val, VALUE, void*)
+IceRuby::DictionaryInfo::KeyCallback::unmarshaled(VALUE val, VALUE, void*, StreamUtil*)
 {
     key = val;
 }
@@ -1909,6 +1957,8 @@ IceRuby::ClassInfo::create(VALUE ident)
 {
     shared_ptr<ClassInfo> classInfo{new ClassInfo{ident}};
     const_cast<VALUE&>(classInfo->typeObj) = createType(classInfo);
+    // Pin the type object: the GC cannot see the VALUE stored in this object, so it must never move.
+    rb_gc_register_mark_object(classInfo->typeObj);
     return classInfo;
 }
 
@@ -1933,10 +1983,12 @@ IceRuby::ClassInfo::define(VALUE t, VALUE compact, VALUE intf, VALUE b, VALUE m)
         assert(base);
     }
 
-    const_cast<int32_t&>(compactId) = static_cast<int32_t>(getInteger(compact));
+    const_cast<int32_t&>(compactId) = getInteger(compact);
     const_cast<bool&>(interface) = RTEST(intf);
     convertDataMembers(m, const_cast<DataMemberList&>(members), const_cast<DataMemberList&>(optionalMembers), true);
     const_cast<VALUE&>(rubyClass) = t;
+    // Pin the class: the GC cannot see the VALUE stored in this object, so it must never move.
+    rb_gc_register_mark_object(rubyClass);
     const_cast<bool&>(defined) = true;
 }
 
@@ -2054,9 +2106,9 @@ IceRuby::ClassInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr&
     // attached to the stream keeps a reference to the callback object to ensure it lives
     // long enough.
     //
-    ReadValueCallbackPtr rocb = make_shared<ReadValueCallback>(shared_from_this(), cb, target, closure);
-    StreamUtil* util = reinterpret_cast<StreamUtil*>(is->getClosure());
+    StreamUtil* util = streamUtil(is);
     assert(util);
+    ReadValueCallbackPtr rocb = make_shared<ReadValueCallback>(shared_from_this(), cb, target, closure, util);
     util->add(rocb);
     is->read(patchObject, rocb.get());
 }
@@ -2076,10 +2128,10 @@ IceRuby::ClassInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHist
     }
     else
     {
-        map<VALUE, int>::iterator q = history->objects.find(value);
-        if (q != history->objects.end())
+        volatile VALUE printedIndex = callRuby(rb_hash_lookup, history->objects, value);
+        if (!NIL_P(printedIndex))
         {
-            out << "<object #" << q->second << ">";
+            out << "<object #" << FIX2INT(printedIndex) << ">";
         }
         else
         {
@@ -2090,7 +2142,7 @@ IceRuby::ClassInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHist
             info = dynamic_pointer_cast<ClassInfo>(getType(type));
             assert(info);
             out << "object #" << history->index << " (" << info->id << ')';
-            history->objects.insert(map<VALUE, int>::value_type(value, history->index));
+            callRuby(rb_hash_aset, history->objects, value, INT2FIX(history->index));
             ++history->index;
             out.sb();
             info->printMembers(value, out, history);
@@ -2185,13 +2237,14 @@ IceRuby::ProxyInfo::create(VALUE ident)
 {
     shared_ptr<ProxyInfo> proxyInfo{new ProxyInfo{ident}};
     const_cast<VALUE&>(proxyInfo->typeObj) = createType(proxyInfo);
+    // Pin the type object: the GC cannot see the VALUE stored in this object, so it must never move.
+    rb_gc_register_mark_object(proxyInfo->typeObj);
     return proxyInfo;
 }
 
-IceRuby::ProxyInfo::ProxyInfo(VALUE ident) : isBase(false), rubyClass(Qnil), typeObj(Qnil)
+IceRuby::ProxyInfo::ProxyInfo(VALUE ident) : rubyClass(Qnil), typeObj(Qnil)
 {
     const_cast<string&>(id) = getString(ident);
-    const_cast<bool&>(isBase) = id == Ice::Object::ice_staticId();
 }
 
 void
@@ -2199,20 +2252,19 @@ IceRuby::ProxyInfo::define(VALUE t, VALUE b, VALUE i)
 {
     if (!NIL_P(b))
     {
-        const_cast<ProxyInfoPtr&>(base) = dynamic_pointer_cast<ProxyInfo>(getType(b));
-        assert(base);
+        assert(dynamic_pointer_cast<ProxyInfo>(getType(b)));
     }
 
     volatile VALUE arr = callRuby(rb_check_array_type, i);
     assert(!NIL_P(arr));
     for (int n = 0; n < RARRAY_LEN(arr); ++n)
     {
-        ProxyInfoPtr iface = dynamic_pointer_cast<ProxyInfo>(getType(RARRAY_AREF(arr, n)));
-        assert(iface);
-        const_cast<ProxyInfoList&>(interfaces).push_back(iface);
+        assert(dynamic_pointer_cast<ProxyInfo>(getType(RARRAY_AREF(arr, n))));
     }
 
     const_cast<VALUE&>(rubyClass) = t;
+    // Pin the class: the GC cannot see the VALUE stored in this object, so it must never move.
+    rb_gc_register_mark_object(rubyClass);
 }
 
 string
@@ -2236,7 +2288,7 @@ IceRuby::ProxyInfo::variableLength() const
 int
 IceRuby::ProxyInfo::wireSize() const
 {
-    return 1;
+    return 2;
 }
 
 Ice::OptionalFormat
@@ -2287,7 +2339,7 @@ IceRuby::ProxyInfo::unmarshal(
 
     if (!proxy)
     {
-        cb->unmarshaled(Qnil, target, closure);
+        cb->unmarshaled(Qnil, target, closure, streamUtil(is));
         return;
     }
 
@@ -2297,7 +2349,7 @@ IceRuby::ProxyInfo::unmarshal(
     }
 
     volatile VALUE p = createProxy(proxy.value(), rubyClass);
-    cb->unmarshaled(p, target, closure);
+    cb->unmarshaled(p, target, closure, streamUtil(is));
 }
 
 void
@@ -2315,47 +2367,8 @@ IceRuby::ProxyInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHist
     }
     else
     {
-        out << getString(value);
-    }
-}
-
-bool
-IceRuby::ProxyInfo::isA(const ProxyInfoPtr& info)
-{
-    //
-    // Return true if this class has an is-a relationship with info.
-    //
-    if (info->isBase)
-    {
-        return true;
-    }
-    else if (this == info.get())
-    {
-        return true;
-    }
-    else if (base && base->isA(info))
-    {
-        return true;
-    }
-    else if (!interfaces.empty())
-    {
-        for (ProxyInfoList::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
-        {
-            if ((*p)->isA(info))
-            {
-                return true;
-            }
-        }
+        out << getProxy(value)->ice_toString();
     }
-
-    return false;
-}
-
-void
-IceRuby::ProxyInfo::destroy()
-{
-    const_cast<ProxyInfoPtr&>(base) = 0;
-    const_cast<ProxyInfoList&>(interfaces).clear();
 }
 
 //
@@ -2366,10 +2379,6 @@ IceRuby::ValueWriter::ValueWriter(VALUE object, ValueMap* valueMap, const ClassI
       _map(valueMap),
       _formal(formal)
 {
-    //
-    // Mark the object as in use for the lifetime of this wrapper.
-    //
-    rb_gc_register_address(&_object);
     if (!_formal || !_formal->interface)
     {
         volatile VALUE cls = CLASS_OF(object);
@@ -2378,6 +2387,9 @@ IceRuby::ValueWriter::ValueWriter(VALUE object, ValueMap* valueMap, const ClassI
         _info = dynamic_pointer_cast<ClassInfo>(getType(type));
         assert(_info);
     }
+
+    // Mark the object as in use for the lifetime of this wrapper. We register last, in case the code above throws.
+    rb_gc_register_address(&_object);
 }
 
 IceRuby::ValueWriter::~ValueWriter() { rb_gc_unregister_address(&_object); }
@@ -2553,7 +2565,9 @@ IceRuby::ValueReader::_iceRead(Ice::InputStream* is)
         {
             assert(!_slicedData->slices.empty());
 
-            volatile VALUE typeId = createString(_slicedData->slices[0]->typeId);
+            const Ice::SliceInfoPtr& sliceInfo = _slicedData->slices[0];
+            volatile VALUE typeId =
+                createString(sliceInfo->typeId.empty() ? std::to_string(sliceInfo->compactId) : sliceInfo->typeId);
             callRuby(rb_iv_set, _object, "@unknownTypeId", typeId);
         }
     }
@@ -2601,10 +2615,14 @@ IceRuby::ReadValueCallback::ReadValueCallback(
     const ClassInfoPtr& info,
     const UnmarshalCallbackPtr& cb,
     VALUE target,
-    void* closure)
+    void* closure,
+    StreamUtil* util)
     : _info(info),
       _cb(cb),
-      _target(target),
+      _util(util),
+      // invoke() can run after the unmarshal frame that created target has returned, and GC compaction
+      // can move target in the meantime; hold it in the stream's holding array and recover it by index.
+      _targetIndex(util->hold(target)),
       _closure(closure)
 {
 }
@@ -2633,11 +2651,11 @@ IceRuby::ReadValueCallback::invoke(const shared_ptr<Ice::Value>& p)
         // With debug builds we force a GC to ensure that all data members are correctly keep alive.
         rb_gc();
 #endif
-        _cb->unmarshaled(obj, _target, _closure);
+        _cb->unmarshaled(obj, _util->getHeldValue(_targetIndex), _closure, _util);
     }
     else
     {
-        _cb->unmarshaled(Qnil, _target, _closure);
+        _cb->unmarshaled(Qnil, _util->getHeldValue(_targetIndex), _closure, _util);
     }
 }
 
@@ -2696,7 +2714,6 @@ IceRuby::ExceptionInfo::print(VALUE value, IceInternal::Output& out)
     }
 
     PrintObjectHistory history;
-    history.index = 0;
 
     out << "exception " << id;
     out.sb();
@@ -2751,7 +2768,10 @@ IceRuby::ExceptionInfo::printMembers(VALUE value, IceInternal::Output& out, Prin
 //
 // ExceptionReader implementation.
 //
-IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) : _info(info) {}
+IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) : _info(info), _ex(Qnil)
+{
+    rb_gc_register_address(&_ex);
+}
 
 IceRuby::ExceptionReader::ExceptionReader(const ExceptionReader& reader) : _info(reader._info), _ex(reader._ex)
 {
@@ -2782,9 +2802,8 @@ void
 IceRuby::ExceptionReader::_read(Ice::InputStream* is)
 {
     is->startException();
-
-    const_cast<VALUE&>(_ex) = _info->unmarshal(is);
-    rb_gc_register_address(&_ex);
+    _ex = _info->unmarshal(is);
+    is->endException();
 }
 
 bool
@@ -2814,7 +2833,9 @@ IceRuby_defineStruct(VALUE /*self*/, VALUE id, VALUE type, VALUE members)
     ICE_RUBY_TRY
     {
         StructInfoPtr info = make_shared<StructInfo>(id, type, members);
-        return createType(info);
+        VALUE result = createType(info);
+        rb_define_const(type, "ICE_TYPE", result);
+        return result;
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -2914,10 +2935,14 @@ IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE base, VALUE
         }
 
         info->rubyClass = type;
+        // Pin the class: the GC cannot see the VALUE stored in this object, so it must never move.
+        rb_gc_register_mark_object(type);
 
         addExceptionInfo(info->id, info);
 
-        return createException(info);
+        VALUE result = createException(info);
+        rb_define_const(type, "ICE_TYPE", result);
+        return result;
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -2974,7 +2999,6 @@ IceRuby_stringify(VALUE /*self*/, VALUE obj, VALUE type)
         ostringstream ostr;
         IceInternal::Output out(ostr);
         PrintObjectHistory history;
-        history.index = 0;
         info->print(obj, out, &history);
 
         string str = ostr.str();