[WIP][clang] Add experimental option to omit the RTTI component from the vtable when -fno-rtti is used

[leonardchan]

Summary

For programs that don't use RTTI, the rtti component is just replaced with a zero. This way, vtables that don't use RTTI can still cooperate with vtables that use RTTI since offset calculations on the ABI level would still work. However, if throughout your whole program you don't use RTTI at all (such as the embedded case), then this is just an unused pointer-sized component that's wasting space. This adds an experimental option for removing the RTTI component from the vtable.

Some notes:

• This is only allowed when RTTI is disabled, so we don't have to worry about things like typeid or dynamic_cast.
• This is a "use at your own risk" since, similar to relative vtables, everything must be compiled with this since it's an ABI breakage. That is, a program compiled with this is not guaranteed to work with a program compiled without this, even if RTTI is disabled for both programs.

Note that this is a completely different ABI flavor orthogonal to the relative-vtables ABI. That is, they can be enabled/disabled independently.

[mcgrathr]

It's not clear from the change description if this can be enabled orthogonally to relative-vtables. I think it should be possible to choose each switch independently, thus generating 4 variants of the vtable layout ABI.

Does any runtime code (libc++abi) ever need to know the vtable layout details when actually making use of RTTI, such that it would need to adapt to this ABI change?

[leonardchan]

In D152405#4404596, @mcgrathr wrote:

It's not clear from the change description if this can be enabled orthogonally to relative-vtables. I think it should be possible to choose each switch independently, thus generating 4 variants of the vtable layout ABI.

Oh this is completely independent from relative vtables. I'll update the wording.

Does any runtime code (libc++abi) ever need to know the vtable layout details when actually making use of RTTI, such that it would need to adapt to this ABI change?

__dynamic_cast is the only thing that comes to mind, but since this is gated on -fno-rtti where dynamic_cast is disabled, then I think libc++abi doesn't need to worry about this.

[mcgrathr]

In D152405#4404616, @leonardchan wrote:

Oh this is completely independent from relative vtables. I'll update the wording.

Great. I'd like to see us try some experiments with enabling both together in places like the Fuchsia kernel where we get benefit from relative-vtables today but it's all a single fungible internal ABI domain and there's no problem having a one-off ABI. It's also interesting of course for true embedded contexts, but those tend to be ILP32 where relative-vtables isn't a size savings anyway. In the Fuchsia kernel we should get some size savings from this and it would be nice to see what that is (probably not all that big, but interesting).

Can we extend the test cases to exercise both with and without relative-vtables also enabled?

Does any runtime code (libc++abi) ever need to know the vtable layout details when actually making use of RTTI, such that it would need to adapt to this ABI change?

__dynamic_cast is the only thing that comes to mind, but since this is gated on -fno-rtti where dynamic_cast is disabled, then I think libc++abi doesn't need to worry about this.

Perfect. This makes this a good free-floating option for any context like kernel or embedded where all code (even if libc++/libc++abi are included) are built from scratch using the same switches.

[leonardchan]

Can we extend the test cases to exercise both with and without relative-vtables also enabled?

Yup, the cases here already test with the regular itanium c++ abi and relative vtables abi.

[leonardchan]

In D152405#4404742, @mcgrathr wrote:

In D152405#4404616, @leonardchan wrote:

Oh this is completely independent from relative vtables. I'll update the wording.

Great. I'd like to see us try some experiments with enabling both together in places like the Fuchsia kernel where we get benefit from relative-vtables today but it's all a single fungible internal ABI domain and there's no problem having a one-off ABI. It's also interesting of course for true embedded contexts, but those tend to be ILP32 where relative-vtables isn't a size savings anyway. In the Fuchsia kernel we should get some size savings from this and it would be nice to see what that is (probably not all that big, but interesting).

In the kernel it saves us about 664 bytes with RV. For some embedded devices I measured, savings is on the order of 1-2kB. For chromium with RV, it would save about 77076 bytes from rodata, but standalone without RV, it's twice that so 154152 bytes saved from .data.rel.ro and this would scale based on the number of processes.

[phosek]

clang/include/clang/Driver/Options.td

2666–2673

Can you use BoolFOption to simplify the definition?

2667

I think the name should signal that this is related to vtables (otherwise users might be wondering what "component" is this referring to).

We could use -fexperimental-omit-vtable-rtti-component but that's quite a mouthful, maybe -fexperimental-omit-vtable-rtti would suffice?

[phosek]

LGTM

clang/include/clang/Basic/LangOptions.def

453

I'd also rename this to OmitVTableRTTI for consistency.

[leonardchan]

clang/include/clang/Driver/Options.td

2667

I think the name should signal that this is related to vtables (otherwise users might be wondering what "component" is this referring to).

Formally, this can be used independently of relative vtables. So under the regular itanium c++ abi this would reduce the vtable by a pointer size and under RV it would reduce the vtable by an offset size. "Component" I believe is the formal name for the actual elements in the vtable: https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vtable-components.

We could use -fexperimental-omit-vtable-rtti-component but that's quite a mouthful, maybe -fexperimental-omit-vtable-rtti would suffice?

WFM

[dyung]

Hi @leonardchan your change was still causing a failure on the PS4 linux bot, so I reverted it in 070493ddbd9473499d6f00ca62bc6aa92808ed79. I noticed earlier that the failing test omit-rtti-component-without-no-rtti.cpp was failing on both the linux and Windows PS bots, and I don't think it is because it was on Windows, but rather, these bots use PS4 and PS5 as the default targets, on which rtti is not enabled by default. The run command on line 4 in your test tests the "default" behavior which on most platforms seems to have rtti enabled by default. If I remove that line, the test then passes on both of the PS targets. To reland the change, you might want to consider removing that line as it makes an assumption which does not seem to be true for all targets.

[leonardchan]

In D152405#4645719, @dyung wrote:

Hi @leonardchan your change was still causing a failure on the PS4 linux bot, so I reverted it in 070493ddbd9473499d6f00ca62bc6aa92808ed79. I noticed earlier that the failing test omit-rtti-component-without-no-rtti.cpp was failing on both the linux and Windows PS bots, and I don't think it is because it was on Windows, but rather, these bots use PS4 and PS5 as the default targets, on which rtti is not enabled by default. The run command on line 4 in your test tests the "default" behavior which on most platforms seems to have rtti enabled by default. If I remove that line, the test then passes on both of the PS targets. To reland the change, you might want to consider removing that line as it makes an assumption which does not seem to be true for all targets.

Ahh. Thanks for the revert and the info. I'll reland with that removed.

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_cc1_round_trip_fail_then_ok : Error<
   "original arguments parse failed, then succeeded in round-trip">;
 def err_cc1_round_trip_ok_then_fail : Error<
   "generated arguments parse failed in round-trip">;
 def err_cc1_round_trip_mismatch : Error<
   "generated arguments do not match in round-trip">;
 def err_cc1_unbounded_vscale_min : Error<
   "minimum vscale must be an unsigned integer greater than 0">;
 
+def err_drv_using_omit_rtti_component_without_no_rtti : Error<
+  "-fexperimental-omit-vtable-rtti call only be used with -fno-rtti">;
+
 def err_drv_ssp_missing_offset_argument : Error<
   "'%0' is used without '-mstack-protector-guard-offset', and there is no default">;
 
 def err_drv_only_one_offload_target_supported : Error<
   "only one offload target is supported">;
 def err_drv_invalid_or_unsupported_offload_target : Error<
   "invalid or unsupported offload target: '%0'">;
 def err_drv_cuda_offload_only_emit_bc : Error<

clang/include/clang/Basic/LangOptions.def

ENUM_LANGOPT(SignReturnAddressKey, SignReturnAddressKeyKind, 1, SignReturnAddressKeyKind::AKey,
              "Key used for return address signing")
 LANGOPT(BranchTargetEnforcement, 1, 0, "Branch-target enforcement enabled")
 
 LANGOPT(SpeculativeLoadHardening, 1, 0, "Speculative load hardening enabled")
 
 LANGOPT(RelativeCXXABIVTables, 1, 0,
         "Use an ABI-incompatible v-table layout that uses relative references")
 
+LANGOPT(OmitRTTIComponent, 1, 0,
+        "Use an ABI-incompatible v-table layout that omits the RTTI component")
+
 LANGOPT(VScaleMin, 32, 0, "Minimum vscale value")
 LANGOPT(VScaleMax, 32, 0, "Maximum vscale value")
 
 ENUM_LANGOPT(ExtendIntArgs, ExtendArgsKind, 1, ExtendArgsKind::ExtendTo32,
              "Controls how scalar integer arguments are extended in calls "
              "to unprototyped and varargs functions")
 
 VALUE_LANGOPT(FuchsiaAPILevel, 32, 0, "Fuchsia API level")

clang/include/clang/Driver/Options.td

def fexperimental_relative_cxx_abi_vtables :
   Flag<["-"], "fexperimental-relative-c++-abi-vtables">,
   Group<f_clang_Group>, Visibility<[ClangOption, CC1Option]>,
   HelpText<"Use the experimental C++ class ABI for classes with virtual tables">;
 def fno_experimental_relative_cxx_abi_vtables :
   Flag<["-"], "fno-experimental-relative-c++-abi-vtables">,
   Group<f_clang_Group>, Visibility<[ClangOption, CC1Option]>,
   HelpText<"Do not use the experimental C++ class ABI for classes with virtual tables">;
 
+defm experimental_omit_vtable_rtti : BoolFOption<"experimental-omit-vtable-rtti",
+  LangOpts<"OmitRTTIComponent">, DefaultFalse,
+  PosFlag<SetTrue, [], [CC1Option], "Omit">,
+  NegFlag<SetFalse, [], [CC1Option], "Do not omit">,
+  BothFlags<[], [CC1Option], " the RTTI component from virtual tables">>;
+
 def fcxx_abi_EQ : Joined<["-"], "fc++-abi=">,
                   Group<f_clang_Group>, Visibility<[ClangOption, CC1Option]>,
                   HelpText<"C++ ABI to use. This will override the target C++ ABI.">;
 
 def flat__namespace : Flag<["-"], "flat_namespace">;
 def flax_vector_conversions_EQ : Joined<["-"], "flax-vector-conversions=">, Group<f_Group>,
   HelpText<"Enable implicit vector bit-casts">, Values<"none,integer,all">,
   Visibility<[ClangOption, CC1Option]>,
   NormalizedValues<["LangOptions::LaxVectorConversionKind::None",
                     "LangOptions::LaxVectorConversionKind::Integer",

clang/lib/AST/VTableBuilder.cpp

if (BaseIsVirtual)
     AddVCallOffsets(Base, RealBaseOffset);
 }
 
 CharUnits VCallAndVBaseOffsetBuilder::getCurrentOffsetOffset() const {
   // OffsetIndex is the index of this vcall or vbase offset, relative to the
   // vtable address point. (We subtract 3 to account for the information just
   // above the address point, the RTTI info, the offset to top, and the
   // vcall offset itself).
-  int64_t OffsetIndex = -(int64_t)(3 + Components.size());
+  size_t NumComponentsAboveAddrPoint = 3;
+  if (Context.getLangOpts().OmitRTTIComponent)
+    NumComponentsAboveAddrPoint--;
+  int64_t OffsetIndex =
+      -(int64_t)(NumComponentsAboveAddrPoint + Components.size());
 
   // Under the relative ABI, the offset widths are 32-bit ints instead of
   // pointer widths.
   CharUnits OffsetWidth = Context.toCharUnitsFromBits(
       VTables.isRelativeLayout()
           ? 32
           : Context.getTargetInfo().getPointerWidth(LangAS::Default));
   CharUnits OffsetOffset = OffsetWidth * OffsetIndex;
void ItaniumVTableBuilder::LayoutPrimaryAndSecondaryVTables(
   if (Base.getBase() == MostDerivedClass)
     VBaseOffsetOffsets = Builder.getVBaseOffsetOffsets();
 
   // Add the offset to top.
   CharUnits OffsetToTop = MostDerivedClassOffset - OffsetInLayoutClass;
   Components.push_back(VTableComponent::MakeOffsetToTop(OffsetToTop));
 
   // Next, add the RTTI.
+  if (!Context.getLangOpts().OmitRTTIComponent)
     Components.push_back(VTableComponent::MakeRTTI(MostDerivedClass));
 
   uint64_t AddressPoint = Components.size();
 
   // Now go through all virtual member functions and add them.
   PrimaryBasesSetVectorTy PrimaryBases;
   AddMethods(Base, OffsetInLayoutClass,
              Base.getBase(), OffsetInLayoutClass,
              PrimaryBases);

clang/lib/Driver/ToolChains/Clang.cpp

Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls,
                      options::OPT_fno_escaping_block_tail_calls);
 
   Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
                   options::OPT_fno_fine_grained_bitfield_accesses);
 
   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
                   options::OPT_fno_experimental_relative_cxx_abi_vtables);
 
+  Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
+                  options::OPT_fno_experimental_omit_vtable_rtti);
+
   // Handle segmented stacks.
   Args.addOptInFlag(CmdArgs, options::OPT_fsplit_stack,
                     options::OPT_fno_split_stack);
 
   // -fprotect-parens=0 is default.
   if (Args.hasFlag(options::OPT_fprotect_parens,
                    options::OPT_fno_protect_parens, false))
     CmdArgs.push_back("-fprotect-parens");
Args.addOptInFlag(CmdArgs, options::OPT_ffixed_point,
                     options::OPT_fno_fixed_point);
 
   if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
     A->render(Args, CmdArgs);
 
   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
                   options::OPT_fno_experimental_relative_cxx_abi_vtables);
 
+  Args.AddLastArg(CmdArgs, options::OPT_fexperimental_omit_vtable_rtti,
+                  options::OPT_fno_experimental_omit_vtable_rtti);
+
   if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
     A->render(Args, CmdArgs);
 
   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
   // (-ansi is equivalent to -std=c89 or -std=c++98).
   //
   // If a std is supplied, only add -trigraphs if it follows the
   // option.

clang/lib/Frontend/CompilerInvocation.cpp

if (!CXXABI.empty()) {
     }
   }
 
   Opts.RelativeCXXABIVTables =
       Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
                    options::OPT_fno_experimental_relative_cxx_abi_vtables,
                    TargetCXXABI::usesRelativeVTables(T));
 
+  // RTTI is on by default.
+  bool HasRTTI = Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti, true);
+  Opts.OmitRTTIComponent =
+      Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
+                   options::OPT_fno_experimental_omit_vtable_rtti, false);
+  if (Opts.OmitRTTIComponent && HasRTTI)
+    Diags.Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
+
   for (const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
     auto Split = StringRef(A).split('=');
     Opts.MacroPrefixMap.insert(
         {std::string(Split.first), std::string(Split.second)});
   }
 
   Opts.UseTargetPathSeparator =
       !Args.getLastArg(OPT_fno_file_reproducible) &&

clang/test/CodeGenCXX/OmitRTTIComponentABI/simple-vtable-definition.cpp

+/// Check that -fexperimental-omit-vtable-rtti omits the RTTI component from
+/// the vtable.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-linux-gnu -fno-rtti -fexperimental-omit-vtable-rtti -S -o - -emit-llvm | FileCheck -check-prefixes=POINTER,RTTI %s
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-linux-gnu -fexperimental-relative-c++-abi-vtables -fno-rtti -fexperimental-omit-vtable-rtti -S -o - -emit-llvm | FileCheck -check-prefixes=RELATIVE,RTTI %s
+
+/// Normally, the vtable would contain at least three components:
+/// - An offset to top
+/// - A pointer to the RTTI struct
+/// - A virtual function
+///
+/// Now vtables should have just two components.
+// POINTER: @_ZTV1A = unnamed_addr constant { [2 x ptr] } { [2 x ptr] [ptr null, ptr @_ZN1A3fooEv] }, align 8
+// RELATIVE: @_ZTV1A.local = private unnamed_addr constant { [2 x i32] } { [2 x i32] [i32 0, i32 trunc (i64 sub (i64 ptrtoint (ptr dso_local_equivalent @_ZN1A3fooEv to i64), i64 ptrtoint (ptr getelementptr inbounds ({ [2 x i32] }, ptr @_ZTV1A.local, i32 0, i32 0, i32 1) to i64)) to i32)] }, align 4
+// RELATIVE: @_ZTV1A = unnamed_addr alias { [2 x i32] }, ptr @_ZTV1A.local
+
+/// None of these supplementary symbols should be emitted with -fno-rtti, but
+/// as a sanity check lets make sure they're not emitted also.
+// RTTI-NOT: @_ZTVN10__cxxabiv117__class_type_infoE
+// RTTI-NOT: @_ZTS1A
+// RTTI-NOT: @_ZTI1A
+
+class A {
+public:
+  virtual void foo();
+};
+
+void A::foo() {}
+
+void A_foo(A *a) {
+  a->foo();
+}

clang/test/CodeGenCXX/OmitRTTIComponentABI/vbase-offset.cpp

+/// Check that the offset to top calculation is adjusted to account for the
+/// omitted RTTI entry.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-linux-gnu -fexperimental-omit-vtable-rtti -fno-rtti -S -o - -emit-llvm | FileCheck -check-prefixes=POINTER %s
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-linux-gnu -fexperimental-relative-c++-abi-vtables -fexperimental-omit-vtable-rtti -fno-rtti -S -o - -emit-llvm | FileCheck -check-prefixes=RELATIVE %s
+
+/// Some important things to check:
+/// - The n16 here represents the virtual thunk size. Normally this would be 24
+///   to represent 3 components (offset to top, RTTI component, vcall offset),
+///   but since one 8-byte component is removed, this is now 16.
+// POINTER-LABEL: @_ZTv0_n16_N7Derived1fEi(
+// POINTER-NEXT:  entry:
+// POINTER:        [[vtable:%.+]] = load ptr, ptr %this1, align 8
+
+/// Same here - When getting the vbase offset, we subtract 2 pointer sizes
+/// instead of 3.
+// POINTER-NEXT:   [[vbase_offset_ptr:%.+]] = getelementptr inbounds i8, ptr [[vtable]], i64 -16
+// POINTER-NEXT:   [[vbase_offset:%.+]] = load i64, ptr [[vbase_offset_ptr]], align 8
+// POINTER-NEXT:   [[adj_this:%.+]] = getelementptr inbounds i8, ptr %this1, i64 [[vbase_offset]]
+// POINTER:   [[call:%.+]] = tail call noundef i32 @_ZN7Derived1fEi(ptr noundef{{[^,]*}} [[adj_this]], i32 noundef {{.*}})
+// POINTER:   ret i32 [[call]]
+
+/// For relative vtables, it's almost the same except the offset sizes are
+/// halved.
+// RELATIVE-LABEL: @_ZTv0_n8_N7Derived1fEi(
+// RELATIVE-NEXT:  entry:
+// RELATIVE:        [[vtable:%.+]] = load ptr, ptr %this1, align 8
+// RELATIVE-NEXT:   [[vbase_offset_ptr:%.+]] = getelementptr inbounds i8, ptr [[vtable]], i64 -8
+// RELATIVE-NEXT:   [[vbase_offset:%.+]] = load i32, ptr [[vbase_offset_ptr]], align 4
+// RELATIVE-NEXT:   [[adj_this:%.+]] = getelementptr inbounds i8, ptr %this1, i32 [[vbase_offset]]
+// RELATIVE:        [[call:%.+]] = tail call noundef i32 @_ZN7Derived1fEi(ptr noundef{{[^,]*}} [[adj_this]], i32 noundef {{.*}})
+// RELATIVE:        ret i32 [[call]]
+
+class Base {
+public:
+  virtual int f(int x);
+
+private:
+  long x;
+};
+
+class Derived : public virtual Base {
+public:
+  virtual int f(int x);
+
+private:
+  long y;
+};
+
+int Base::f(int x) { return x + 1; }
+int Derived::f(int x) { return x + 2; }

clang/test/CodeGenCXX/OmitRTTIComponentABI/vtable-layout.cpp

+/// Ensure -fdump-vtable-layout omits the rtti component when passed -fexperimental-omit-vtable-rtti.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-linux-gnu -fno-rtti -fexperimental-omit-vtable-rtti -emit-llvm-only -fdump-vtable-layouts | FileCheck %s
+
+// CHECK:      Vtable for 'A' (2 entries).
+// CHECK-NEXT:    0 | offset_to_top (0)
+// CHECK-NEXT:        -- (A, 0) vtable address --
+// CHECK-NEXT:    1 | void A::foo()
+
+class A {
+public:
+  virtual void foo();
+};
+
+void A::foo() {}
+
+void A_foo(A *a) {
+  a->foo();
+}

clang/test/Driver/omit-rtti-component-flag.cpp

+// RUN: %clangxx --target=aarch64-unknown-linux -fno-rtti -Xclang -fexperimental-omit-vtable-rtti -c %s -### 2>&1 | FileCheck %s --check-prefix=OMIT
+// RUN: %clangxx --target=aarch64-unknown-linux -fno-rtti -Xclang -fno-experimental-omit-vtable-rtti -c %s -### 2>&1 | FileCheck %s --check-prefix=NO-OMIT
+
+// OMIT: "-fexperimental-omit-vtable-rtti"
+// NO-OMIT-NOT: "-fexperimental-omit-vtable-rtti"

clang/test/Driver/omit-rtti-component-without-no-rtti.cpp

+/// Ensure that -fexperimental-omit-vtable-rtti is only allowed if rtti is
+/// disabled.
+
+// RUN: not %clang -c -Xclang -fexperimental-omit-vtable-rtti %s 2>&1 | FileCheck -check-prefix=ERROR %s
+// RUN: not %clang -c -Xclang -fexperimental-omit-vtable-rtti -frtti %s 2>&1 | FileCheck -check-prefix=ERROR %s
+// RUN: not %clang -c -Xclang -fexperimental-omit-vtable-rtti -fno-rtti -frtti %s 2>&1 | FileCheck -check-prefix=ERROR %s
+
+// RUN: %clang -c -Xclang -fexperimental-omit-vtable-rtti -fno-rtti %s 2>&1 | FileCheck -check-prefix=NO-ERROR %s --allow-empty
+// RUN: %clang -c -Xclang -fno-experimental-omit-vtable-rtti -frtti %s 2>&1 | FileCheck -check-prefix=NO-ERROR %s --allow-empty
+// RUN: %clang -c -Xclang -fexperimental-omit-vtable-rtti -Xclang -fno-experimental-omit-vtable-rtti -frtti %s 2>&1 | FileCheck -check-prefix=NO-ERROR %s --allow-empty
+
+// ERROR: -fexperimental-omit-vtable-rtti call only be used with -fno-rtti
+// NO-ERROR-NOT: -fexperimental-omit-vtable-rtti call only be used with -fno-rtti