[libcxxabi] Add macro for changing functions to support the relative vtables ABI

[leonardchan]

Summary

Under the relative vtables ABI, __dynamic_cast will not work since it assumes the vtable pointer is 2 ptrdiff_ts away from the start of the vtable (8-byte offset to top + 8-byte pointer to typeinfo) when it is actually 8 bytes away (4-byte offset to top + 4-byte offset to typeinfo). This adjusts the logic under __dynamic_cast to support this ABI when it's used.

[leonardchan]

Marking WIP for now since (I think for testing), this will require some separate clang changes first.

[leonardchan]

Ok. Ready for review!

[mcgrathr]

Long-term, I think we want this to be keyed entirely on a compiler predefine and not chosen in cmake.

[ldionne]

In D77606#2214538, @mcgrathr wrote:

Long-term, I think we want this to be keyed entirely on a compiler predefine and not chosen in cmake.

Actually, I'd like to use that approach now. @leonardchan is that possible?

[leonardchan]

In D77606#2215442, @ldionne wrote:

In D77606#2214538, @mcgrathr wrote:

Long-term, I think we want this to be keyed entirely on a compiler predefine and not chosen in cmake.

Actually, I'd like to use that approach now. @leonardchan is that possible?

Can do. Something like D85924?

[ldionne]

In D77606#2216493, @leonardchan wrote:

In D77606#2215442, @ldionne wrote:

In D77606#2214538, @mcgrathr wrote:

Long-term, I think we want this to be keyed entirely on a compiler predefine and not chosen in cmake.

Actually, I'd like to use that approach now. @leonardchan is that possible?

Can do. Something like D85924?

Yeah, something like that. I'm not a big fan of the name of the macro, but that's a different story to be discussed in D85924.

[leonardchan]

Update to use the __has_feature(cxx_abi_relative_vtable) macro to check how we should find the dynamic_type.

[mcgrathr]

libcxxabi/src/private_typeinfo.cpp

647

I think this should be const uint32_t* ... and <const uint32_t* const*>.

649

This should also be pointer to const.

[leonardchan]

Update with more consts and clang-formated.

[leonardchan]

*ping* Any more comments on this patch?

[ldionne]

libcxxabi/src/private_typeinfo.cpp

644

Just to be clear, is this enabled whenever the compiler *supports* the feature, or whenever the feature is actually turned on?

The former would be incorrect, because any sufficiently recent Clang would take that code path. The latter is what we want.

645

Are you certain this is the only place where code needs changing? For example we seem to extract the vtable in __base_class_type_info::search_above_dst and other functions -- don't they need to be changed too?

[leonardchan]

libcxxabi/src/private_typeinfo.cpp

644

The latter, where it's turned on.

645

Thanks for catching this. It took me some time to check and assert what these values should be. Updated to just load 32-bit ints instead of ptrdiff_t.

[ldionne]

libcxxabi/src/private_typeinfo.cpp

654

Can you avoid changing the formatting of this piece of code to make it clear it's unchanged?

[leonardchan]

Removed formatting for existing code.

libcxxabi/src/private_typeinfo.cpp

is_equal(const std::type_info* x, const std::type_info* y, bool use_strcmp)
     // Use std::type_info's default comparison unless we've explicitly asked
     // for strcmp.
     if (!use_strcmp)
         return *x == *y;
     // Still allow pointer equality to short circut.
     return x == y || strcmp(x->name(), y->name()) == 0;
 }
 
+static inline ptrdiff_t update_offset_to_base(const char* vtable,
+                                              ptrdiff_t offset_to_base) {
+#if __has_feature(cxx_abi_relative_vtable)
+  // VTable components are 32 bits in the relative vtables ABI.
+  return *reinterpret_cast<const int32_t*>(vtable + offset_to_base);
+#else
+  return *reinterpret_cast<const ptrdiff_t*>(vtable + offset_to_base);
+#endif
+}
+
 namespace __cxxabiv1
 {
 
 // __shim_type_info
 
 __shim_type_info::~__shim_type_info()
 {
 }

 {
     ptrdiff_t offset_to_base = 0;
     if (adjustedPtr != nullptr)
     {
         offset_to_base = __offset_flags >> __offset_shift;
         if (__offset_flags & __virtual_mask)
         {
             const char* vtable = *static_cast<const char*const*>(adjustedPtr);
-            offset_to_base = *reinterpret_cast<const ptrdiff_t*>(vtable + offset_to_base);
+            offset_to_base = update_offset_to_base(vtable, offset_to_base);
         }
     }
     __base_type->has_unambiguous_public_base(
             info,
             static_cast<char*>(adjustedPtr) + offset_to_base,
             (__offset_flags & __public_mask) ? path_below : not_public_path);
 }
 

 
 extern "C" _LIBCXXABI_FUNC_VIS void *
 __dynamic_cast(const void *static_ptr, const __class_type_info *static_type,
                const __class_type_info *dst_type,
                std::ptrdiff_t src2dst_offset) {
     // Possible future optimization:  Take advantage of src2dst_offset
 
     // Get (dynamic_ptr, dynamic_type) from static_ptr
+#if __has_feature(cxx_abi_relative_vtable)
+    // The vtable address will point to the first virtual function, which is 8
+    // bytes after the start of the vtable (4 for the offset from top + 4 for the typeinfo component).
+    const int32_t* vtable =
+        *reinterpret_cast<const int32_t* const*>(static_ptr);
+    int32_t offset_to_derived = vtable[-2];
+    const void* dynamic_ptr = static_cast<const char*>(static_ptr) + offset_to_derived;
+
+    // The typeinfo component is now a relative offset to a proxy.
+    int32_t offset_to_ti_proxy = vtable[-1];
+    const uint8_t* ptr_to_ti_proxy =
+        reinterpret_cast<const uint8_t*>(vtable) + offset_to_ti_proxy;
+    const __class_type_info* dynamic_type =
+        *(reinterpret_cast<const __class_type_info* const*>(ptr_to_ti_proxy));
+#else
     void **vtable = *static_cast<void ** const *>(static_ptr);
     ptrdiff_t offset_to_derived = reinterpret_cast<ptrdiff_t>(vtable[-2]);
     const void* dynamic_ptr = static_cast<const char*>(static_ptr) + offset_to_derived;
     const __class_type_info* dynamic_type = static_cast<const __class_type_info*>(vtable[-1]);
+#endif
 
     // Initialize answer to nullptr.  This will be changed from the search
     //    results if a non-null answer is found.  Regardless, this is what will
     //    be returned.
     const void* dst_ptr = 0;
     // Initialize info struct for this search.
     __dynamic_cast_info info = {dst_type, static_ptr, static_type, src2dst_offset, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
 
     // Find out if we can use a giant short cut in the search
     if (is_equal(dynamic_type, dst_type, false))
     {
         // Using giant short cut.  Add that information to info.
         info.number_of_dst_type = 1;
         // Do the  search
         dynamic_type->search_above_dst(&info, dynamic_ptr, dynamic_ptr, public_path, false);
__base_class_type_info::search_above_dst(__dynamic_cast_info* info,
                                          const void* current_ptr,
                                          int path_below,
                                          bool use_strcmp) const
 {
     ptrdiff_t offset_to_base = __offset_flags >> __offset_shift;
     if (__offset_flags & __virtual_mask)
     {
         const char* vtable = *static_cast<const char*const*>(current_ptr);
-        offset_to_base = *reinterpret_cast<const ptrdiff_t*>(vtable + offset_to_base);
+        offset_to_base = update_offset_to_base(vtable, offset_to_base);
     }
     __base_type->search_above_dst(info, dst_ptr,
                                   static_cast<const char*>(current_ptr) + offset_to_base,
                                   (__offset_flags & __public_mask) ?
                                       path_below :
                                       not_public_path,
                                   use_strcmp);
 }
 
 void
 __base_class_type_info::search_below_dst(__dynamic_cast_info* info,
                                          const void* current_ptr,
                                          int path_below,
                                          bool use_strcmp) const
 {
     ptrdiff_t offset_to_base = __offset_flags >> __offset_shift;
     if (__offset_flags & __virtual_mask)
     {
         const char* vtable = *static_cast<const char*const*>(current_ptr);
-        offset_to_base = *reinterpret_cast<const ptrdiff_t*>(vtable + offset_to_base);
+        offset_to_base = update_offset_to_base(vtable, offset_to_base);
     }
     __base_type->search_below_dst(info,
                                   static_cast<const char*>(current_ptr) + offset_to_base,
                                   (__offset_flags & __public_mask) ?
                                       path_below :
                                       not_public_path,
                                   use_strcmp);
 }
 
 }  // __cxxabiv1