Relative VTables ABI on Fuchsia

[leonardchan]

Summary

This contains the updated patch for enabling Peter Collingbourne's relative vtable ABI (described in https://bugs.llvm.org/show_bug.cgi?id=26723) on Fuchsia. The goal is to reduce memory usage by making vtables readonly.

Key differences:

• LTO is not required
• No white listing of classes. Fuchsia does not guarantee C++ ABI stability, so anything running on Fuchsia should either by compiled with this ABI or not depend on the C++ ABI at all.
• Instead of taking the offset between the vtable and virtual function directly, we emit a DSO-local stub that just contains a tail call to the original virtual function, and take the offset between that and the vtable. We do this because there are some cases where the original function that would've been inserted into the vtable is not local or hidden and may require some kind of dynamic relocation which prevents the vtable from being readonly. On x86_64, taking the offset between the function and the vtable gets lowered to the offset between the PLT entry for the function and the vtable which gives us a PLT32 reloc. On Aarch64, right now only CALL26 and JUMP26 instructions generate PLT relocations, so we manifest them with stubs that are just jumps to the original function.
• Apply the same technique with the RTTI component in the vtable and emit a proxy that results in a GOTPCREL reloc.
• Update libcxxabi to use different arithmetic for finding the typeinfo pointer given the vtable pointer for Fuchsia
• Hide the ABI behind a flag -fexperimental-relative-c++-abi-vtables that is only available through CCI (-Xclang will need to be passed before it)

[pcc]

On Aarch64, right now only CALL26 and JUMP26 instructions generate PLT relocations, so we manifest them with stubs that are just jumps to the original function.

I think it would be worth considering defining a new relocation type for this. I think we should make the new reloc type represent the relative address shifted right by 2, which would allow it to be used freely in the aarch64 small code model (which permits programs up to 4GB), but would require the target to be 4-byte aligned, which seems like a reasonable restriction. On aarch64, decoding this would not require any additional instructions either (we can fold the lsl into the add). We could use the same technique for a new GOTPCREL relocation to be used for the RTTI component. @peter.smith what do you think?

[peter.smith]

In D72959#1832011, @pcc wrote:

On Aarch64, right now only CALL26 and JUMP26 instructions generate PLT relocations, so we manifest them with stubs that are just jumps to the original function.

I think it would be worth considering defining a new relocation type for this. I think we should make the new reloc type represent the relative address shifted right by 2, which would allow it to be used freely in the aarch64 small code model (which permits programs up to 4GB), but would require the target to be 4-byte aligned, which seems like a reasonable restriction. On aarch64, decoding this would not require any additional instructions either (we can fold the lsl into the add). We could use the same technique for a new GOTPCREL relocation to be used for the RTTI component. @peter.smith what do you think?

The idea of a new relocation type has come up before, as I recall it was something like the equivalent of R_X86_PLT32

| R_X86_64_PLT32 | 4 | word32 | L + A - P |
Where L is defined as: L Represents the place (section offset or address) of the Procedure Linkage Table entry for a symbol.

For Fuchsia there are two options:
1.) Ask for an ABI relocation type to be defined. I've raised an ABI issue with Arm, for it to progress I think it needs a "yes we really would like one, here is the definition we want to use, this is the use case and it could be used outside of Fuchsia at some point." For example I can see position independent C++ being useful in bare-metal embedded C++. The external facing email for feedback on the abi is [e-mail] (address is on the first page of the doc below)
2.) There are two ranges of relocation types reserved for private and platform relocations: https://developer.arm.com/docs/ihi0056/f/elf-for-the-arm-64-bit-architecture-aarch64-abi-2019q2-documentation

Private and platform-specific relocations
Private relocations for vendor experiments:

0xE000 to 0xEFFF for ELF64
0xE0 to 0xEF for ELF32
Platform ABI defined relocations:

0xF000 to 0xFFFF for ELF64
0xF0 to 0xFF for ELF32
Platform ABI relocations can only be interpreted when the EI_OSABI field is set to indicate the Platform ABI governing the definition.

All of the above codes will not be assigned by any future version of this standard.

If this could be generally useful outside of Fuchsia, then an official relocation would be preferable.

[rjmccall]

There's two independently-useful things here for the relocation, right? First, it's useful to be able to express a relocation to a symbol that has the semantics of a particular function but doesn't necessarily have its address, and that concept could be used across many "physical" relocations; and second, it's potentially useful to have a shifted-by-two relative address relocation, at least on AArch64 where instructions (and v-table entries under this ABI) are always four-byte-aligned anyway. Is it possible to separate these concerns in ELF, e.g. by having a "symbol" that can be the target of any other relocation but which actually represents a function of unspecified address with the semantics of another function?

[peter.smith]

In D72959#1835368, @rjmccall wrote:

There's two independently-useful things here for the relocation, right? First, it's useful to be able to express a relocation to a symbol that has the semantics of a particular function but doesn't necessarily have its address, and that concept could be used across many "physical" relocations; and second, it's potentially useful to have a shifted-by-two relative address relocation, at least on AArch64 where instructions (and v-table entries under this ABI) are always four-byte-aligned anyway. Is it possible to separate these concerns in ELF, e.g. by having a "symbol" that can be the target of any other relocation but which actually represents a function of unspecified address with the semantics of another function?

It would be possible to design relocations like that, but I think it would be difficult to fit into existing multi-target designs, which assume that the relocation code alone encodes all the actions a linker needs to take (smart-format, dumb-linker). My understanding of the reasons behind this are:

• The linker can have millions of relocations to resolve and having all the actions explicit in the code simplifies its job.
• There is a large space of available relocation codes, partitioned per target, but a much more limited availability of target specific symbol types and flags.
• The concerns can be separated at implementation time, for example the symbol lookup, encoding and calculation stages are independent and shared between the codes.

It is possible that there is a better trade-off in complexity, but anything radically different might need quite a bit of work to fit into an existing linker. Hope I've understood you correctly and apologies if the above isn't relevant.

[rjmccall]

Okay. In that case, I would ask that if you're considering going through the work of adding relocations, please consider adding both scaled and unscaled relative-offset-to-equivalent-symbol.

[leonardchan]

I updated the patch such that this everything here allows us to work with RTTI also. Since this is very large and has a lot of refactoring of the ItaniumCXXABI class and llvm changes independent from the FuchsiaCXXABI, I'll do my best to split them into smaller patches then formally ask for reviews on them. Keeping this around for reference as the point of reference I'll keep up to date.

[ldionne]

libcxxabi/src/private_typeinfo.cpp

617

Please introduce a macro that generically expresses that relative vtables are enabled, and explain what it is. You can then enable that macro only on __Fuchsia__. I'd like to avoid freely adding platform-specific #ifdefs in the code when it's easy to avoid.

[mcgrathr]

libcxxabi/src/private_typeinfo.cpp

617

I think the libcxxabi change should be separated from the compiler change entirely.
It will need more configuration issues resolved before it usefully lands.
Let's keep this change just for the pure compiler feature.

[leonardchan]

Updated such that this ABI is only usable on Fuchsia and if -fexperimental-fuchsia-relative-c++-abi-vtables is passed.

[phosek]

clang/include/clang/Basic/LangOptions.def

353

I think we should omit the Fuchsia bit and make it a generic, this feature should be usable by any target.

clang/include/clang/Driver/Options.td

1328

Ditto, I'd drop the fuchsia bit from these flags.

[leonardchan]

• Remove fuchsia pair from the argument and LangOpt.
• Make the virtual base offset and offset to top 32-bits to make the whole vtable 32-bit aligned.
• Introduce and check against the ItaniumVTableContext::VTableComponentLayout enum which will indicate that vtable components should be relative instead of pointers. Use this instead of making overridable virtual methods in ABI classes since this shouldn't be customized between ABIs.
• Update tests.

[rjmccall]

clang/lib/CodeGen/CGVTables.cpp

621

There's already an addRelativeOffset on ConstantArrayBuilder; is that insufficient for some reason? I think that, if v-table building were refactored so that the places that build components also add them to the v-table, we'd end up with a lot more flexibility for the ABIs. We needed a similar sort of change for pointer authentication, which we haven't upstreamed to LLVM yet, but which you can see here:

https://github.com/apple/llvm-project/blob/apple/master/clang/lib/CodeGen/CGVTables.cpp

[leonardchan]

clang/lib/CodeGen/CGVTables.cpp

621

I actually did not know about this method, but it does seem to boil down to the same arithmetic used here. Will update to see if I can use the existing builders instead.

[leonardchan]

clang/lib/CodeGen/CGVTables.cpp

621

Ah, so it seems addRelativeOffset operates differently than I thought. Initially I thought it just took the offset relative to the start of the array being built, but it actually seems to be relative to the component that would be added to the builder. This is slightly different from the current implementation where the offset is instead taken relative to the address point of the current vtable.

We could technically still achieve the desired effect of offsets in the vtable if we were to use addTaggedRelativeOffset and subtract a constantaly increasing offset as more virtual function components are added, although I'm not sure how much more benefit that would offer.

An alternative approach could also be to just use addRelativeOffset for offsets relative to the component slot and update instances we access the vtable to adjust for this new arithmetic. I think this would just transform instances of llvm.load.relative(%vtable, %func_offset) to llvm.load.relative(%vtable + %func_offset , 0), which seems differerent from how it was intended to be used, but technically might work.

[rjmccall]

clang/lib/CodeGen/CGVTables.cpp

621

Interesting. Yeah, it should be relatively straightforward to add a method that adds a pointer subtraction starting from a different base, and there's already a function for getting a constant that represents the address of the current position in the struct.

I take it you've taught LLVM that it can emit that subtraction with a normal relative-offset relocation by using an addend? That must've been exciting. Or, yeah, we can add in that addend in the frontend.

I think I see the expected benefit: it should generally save an instruction from the call sequence, at least on targets like x86 that lack pre-incrementing addressing modes. It does mean that the v-table entries can't be independently described — e.g. there's really no way you could write a C++ type that behaves like a v-table entry — but that's not too much of a loss.

[leonardchan]

Updated to use builders for constructing the vtable in "leaf" functions instead of returning a value and propagating it back up to a builder. Also extended ConstantAggregateBuilderBase with a method to add a relative offset to a specific position in the aggregate being constructed.

[rjmccall]

clang/include/clang/Basic/LangOptions.def

355

"Use an ABI-incompatible v-table layout that uses relative references"

clang/include/clang/CodeGen/ConstantInitBuilder.h

230 ↗

(On Diff #261894)

"relative to an element in this aggregate, identified by its index".

317 ↗

(On Diff #261894)

Hmm, you've borrowed the last sentence from getAddrOfCurrentPosition, but it actually doesn't make any sense (in either place). I think it would be better to say something like "The returned pointer will have type T*, where T is the given type. This type can differ from the type of the actual element."

clang/lib/CodeGen/CGVTables.cpp

636

Lots of typos

644

That's not what this block is doing.

I think it would make sense to build this stub in a helper function.

Can you just avoid making the stub entirely if the function is known to be defined in this translation unit (which will include all the internal-linkage cases, but also things like hidden linkonce_odr)?

647

private is a specific linkage that you're not actually using.

651

You're propagating *all* the attributes (which is good, but the comment should be clearer).

724

lastAddrPoint is a confusing name for this.

739

Relying on a capitalization difference for this is not a good idea for readability.

791

It's not a "destructor" equivalent, it's when the virtual function is defined as deleted.

797

Prefer llvm::ConstantPointerNull::get.

832

Can we make a helper function for this?

875

Please use the same local-variable capitalization conventions as the existing code, and please don't recompute getNumVTables() each time through the loop.

I agree that vtableIndex is a clearer name than i, but if you're going to rename locals for readability, please also rename thisIndex and nextIndex.

879

"Relative offsets should be relative to the v-table address point, which is the first entry after the RTTI pointer."

Can we just do this scan ahead of time to find the component index of the address point when we're using the relative ABI? It typically won't be a large scan, and it'll be a lot more obviously correct than what you're doing here. Also, I think what you're doing here is broken for the RTTI pointer.

You could also add a method on VTableLayout to get the address point by table index.

[leonardchan]

Evidently I left a lot of spelling mistakes and leftover comments. Cleaned them up!

This should address most of @rjmccall's comments except for calculating the vtable address points beforehand which I will add soon. Just posting what I have so far.

clang/lib/CodeGen/CGVTables.cpp

644

Done and added a test for it. Was planning to add this later as a followup but it turned out to be pretty simple to implement.

875

Updated naming in addVTableComponent and addRelativeComponent also.

[leonardchan]

Calculate the address points once beforehand such that we can get an address point from a vtable index.

Also updated to emit a stub still for complete destructor components in the vtable. The reason for this is because, with optimizations enabled, it's possible for dso_local complete destructors of a child class to be replaced by destructors of a parent class in the child's vtable, even if that parent destructor is not guaranteed to be dso_local. Updated the no-stub-when-dso-local.cpp test to reflect this.

[rjmccall]

Otherwise LGTM.

clang/lib/CodeGen/CGVTables.cpp

735

componentName seems to no longer be used meaningfully. in this function.

[ldionne]

[Github PR transition cleanup]

I think this work has landed as multiple separate patches, right? If so, can we please close this to clear up the review queue?

[leonardchan]

This was landed in various other smaller changes

clang/include/clang/Basic/LangOptions.def

 
 LANGOPT(FixedPoint, 1, 0, "fixed point types")
 LANGOPT(PaddingOnUnsignedFixedPoint, 1, 0,
         "unsigned fixed point types having one extra padding bit")
 
 LANGOPT(RegisterStaticDestructors, 1, 1, "Register C++ static destructors")
 
 COMPATIBLE_VALUE_LANGOPT(MaxTokens, 32, 0, "Max number of tokens per TU or 0")
+LANGOPT(FuchsiaRelativeCXXABIVTables, 1, 0,
+        "Whether to use clang's relative C++ ABI "
+        "for classes with vtables on Fuchsia")
 
 #undef LANGOPT
 #undef COMPATIBLE_LANGOPT
 #undef BENIGN_LANGOPT
 #undef ENUM_LANGOPT
 #undef COMPATIBLE_ENUM_LANGOPT
 #undef BENIGN_ENUM_LANGOPT
 #undef VALUE_LANGOPT
 #undef COMPATIBLE_VALUE_LANGOPT
 #undef BENIGN_VALUE_LANGOPT

clang/include/clang/Driver/Options.td

 
 def ffine_grained_bitfield_accesses : Flag<["-"],
   "ffine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Use separate accesses for consecutive bitfield runs with legal widths and alignments.">;
 def fno_fine_grained_bitfield_accesses : Flag<["-"],
   "fno-fine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Use large-integer access for consecutive bitfield runs.">;
 
+def fexperimental_fuchsia_relative_cxx_abi_vtables : Flag<["-"], "fexperimental-fuchsia-relative-c++-abi-vtables">,
+  Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Use the experimental C++ class ABI for classes with virtual tables on Fuchsia">;
+def fno_experimental_fuchsia_relative_cxx_abi_vtables : Flag<["-"], "fno-experimental-relative-c++-abi-vtables">,
+  Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Do not use the experimental C++ class ABI for classes with virtual tables on Fuchsia">;
+
 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">, Flags<[CC1Option]>;
 def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>,
   Alias<flax_vector_conversions_EQ>, AliasArgs<["integer"]>;
 def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>;
 def fapple_link_rtlib : Flag<["-"], "fapple-link-rtlib">, Group<f_Group>,
   HelpText<"Force linking the clang builtins runtime library">;

clang/lib/AST/VTableBuilder.cpp

CharUnits VCallAndVBaseOffsetBuilder::getCurrentOffsetOffset() const {
   // 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());
 
   CharUnits PointerWidth =
     Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
   CharUnits OffsetOffset = PointerWidth * OffsetIndex;
+
+  if (Context.getLangOpts().FuchsiaRelativeCXXABIVTables) {
+    // Add 4 bytes since under the relative vtable ABI, the RTTI info component
+    // is also a 4 byte offset.
+    OffsetOffset += CharUnits::fromQuantity(4);
+  }
+
   return OffsetOffset;
 }
 
 void VCallAndVBaseOffsetBuilder::AddVCallOffsets(BaseSubobject Base,
                                                  CharUnits VBaseOffset) {
   const CXXRecordDecl *RD = Base.getBase();
   const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
 

clang/lib/CodeGen/CGCXXABI.h

EmitMemberPointerComparison(CodeGenFunction &CGF,
                               bool Inequality);
 
   /// Determine if a member pointer is non-null.  Returns an i1.
   virtual llvm::Value *
   EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
                              llvm::Value *MemPtr,
                              const MemberPointerType *MPT);
 
+  /// Create and set the initializer for the vtable.
+  virtual void SetVTableInitializer(CodeGenVTables &CGVT,
+                                    llvm::GlobalVariable *VTable,
+                                    const VTableLayout &VTLayout,
+                                    llvm::Constant *RTTI) = 0;
+
 protected:
   /// A utility method for computing the offset required for the given
   /// base-to-derived or derived-to-base member-pointer conversion.
   /// Does not handle virtual conversions (in case we ever fully
   /// support an ABI that allows this).  Returns null if no adjustment
   /// is required.
   llvm::Constant *getMemberPointerAdjustment(const CastExpr *E);
 
virtual void EmitReturnFromThunk(CodeGenFunction &CGF,
                                    RValue RV, QualType ResultType);
 
   virtual size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
                                       FunctionArgList &Args) const = 0;
 
   /// Gets the offsets of all the virtual base pointers in a given class.
   virtual std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD);
 
-  /// Gets the pure virtual member call function.
+  /// Gets the pure virtual member call.
   virtual StringRef GetPureVirtualCallName() = 0;
+  virtual llvm::Constant *GetPureVirtualFunction();
 
-  /// Gets the deleted virtual member call name.
+  /// Gets the deleted virtual member call.
   virtual StringRef GetDeletedVirtualCallName() = 0;
+  virtual llvm::Constant *GetDeletedVirtualFunction();
+
+  llvm::Constant *getSpecialVirtualFn(StringRef name);
 
   /**************************** Array cookies ******************************/
 
   /// Returns the extra size required in order to store the array
   /// cookie for the given new-expression.  May return 0 to indicate that no
   /// array cookie is required.
   ///
   /// Several cases are filtered out before this method is called:

clang/lib/CodeGen/CGCXXABI.cpp

Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
                                         llvm::Value *NumElements,
                                         const CXXNewExpr *expr,
                                         QualType ElementType) {
   // Should never be called.
   ErrorUnsupportedABI(CGF, "array cookie initialization");
   return Address::invalid();
 }
 
+llvm::Constant *CGCXXABI::getSpecialVirtualFn(StringRef name) {
+  // For NVPTX devices in OpenMP emit special functon as null pointers,
+  // otherwise linking ends up with unresolved references.
+  if (CGM.getLangOpts().OpenMP && CGM.getLangOpts().OpenMPIsDevice &&
+      CGM.getTriple().isNVPTX())
+    return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
+  llvm::FunctionType *fnTy =
+      llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
+  llvm::Constant *fn =
+      cast<llvm::Constant>(CGM.CreateRuntimeFunction(fnTy, name).getCallee());
+  if (auto f = dyn_cast<llvm::Function>(fn))
+    f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+  return llvm::ConstantExpr::getBitCast(fn, CGM.Int8PtrTy);
+}
+
+llvm::Constant *CGCXXABI::GetPureVirtualFunction() {
+  return getSpecialVirtualFn(GetPureVirtualCallName());
+}
+
+llvm::Constant *CGCXXABI::GetDeletedVirtualFunction() {
+  return getSpecialVirtualFn(GetDeletedVirtualCallName());
+}
+
 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
                                    QualType elementType) {
   // If the class's usual deallocation function takes two arguments,
   // it needs a cookie.
   if (expr->doesUsualArrayDeleteWantSize())
     return true;
 
   return elementType.isDestructedType();

clang/lib/CodeGen/CGVTables.h

llvm::Constant *maybeEmitThunk(GlobalDecl GD,
                                  const ThunkInfo &ThunkAdjustments,
                                  bool ForVTable);
 
   void addVTableComponent(ConstantArrayBuilder &builder,
                           const VTableLayout &layout, unsigned idx,
                           llvm::Constant *rtti,
                           unsigned &nextVTableThunkIndex);
 
+  /// Get the constant to be added to a VTable.
+  llvm::Constant *getVTableComponent(const VTableLayout &layout,
+                                     unsigned componentIdx,
+                                     llvm::Constant *rtti,
+                                     unsigned &nextVTableThunkIndex);
+
+  /// Make a function pointer into a relative integer when using the relative
+  /// vtables ABI.
+  llvm::Constant *makeComponentRelative(llvm::Constant *C,
+                                        llvm::GlobalVariable *VTable,
+                                        unsigned vtableIdx,
+                                        unsigned lastAddrPoint) const;
+
 public:
   /// Add vtable components for the given vtable layout to the given
   /// global initializer.
   void createVTableInitializer(ConstantStructBuilder &builder,
                                const VTableLayout &layout,
                                llvm::Constant *rtti);
 
+  void createRelativeVTableInitializer(ConstantStructBuilder &builder,
+                                       llvm::GlobalVariable *VTable,
+                                       const VTableLayout &layout,
+                                       llvm::Constant *rtti);
+
   CodeGenVTables(CodeGenModule &CGM);
 
   ItaniumVTableContext &getItaniumVTableContext() {
     return *cast<ItaniumVTableContext>(VTContext);
   }
 
   MicrosoftVTableContext &getMicrosoftVTableContext() {
     return *cast<MicrosoftVTableContext>(VTContext);

clang/lib/CodeGen/CGVTables.cpp

void CodeGenVTables::EmitThunks(GlobalDecl GD) {
 
   if (!ThunkInfoVector)
     return;
 
   for (const ThunkInfo& Thunk : *ThunkInfoVector)
     maybeEmitThunk(GD, Thunk, /*ForVTable=*/false);
 }
 
+llvm::Constant *CodeGenVTables::makeComponentRelative(
+    llvm::Constant *C, llvm::GlobalVariable *VTable, unsigned vtableIdx,
+    unsigned lastAddrPoint) const {
+  // No need to get the offset of a nullptr.
+  if (C->isNullValue())
+    return llvm::ConstantInt::get(CGM.Int32Ty, 0);
+
+  llvm::Type *Int32Ty = CGM.Int32Ty;
+  llvm::Type *PtrDiffTy =
+      CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
+  llvm::Type *VTableTy = VTable->getValueType();
+
+  llvm::Constant *gep = llvm::ConstantExpr::getGetElementPtr(
+      VTableTy, VTable,
+      llvm::ArrayRef<llvm::Constant *>{
+          llvm::ConstantInt::get(Int32Ty, 0),
+          llvm::ConstantInt::get(Int32Ty, vtableIdx),
+          llvm::ConstantInt::get(Int32Ty, lastAddrPoint)});
+
+  llvm::Constant *AddrPointInt =
+      llvm::ConstantExpr::getPtrToInt(gep, PtrDiffTy);
+  llvm::Constant *Target;
+
+  auto *GlobalVal = cast<llvm::GlobalValue>(C->stripPointerCastsAndAliases());
+  llvm::Module &M = CGM.getModule();
+  llvm::SmallString<16> Name(GlobalVal->getName());
+
+  // We don't want to copy the linkage of the vtable exactly because we still
+  // want the stub/proxy to be emitted for properlly caluclating the offset.
+  // Examples where there would bo no symbol emitted are available_externally
+  // and private linkages.
+  auto StubLinkage = VTable->hasLocalLinkage()
+                         ? llvm::GlobalValue::InternalLinkage
+                         : llvm::GlobalValue::ExternalLinkage;
+
+  if (auto *Func = dyn_cast<llvm::Function>(GlobalVal)) {
+    llvm::SmallString<16> StubName(Name);
+    StubName.append(".stub");
+
+    // Take offset from stub to the vtable component.
+    llvm::Function *HiddenFunc = M.getFunction(StubName);
+    if (!HiddenFunc) {
+      // Make the stub private.
+      llvm::Function *Stub = llvm::Function::Create(Func->getFunctionType(),
+                                                    StubLinkage, StubName, M);
+
+      // Propogate byval attributes.
+      Stub->setAttributes(Func->getAttributes());
+
+      Stub->setDSOLocal(true);
+      Stub->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+      if (!llvm::GlobalValue::isLocalLinkage(StubLinkage)) {
+        Stub->setVisibility(llvm::GlobalValue::HiddenVisibility);
+        Stub->setComdat(M.getOrInsertComdat(StubName));
+      }
+
+      // Fill the stub with a tail call that will be optimized.
+      llvm::BasicBlock *BB =
+          llvm::BasicBlock::Create(M.getContext(), "entry", Stub);
+      llvm::IRBuilder<> Builder(BB);
+      llvm::SmallVector<llvm::Value *, 8> Args;
+      for (auto &Arg : Stub->args())
+        Args.push_back(&Arg);
+      llvm::CallInst *Call = Builder.CreateCall(Func, Args);
+      Call->setAttributes(Func->getAttributes());
+      Call->setTailCall();
+      if (Call->getType()->isVoidTy())
+        Builder.CreateRetVoid();
+      else
+        Builder.CreateRet(Call);
+
+      HiddenFunc = Stub;
+    }
+    Target = HiddenFunc;
+  } else {
+    llvm::SmallString<16> RTTIProxyName(Name);
+    RTTIProxyName.append(".rtti_proxy");
+
+    // Component is RTTI. Create a private variable that points to this RTTI
+    // struct and take the offset of that.
+    llvm::GlobalVariable *GV = M.getNamedGlobal(RTTIProxyName);
+    if (!GV) {
+      GV = new llvm::GlobalVariable(CGM.getModule(), GlobalVal->getType(),
+                                    /*isConstant=*/true, StubLinkage, GlobalVal,
+                                    RTTIProxyName);
+      GV->setDSOLocal(true);
+      GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+      if (!llvm::GlobalValue::isLocalLinkage(StubLinkage)) {
+        GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
+        GV->setComdat(M.getOrInsertComdat(RTTIProxyName));
+      }
+    }
+    Target = GV;
+  }
+
+  llvm::Constant *ptrToInt = llvm::ConstantExpr::getPtrToInt(Target, PtrDiffTy);
+  return llvm::ConstantExpr::getIntegerCast(
+      llvm::ConstantExpr::getSub(ptrToInt, AddrPointInt), Int32Ty,
+      /*isSigned=*/true);
+}
+
 void CodeGenVTables::addVTableComponent(
     ConstantArrayBuilder &builder, const VTableLayout &layout,
     unsigned idx, llvm::Constant *rtti, unsigned &nextVTableThunkIndex) {
-  auto &component = layout.vtable_components()[idx];
+  builder.add(getVTableComponent(layout, idx, rtti, nextVTableThunkIndex));
+}
+
+llvm::Constant *
+CodeGenVTables::getVTableComponent(const VTableLayout &layout,
+                                   unsigned componentIdx, llvm::Constant *rtti,
+                                   unsigned &nextVTableThunkIndex) {
+  auto &component = layout.vtable_components()[componentIdx];
 
   auto addOffsetConstant = [&](CharUnits offset) {
-    builder.add(llvm::ConstantExpr::getIntToPtr(
+    return llvm::ConstantExpr::getIntToPtr(
         llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity()),
-        CGM.Int8PtrTy));
+        CGM.Int8PtrTy);
   };
 
   switch (component.getKind()) {
   case VTableComponent::CK_VCallOffset:
     return addOffsetConstant(component.getVCallOffset());
 
   case VTableComponent::CK_VBaseOffset:
     return addOffsetConstant(component.getVBaseOffset());
 
   case VTableComponent::CK_OffsetToTop:
     return addOffsetConstant(component.getOffsetToTop());
 
   case VTableComponent::CK_RTTI:
-    return builder.add(llvm::ConstantExpr::getBitCast(rtti, CGM.Int8PtrTy));
+    return llvm::ConstantExpr::getBitCast(rtti, CGM.Int8PtrTy);
 
   case VTableComponent::CK_FunctionPointer:
   case VTableComponent::CK_CompleteDtorPointer:
   case VTableComponent::CK_DeletingDtorPointer: {
     GlobalDecl GD;
 
     // Get the right global decl.
     switch (component.getKind()) {
if (CGM.getLangOpts().CUDA) {
       const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
       // OK on device side: functions w/ __device__ attribute
       // OK on host side: anything except __device__-only functions.
       bool CanEmitMethod =
           CGM.getLangOpts().CUDAIsDevice
               ? MD->hasAttr<CUDADeviceAttr>()
               : (MD->hasAttr<CUDAHostAttr>() || !MD->hasAttr<CUDADeviceAttr>());
       if (!CanEmitMethod)
-        return builder.addNullPointer(CGM.Int8PtrTy);
+        return llvm::ConstantExpr::getNullValue(CGM.Int8PtrTy);
       // Method is acceptable, continue processing as usual.
     }
 
-    auto getSpecialVirtualFn = [&](StringRef name) -> llvm::Constant * {
-      // For NVPTX devices in OpenMP emit special functon as null pointers,
-      // otherwise linking ends up with unresolved references.
-      if (CGM.getLangOpts().OpenMP && CGM.getLangOpts().OpenMPIsDevice &&
-          CGM.getTriple().isNVPTX())
-        return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
-      llvm::FunctionType *fnTy =
-          llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
-      llvm::Constant *fn = cast<llvm::Constant>(
-          CGM.CreateRuntimeFunction(fnTy, name).getCallee());
-      if (auto f = dyn_cast<llvm::Function>(fn))
-        f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
-      return llvm::ConstantExpr::getBitCast(fn, CGM.Int8PtrTy);
-    };
-
     llvm::Constant *fnPtr;
 
     // Pure virtual member functions.
     if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
       if (!PureVirtualFn)
-        PureVirtualFn =
-          getSpecialVirtualFn(CGM.getCXXABI().GetPureVirtualCallName());
+        PureVirtualFn = CGM.getCXXABI().GetPureVirtualFunction();
       fnPtr = PureVirtualFn;
 
     // Deleted virtual member functions.
     } else if (cast<CXXMethodDecl>(GD.getDecl())->isDeleted()) {
       if (!DeletedVirtualFn)
-        DeletedVirtualFn =
-          getSpecialVirtualFn(CGM.getCXXABI().GetDeletedVirtualCallName());
+        DeletedVirtualFn = CGM.getCXXABI().GetDeletedVirtualFunction();
       fnPtr = DeletedVirtualFn;
 
     // Thunks.
     } else if (nextVTableThunkIndex < layout.vtable_thunks().size() &&
-               layout.vtable_thunks()[nextVTableThunkIndex].first == idx) {
+               layout.vtable_thunks()[nextVTableThunkIndex].first ==
+                   componentIdx) {
       auto &thunkInfo = layout.vtable_thunks()[nextVTableThunkIndex].second;
 
       nextVTableThunkIndex++;
       fnPtr = maybeEmitThunk(GD, thunkInfo, /*ForVTable=*/true);
 
     // Otherwise we can use the method definition directly.
     } else {
       llvm::Type *fnTy = CGM.getTypes().GetFunctionTypeForVTable(GD);
       fnPtr = CGM.GetAddrOfFunction(GD, fnTy, /*ForVTable=*/true);
     }
 
-    fnPtr = llvm::ConstantExpr::getBitCast(fnPtr, CGM.Int8PtrTy);
-    builder.add(fnPtr);
-    return;
+    return llvm::ConstantExpr::getBitCast(fnPtr, CGM.Int8PtrTy);
   }
 
   case VTableComponent::CK_UnusedFunctionPointer:
-    return builder.addNullPointer(CGM.Int8PtrTy);
+    return llvm::ConstantExpr::getNullValue(CGM.Int8PtrTy);
   }
 
   llvm_unreachable("Unexpected vtable component kind");
 }
 
 llvm::Type *CodeGenVTables::getVTableType(const VTableLayout &layout) {
-  SmallVector<llvm::Type *, 4> tys;
+  SmallVector<llvm::Type *, 4> types;
   for (unsigned i = 0, e = layout.getNumVTables(); i != e; ++i) {
-    tys.push_back(llvm::ArrayType::get(CGM.Int8PtrTy, layout.getVTableSize(i)));
+    if (!CGM.getLangOpts().FuchsiaRelativeCXXABIVTables) {
+      types.push_back(
+          llvm::ArrayType::get(CGM.Int8PtrTy, layout.getVTableSize(i)));
+    } else {
+      SmallVector<llvm::Type *, 4> innerTypes;
+      size_t thisIndex = layout.getVTableOffset(i);
+      size_t nextIndex = thisIndex + layout.getVTableSize(i);
+      for (unsigned componentIdx = thisIndex; componentIdx != nextIndex;
+           ++componentIdx) {
+        auto &component = layout.vtable_components()[componentIdx];
+        if (component.isFunctionPointerKind()) {
+          innerTypes.push_back(CGM.Int32Ty);
+        } else if (component.isRTTIKind()) {
+          // NOTE: A bunch of RTTI depends on expecting that the offset to top,
+          // and RTTI struct are i8*s, or at least 64 bits (see __dynamic_cast
+          // in libcxx), so when we decide
+          // to tackle RTTI usage, we will either need to change a bunch of rtti
+          // functions, or keep this as an i8* (or an i64, or an i32 with
+          // padding) then add the PLT64 to lld for x86 since it currently
+          // doesn't seem to be handled yet.
+          innerTypes.push_back(CGM.Int32Ty);
+        } else {
+          innerTypes.push_back(CGM.Int8PtrTy);
+        }
+      }
+      types.push_back(llvm::StructType::get(CGM.getLLVMContext(), innerTypes));
+    }
   }
 
-  return llvm::StructType::get(CGM.getLLVMContext(), tys);
+  return llvm::StructType::get(CGM.getLLVMContext(), types);
 }
 
 void CodeGenVTables::createVTableInitializer(ConstantStructBuilder &builder,
                                              const VTableLayout &layout,
                                              llvm::Constant *rtti) {
   unsigned nextVTableThunkIndex = 0;
   for (unsigned i = 0, e = layout.getNumVTables(); i != e; ++i) {
     auto vtableElem = builder.beginArray(CGM.Int8PtrTy);
     size_t thisIndex = layout.getVTableOffset(i);
     size_t nextIndex = thisIndex + layout.getVTableSize(i);
-    for (unsigned i = thisIndex; i != nextIndex; ++i) {
+    for (unsigned i = thisIndex; i != nextIndex; ++i)
       addVTableComponent(vtableElem, layout, i, rtti, nextVTableThunkIndex);
-    }
+    vtableElem.finishAndAddTo(builder);
+}
+
+void CodeGenVTables::createRelativeVTableInitializer(
+    ConstantStructBuilder &builder, llvm::GlobalVariable *VTable,
+    const VTableLayout &VTLayout, llvm::Constant *RTTI) {
+  unsigned nextVTableThunkIndex = 0;
+  for (unsigned vtableIdx = 0; vtableIdx != VTLayout.getNumVTables();
+       ++vtableIdx) {
+    auto vtableElem = builder.beginStruct();
+
+    unsigned lastAddrPoint = 0;
+    size_t thisIndex = VTLayout.getVTableOffset(vtableIdx);
+    size_t nextIndex = thisIndex + VTLayout.getVTableSize(vtableIdx);
+    for (unsigned componentIdx = thisIndex; componentIdx != nextIndex;
+         ++componentIdx) {
+      // We want to point to the first function in the vtable. This will come
+      // after the RTTI component, so we can just check if the previous
+      // component was RTTI.
+      // FIXME: Need a better way of identifying address points.
+      if (componentIdx > 0 &&
+          VTLayout.vtable_components()[componentIdx - 1].isRTTIKind())
+        lastAddrPoint = componentIdx;
+
+      llvm::Constant *component = getVTableComponent(
+          VTLayout, componentIdx, RTTI, nextVTableThunkIndex);
+
+      auto &layoutComponent = VTLayout.vtable_components()[componentIdx];
+      if (layoutComponent.isFunctionPointerKind()) {
+        component = makeComponentRelative(component, VTable, vtableIdx,
+                                          lastAddrPoint - thisIndex);
+      } else if (layoutComponent.isRTTIKind()) {
+        component = makeComponentRelative(component, VTable, vtableIdx, 2);
+      }
+
+      vtableElem.add(component);
+    }
+
     vtableElem.finishAndAddTo(builder);
   }
 }
 
-llvm::GlobalVariable *
-CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
-                                      const BaseSubobject &Base,
-                                      bool BaseIsVirtual,
-                                   llvm::GlobalVariable::LinkageTypes Linkage,
-                                      VTableAddressPointsMapTy& AddressPoints) {
+llvm::GlobalVariable *CodeGenVTables::GenerateConstructionVTable(
+    const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual,
+    VTableAddressPointsMapTy &AddressPoints) {
   if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
     DI->completeClassData(Base.getBase());
 
   std::unique_ptr<VTableLayout> VTLayout(
       getItaniumVTableContext().createConstructionVTableLayout(
           Base.getBase(), Base.getBaseOffset(), BaseIsVirtual, RD));
 
   // Add the address points.
llvm::GlobalVariable *CodeGenVTables::GenerateConstructionVTable(
 
   // V-tables are always unnamed_addr.
   VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 
   llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(
       CGM.getContext().getTagDeclType(Base.getBase()));
 
   // Create and set the initializer.
-  ConstantInitBuilder builder(CGM);
-  auto components = builder.beginStruct();
-  createVTableInitializer(components, *VTLayout, RTTI);
-  components.finishAndSetAsInitializer(VTable);
+  CGM.getCXXABI().SetVTableInitializer(*this, VTable, *VTLayout, RTTI);
 
   // Set properties only after the initializer has been set to ensure that the
   // GV is treated as definition and not declaration.
   assert(!VTable->isDeclaration() && "Shouldn't set properties on declaration");
   CGM.setGVProperties(VTable, RD);
 
   CGM.EmitVTableTypeMetadata(RD, VTable, *VTLayout.get());
 

clang/lib/CodeGen/ItaniumCXXABI.cpp

public:
   void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
                           CXXDtorType Type, bool ForVirtualBase,
                           bool Delegating, Address This,
                           QualType ThisTy) override;
 
   void emitVTableDefinitions(CodeGenVTables &CGVT,
                              const CXXRecordDecl *RD) override;
 
+  virtual void SetVTableInitializer(CodeGenVTables &CGVT,
+                                    llvm::GlobalVariable *VTable,
+                                    const VTableLayout &VTLayout,
+                                    llvm::Constant *RTTI) override {
+    ConstantInitBuilder builder(CGM);
+    auto components = builder.beginStruct();
+    CGVT.createVTableInitializer(components, VTLayout, RTTI);
+    components.finishAndSetAsInitializer(VTable);
+  }
+
   bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
                                            CodeGenFunction::VPtr Vptr) override;
 
   bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {
     return true;
   }
 
   llvm::Constant *
public:
 
   llvm::Constant *
   getVTableAddressPointForConstExpr(BaseSubobject Base,
                                     const CXXRecordDecl *VTableClass) override;
 
   llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
                                         CharUnits VPtrOffset) override;
 
+  virtual llvm::Constant *getVTableAddressPointForTypeInfo(llvm::Constant *VTable) const;
+
   CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
                                      Address This, llvm::Type *Ty,
                                      SourceLocation Loc) override;
 
   llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
                                          const CXXDestructorDecl *Dtor,
                                          CXXDtorType DtorType, Address This,
                                          DeleteOrMemberCallExpr E) override;
public:
 
   /**************************** RTTI Uniqueness ******************************/
 
 protected:
   /// Returns true if the ABI requires RTTI type_info objects to be unique
   /// across a program.
   virtual bool shouldRTTIBeUnique() const { return true; }
 
+  virtual llvm::Value *GetVirtualFunctionFromVTable(CodeGenFunction &CGF,
+                                                    const CXXRecordDecl *RD,
+                                                    llvm::Value *VTable,
+                                                    uint64_t VTableIndex,
+                                                    llvm::Type *Ty);
+
+  virtual llvm::Value *
+  GetPointerToMemberVirtualFunction(CodeGenFunction &CGF, llvm::Value *VTable,
+                                    llvm::Value *VTableOffset,
+                                    llvm::FunctionType *FTy) {
+    llvm::Value *VFPAddr = CGF.Builder.CreateGEP(VTable, VTableOffset);
+    VFPAddr =
+        CGF.Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo());
+    return CGF.Builder.CreateAlignedLoad(VFPAddr, CGF.getPointerAlign(),
+                                         "memptr.virtualfn");
+  }
+
+  virtual uint64_t getVTableOffset(uint64_t Index) {
+    const ASTContext &Context = getContext();
+    CharUnits PointerWidth =
+        Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
+    return Index * PointerWidth.getQuantity();
+  }
+
 public:
   /// What sort of unique-RTTI behavior should we use?
   enum RTTIUniquenessKind {
     /// We are guaranteeing, or need to guarantee, that the RTTI string
     /// is unique.
     RUK_Unique,
 
     /// We are not guaranteeing uniqueness for the RTTI string, so we
public:
   bool shouldRTTIBeUnique() const override { return false; }
 };
 
 class FuchsiaCXXABI final : public ItaniumCXXABI {
 public:
   explicit FuchsiaCXXABI(CodeGen::CodeGenModule &CGM)
       : ItaniumCXXABI(CGM) {}
 
+  void SetVTableInitializer(CodeGenVTables &CGVT, llvm::GlobalVariable *VTable,
+                            const VTableLayout &VTLayout,
+                            llvm::Constant *RTTI) override {
+    ConstantInitBuilder builder(CGM);
+    auto components = builder.beginStruct();
+    CGVT.createRelativeVTableInitializer(components, VTable, VTLayout, RTTI);
+    components.finishAndSetAsInitializer(VTable);
+  }
+
+  llvm::Constant *GetPureVirtualFunction() override {
+    // FIXME: There is currently an issue (PR43094) where
+    // when merging comdat groups, lld can select a local symbol as the
+    // signature symbol even though it cannot be accessed outside that
+    // symbol's module. A result of this ABI would make __cxa_pure_virtual
+    // (and it's destructor equivalent) local symbols, and depending on
+    // link order, the comdat groups would resolve to the one with the
+    // local symbol. As a temporary solution, since we shouldn't be
+    // calling these functions in the first place, fill these components
+    // with zero.
+    return llvm::Constant::getNullValue(CGM.Int8PtrTy);
+  }
+
+  llvm::Constant *GetDeletedVirtualFunction() override {
+    return llvm::Constant::getNullValue(CGM.Int8PtrTy);
+  }
+
+  llvm::Value *EmitTypeid(CodeGenFunction &CGF,
+                          QualType SrcRecordTy,
+                          Address ThisPtr,
+                          llvm::Type *StdTypeInfoPtrTy) override {
+    auto *ClassDecl =
+        cast<CXXRecordDecl>(SrcRecordTy->castAs<RecordType>()->getDecl());
+    llvm::Value *Value =
+        CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo(), ClassDecl);
+
+    // Load the type info.
+    //Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
+    //return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign());
+    Value = CGF.Builder.CreateBitCast(Value, CGM.Int8PtrTy);
+    Value = CGF.Builder.CreateCall(
+        CGM.getIntrinsic(llvm::Intrinsic::load_relative, {CGM.Int32Ty}),
+        {Value, llvm::ConstantInt::get(CGM.Int32Ty, -4)});
+
+    // Dereference again since this is a proxy we accessed.
+    Value = CGF.Builder.CreateBitCast(Value, StdTypeInfoPtrTy->getPointerTo());
+    return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign());
+  }
+
+  llvm::Constant *getVTableAddressPointForTypeInfo(llvm::Constant *VTable) const override {
+    // The vtable address point is 12 bytes after its start:
+    // 8 for the offset to top + 4 for the relative offset to rtti
+    llvm::Constant *Twelve = llvm::ConstantInt::get(CGM.Int32Ty, 12);
+    VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
+    return llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8Ty, VTable, Twelve);
+  }
+
+protected:
+  llvm::Value *GetVirtualFunctionFromVTable(CodeGenFunction &CGF,
+                                            const CXXRecordDecl *RD,
+                                            llvm::Value *VTable,
+                                            uint64_t VTableIndex,
+                                            llvm::Type *Ty) override {
+    VTable = CGF.Builder.CreateBitCast(VTable, CGM.Int8PtrTy);
+    llvm::Value *Load = CGF.Builder.CreateCall(
+        CGM.getIntrinsic(llvm::Intrinsic::load_relative, {CGM.Int32Ty}),
+        {VTable, llvm::ConstantInt::get(CGM.Int32Ty, 4 * VTableIndex)});
+    return CGF.Builder.CreateBitCast(Load, Ty->getPointerTo());
+  }
+
+  llvm::Value *
+  GetPointerToMemberVirtualFunction(CodeGenFunction &CGF, llvm::Value *VTable,
+                                    llvm::Value *VTableOffset,
+                                    llvm::FunctionType *FTy) override {
+    llvm::Value *VirtualFn =
+        CGF.Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::load_relative,
+                                                {VTableOffset->getType()}),
+                               {VTable, VTableOffset});
+    return CGF.Builder.CreateBitCast(VirtualFn, FTy->getPointerTo());
+  }
+
+  uint64_t getVTableOffset(uint64_t Index) override {
+    // Multiply by 4-byte relative offsets.
+    return Index * 4;
+  }
+
 private:
   bool HasThisReturn(GlobalDecl GD) const override {
     return isa<CXXConstructorDecl>(GD.getDecl()) ||
            (isa<CXXDestructorDecl>(GD.getDecl()) &&
             GD.getDtorType() != Dtor_Deleting);
   }
 };
 
llvm::Value *VirtualFn = nullptr;
     if (ShouldEmitCFICheck || ShouldEmitVFEInfo || ShouldEmitWPDInfo) {
       // If doing CFI, VFE or WPD, we will need the metadata node to check
       // against.
       llvm::Metadata *MD =
           CGM.CreateMetadataIdentifierForVirtualMemPtrType(QualType(MPT, 0));
       TypeId = llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
     }
 
+    if (ShouldEmitVFEInfo) {
       llvm::Value *VFPAddr = Builder.CreateGEP(VTable, VTableOffset);
 
-    if (ShouldEmitVFEInfo) {
       // If doing VFE, load from the vtable with a type.checked.load intrinsic
       // call. Note that we use the GEP to calculate the address to load from
       // and pass 0 as the offset to the intrinsic. This is because every
       // vtable slot of the correct type is marked with matching metadata, and
       // we know that the load must be from one of these slots.
       llvm::Value *CheckedLoad = Builder.CreateCall(
           CGM.getIntrinsic(llvm::Intrinsic::type_checked_load),
           {VFPAddr, llvm::ConstantInt::get(CGM.Int32Ty, 0), TypeId});
       CheckResult = Builder.CreateExtractValue(CheckedLoad, 1);
       VirtualFn = Builder.CreateExtractValue(CheckedLoad, 0);
       VirtualFn = Builder.CreateBitCast(VirtualFn, FTy->getPointerTo(),
                                         "memptr.virtualfn");
     } else {
       // When not doing VFE, emit a normal load, as it allows more
       // optimisations than type.checked.load.
       if (ShouldEmitCFICheck || ShouldEmitWPDInfo) {
+        llvm::Value *VFPAddr = Builder.CreateGEP(VTable, VTableOffset);
         CheckResult = Builder.CreateCall(
             CGM.getIntrinsic(llvm::Intrinsic::type_test),
             {Builder.CreateBitCast(VFPAddr, CGF.Int8PtrTy), TypeId});
       }
-      VFPAddr =
-          Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo());
-      VirtualFn = Builder.CreateAlignedLoad(VFPAddr, CGF.getPointerAlign(),
-                                            "memptr.virtualfn");
+
+      VirtualFn =
+          GetPointerToMemberVirtualFunction(CGF, VTable, VTableOffset, FTy);
     }
     assert(VirtualFn && "Virtual fuction pointer not created!");
     assert((!ShouldEmitCFICheck || !ShouldEmitVFEInfo || !ShouldEmitWPDInfo ||
             CheckResult) &&
            "Check result required but not created!");
 
     if (ShouldEmitCFICheck) {
       // If doing CFI, emit the check.
llvm::Constant *ItaniumCXXABI::BuildMemberPointer(const CXXMethodDecl *MD,
   assert(MD->isInstance() && "Member function must not be static!");
 
   CodeGenTypes &Types = CGM.getTypes();
 
   // Get the function pointer (or index if this is a virtual function).
   llvm::Constant *MemPtr[2];
   if (MD->isVirtual()) {
     uint64_t Index = CGM.getItaniumVTableContext().getMethodVTableIndex(MD);
-
-    const ASTContext &Context = getContext();
-    CharUnits PointerWidth =
-      Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
-    uint64_t VTableOffset = (Index * PointerWidth.getQuantity());
+    uint64_t VTableOffset = getVTableOffset(Index);
 
     if (UseARMMethodPtrABI) {
       // ARM C++ ABI 3.2.1:
       //   This ABI specifies that adj contains twice the this
       //   adjustment, plus 1 if the member function is virtual. The
       //   least significant bit of adj then makes exactly the same
       //   discrimination as the least significant bit of ptr does for
       //   Itanium.
if (VTable->hasInitializer())
     return;
 
   ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
   const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
   llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
   llvm::Constant *RTTI =
       CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));
 
-  // Create and set the initializer.
-  ConstantInitBuilder Builder(CGM);
-  auto Components = Builder.beginStruct();
-  CGVT.createVTableInitializer(Components, VTLayout, RTTI);
-  Components.finishAndSetAsInitializer(VTable);
-
   // Set the correct linkage.
   VTable->setLinkage(Linkage);
 
+  // Create and set the initializer.
+  SetVTableInitializer(CGVT, VTable, VTLayout, RTTI);
+
   if (CGM.supportsCOMDAT() && VTable->isWeakForLinker())
     VTable->setComdat(CGM.getModule().getOrInsertComdat(VTable->getName()));
 
   // Set the right visibility.
   CGM.setGVProperties(VTable, RD);
 
   // If this is the magic class __cxxabiv1::__fundamental_type_info,
   // we will emit the typeinfo for the fundamental types. This is the
VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
       getContext().toCharUnitsFromBits(PAlign).getQuantity());
   VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 
   CGM.setGVProperties(VTable, RD);
 
   return VTable;
 }
 
+llvm::Constant *ItaniumCXXABI::getVTableAddressPointForTypeInfo(llvm::Constant *VTable) const {
+  llvm::Type *PtrDiffTy =
+    CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
+
+  // The vtable address point is 2.
+  llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
+  VTable =
+      llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
+  return llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
+}
+
+llvm::Value *ItaniumCXXABI::GetVirtualFunctionFromVTable(
+    CodeGenFunction &CGF, const CXXRecordDecl *RD, llvm::Value *VTable,
+    uint64_t VTableIndex, llvm::Type *Ty) {
+  VTable =
+      CGF.Builder.CreateBitCast(VTable, Ty->getPointerTo()->getPointerTo());
+  llvm::Value *VTableSlotPtr =
+      CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
+  return CGF.Builder.CreateAlignedLoad(VTableSlotPtr, CGF.getPointerAlign());
+}
+
 CGCallee ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
                                                   GlobalDecl GD,
                                                   Address This,
                                                   llvm::Type *Ty,
                                                   SourceLocation Loc) {
-  Ty = Ty->getPointerTo()->getPointerTo();
   auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
-  llvm::Value *VTable = CGF.GetVTablePtr(This, Ty, MethodDecl->getParent());
+  llvm::Value *VTable = CGF.GetVTablePtr(
+      This, Ty->getPointerTo()->getPointerTo(), MethodDecl->getParent());
 
   uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
   llvm::Value *VFunc;
   if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
     VFunc = CGF.EmitVTableTypeCheckedLoad(
         MethodDecl->getParent(), VTable,
         VTableIndex * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
   } else {
     CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
 
-    llvm::Value *VFuncPtr =
-        CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
-    auto *VFuncLoad =
-        CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
+    auto *VFuncLoad = GetVirtualFunctionFromVTable(CGF, MethodDecl->getParent(),
+                                                   VTable, VTableIndex, Ty);
 
     // Add !invariant.load md to virtual function load to indicate that
     // function didn't change inside vtable.
     // It's safe to add it without -fstrict-vtable-pointers, but it would not
     // help in devirtualization because it will only matter if we will have 2
     // the same virtual function loads from the same vtable load, which won't
     // happen without enabled devirtualization with -fstrict-vtable-pointers.
     if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
-        CGM.getCodeGenOpts().StrictVTablePointers)
-      VFuncLoad->setMetadata(
+        CGM.getCodeGenOpts().StrictVTablePointers) {
+      if (auto *VFuncLoadInstr = dyn_cast<llvm::Instruction>(VFuncLoad)) {
+        VFuncLoadInstr->setMetadata(
             llvm::LLVMContext::MD_invariant_load,
             llvm::MDNode::get(CGM.getLLVMContext(),
                               llvm::ArrayRef<llvm::Metadata *>()));
+      }
+    }
     VFunc = VFuncLoad;
   }
 
   CGCallee Callee(GD, VFunc);
   return Callee;
 }
 
 llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(
case Type::MemberPointer:
     VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
     break;
   }
 
   llvm::Constant *VTable =
     CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
   CGM.setDSOLocal(cast<llvm::GlobalValue>(VTable->stripPointerCasts()));
 
-  llvm::Type *PtrDiffTy =
-    CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
-
-  // The vtable address point is 2.
-  llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
-  VTable =
-      llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
-  VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
+  VTable = CXXABI.getVTableAddressPointForTypeInfo(VTable);
 
   Fields.push_back(VTable);
 }
 
 /// Return the linkage that the type info and type info name constants
 /// should have for the given type.
 static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
                                                              QualType Ty) {

clang/lib/CodeGen/MicrosoftCXXABI.cpp

void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
                           QualType ThisTy) override;
 
   void emitVTableTypeMetadata(const VPtrInfo &Info, const CXXRecordDecl *RD,
                               llvm::GlobalVariable *VTable);
 
   void emitVTableDefinitions(CodeGenVTables &CGVT,
                              const CXXRecordDecl *RD) override;
 
+  void SetVTableInitializer(CodeGenVTables &CGVT, llvm::GlobalVariable *VTable,
+                            const VTableLayout &VTLayout,
+                            llvm::Constant *RTTI) override;
+
   bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
                                            CodeGenFunction::VPtr Vptr) override;
 
   /// Don't initialize vptrs if dynamic class
   /// is marked with with the 'novtable' attribute.
   bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {
     return !VTableClass->hasAttr<MSNoVTableAttr>();
   }
for (unsigned I = Info.PathToIntroducingObject.size() - 1; I != 0; --I) {
     CGM.AddVTableTypeMetadata(VTable, AddressPoint, DerivedRD);
   }
 
   // Finally do the same for the most derived class.
   if (Info.FullOffsetInMDC.isZero())
     CGM.AddVTableTypeMetadata(VTable, AddressPoint, RD);
 }
 
+void MicrosoftCXXABI::SetVTableInitializer(CodeGenVTables &CGVT,
+                                           llvm::GlobalVariable *VTable,
+                                           const VTableLayout &VTLayout,
+                                           llvm::Constant *RTTI) {
+  ConstantInitBuilder builder(CGM);
+  auto components = builder.beginStruct();
+  CGVT.createVTableInitializer(components, VTLayout, RTTI);
+  components.finishAndSetAsInitializer(VTable);
+}
+
 void MicrosoftCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
                                             const CXXRecordDecl *RD) {
   MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext();
   const VPtrInfoVector &VFPtrs = VFTContext.getVFPtrOffsets(RD);
 
   for (const std::unique_ptr<VPtrInfo>& Info : VFPtrs) {
     llvm::GlobalVariable *VTable = getAddrOfVTable(RD, Info->FullOffsetInMDC);
     if (VTable->hasInitializer())
       continue;
 
     const VTableLayout &VTLayout =
       VFTContext.getVFTableLayout(RD, Info->FullOffsetInMDC);
 
     llvm::Constant *RTTI = nullptr;
     if (any_of(VTLayout.vtable_components(),
                [](const VTableComponent &VTC) { return VTC.isRTTIKind(); }))
       RTTI = getMSCompleteObjectLocator(RD, *Info);
 
-    ConstantInitBuilder Builder(CGM);
-    auto Components = Builder.beginStruct();
-    CGVT.createVTableInitializer(Components, VTLayout, RTTI);
-    Components.finishAndSetAsInitializer(VTable);
+    SetVTableInitializer(CGVT, VTable, VTLayout, RTTI);
 
     emitVTableTypeMetadata(*Info, RD, VTable);
   }
 }
 
 bool MicrosoftCXXABI::isVirtualOffsetNeededForVTableField(
     CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) {
   return Vptr.NearestVBase != nullptr;

clang/lib/Driver/ToolChains/Clang.cpp

   if (WholeProgramVTables) {
     if (!D.isUsingLTO())
       D.Diag(diag::err_drv_argument_only_allowed_with)
           << "-fwhole-program-vtables"
           << "-flto";
     CmdArgs.push_back("-fwhole-program-vtables");
   }
 
+  // Add unstable C++ ABI flags.
+  if (Args.hasArg(options::OPT_fexperimental_fuchsia_relative_cxx_abi_vtables))
+    CmdArgs.push_back("-fexperimental-fuchsia-relative-c++-abi-vtables");
+  if (Args.hasArg(
+          options::OPT_fno_experimental_fuchsia_relative_cxx_abi_vtables))
+    CmdArgs.push_back("-fno-experimental-fuchsia-relative-c++-abi-vtables");
+
   bool DefaultsSplitLTOUnit =
       (WholeProgramVTables || Sanitize.needsLTO()) &&
       (D.getLTOMode() == LTOK_Full || TC.canSplitThinLTOUnit());
   bool SplitLTOUnit =
       Args.hasFlag(options::OPT_fsplit_lto_unit,
                    options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
   if (Sanitize.needsLTO() && !SplitLTOUnit)
     D.Diag(diag::err_drv_argument_not_allowed_with) << "-fno-split-lto-unit"

clang/lib/Frontend/CompilerInvocation.cpp

if (!VerParts.first.startswith("0") &&
           << A->getAsString(Args) << A->getValue();
     }
   }
 
   Opts.CompleteMemberPointers = Args.hasArg(OPT_fcomplete_member_pointers);
   Opts.BuildingPCHWithObjectFile = Args.hasArg(OPT_building_pch_with_obj);
 
   Opts.MaxTokens = getLastArgIntValue(Args, OPT_fmax_tokens_EQ, 0, Diags);
+  llvm::Triple Triple = llvm::Triple(TargetOpts.Triple);
+  Opts.FuchsiaRelativeCXXABIVTables =
+      (Args.hasArg(OPT_fexperimental_fuchsia_relative_cxx_abi_vtables) ||
+       Triple.isOSFuchsia()) &&
+      !Args.hasArg(OPT_fno_experimental_fuchsia_relative_cxx_abi_vtables);
 }
 
 static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
   switch (Action) {
   case frontend::ASTDeclList:
   case frontend::ASTDump:
   case frontend::ASTPrint:
   case frontend::ASTView:

clang/test/CodeGenCXX/Fuchsia/child-inheritted-from-parent-in-comdat.cpp

+// Cross comdat example
+// Parent VTable is in a comdat section.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: $_ZN1B3fooEv.stub = comdat any
+
+// The inline function is emitted in each module with the same comdat
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZTS1A = comdat any
+// CHECK: $_ZTI1A = comdat any
+// CHECK: $_ZTI1B.rtti_proxy = comdat any
+
+// The VTable is emitted everywhere used
+// CHECK: $_ZTV1A = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+
+// The VTable for B is emitted here since it has a key function which is defined in this module
+// CHECK: @_ZTV1B = dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// The VTable for A is emitted here and in a comdat section since it has no key function, and is used in this module when creating an instance of A (in func()).
+// CHECK: @_ZTV1A = linkonce_odr dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, comdat, align 8
+
+// CHECK:      define dso_local void @_ZN1B3fooEv(%class.B* nocapture %this) unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK:      define hidden void @_ZN1B3fooEv.stub(%class.B* nocapture %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK:      define hidden void @_ZN1A3fooEv.stub(%class.A* nocapture readnone %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  inline virtual void foo() {}
+};
+class B : public A {
+public:
+  void foo() override;
+};
+void A_foo(A *a);
+
+void B::foo() {}
+void func2() {
+  A a;
+  A_foo(&a);
+}

clang/test/CodeGenCXX/Fuchsia/child-vtable-in-comdat.cpp

+// Cross comdat example
+// Child VTable is in a comdat section.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: $_ZN1B3fooEv.stub = comdat any
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+
+// A comdat is emitted for B but not A
+// CHECK: $_ZTV1B = comdat any
+// CHECK: $_ZTS1B = comdat any
+// CHECK: $_ZTI1B = comdat any
+// CHECK: $_ZTI1B.rtti_proxy = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+
+// VTable for B is emitted here since we access it when creating an instance of B. The VTable is also linkonce_odr and in its own comdat.
+// CHECK: @_ZTV1B = linkonce_odr dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, comdat, align 8
+
+// The RTTI objects aren’t that important, but it is good to know that they are emitted here since they are used in the vtable for B, and external references are used for RTTI stuff from A.
+// CHECK: @_ZTVN10__cxxabiv120__si_class_type_infoE = external global i8*
+// CHECK: @_ZTS1B = linkonce_odr dso_local constant [3 x i8] c"1B\00", comdat, align 1
+// CHECK: @_ZTI1A = external constant i8*
+// CHECK: @_ZTI1B = linkonce_odr dso_local constant { i8*, i8*, i8* } { i8* getelementptr inbounds (i8, i8* bitcast (i8** @_ZTVN10__cxxabiv120__si_class_type_infoE to i8*), i32 12), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1B, i32 0, i32 0), i8* bitcast (i8** @_ZTI1A to i8*) }, comdat, align 8
+// CHECK: @_ZTI1B.rtti_proxy = hidden unnamed_addr constant { i8*, i8*, i8* }* @_ZTI1B, comdat
+// CHECK: @_ZTI1A.rtti_proxy = hidden unnamed_addr constant i8** @_ZTI1A, comdat
+
+// CHECK:      define hidden void @_ZN1B3fooEv.stub(%class.B* nocapture readnone %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK: declare void @_ZN1A3fooEv(%class.A*) unnamed_addr
+
+// CHECK: define hidden void @_ZN1A3fooEv.stub(%class.A* %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   tail call void @_ZN1A3fooEv(%class.A* %0)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+};
+class B : public A {
+public:
+  inline void foo() override {}
+};
+void A_foo(A *a);
+
+// func() is used so that the vtable for B is accessed when creating the instance.
+void func() {
+  B b;
+  A_foo(&b);
+}

clang/test/CodeGenCXX/Fuchsia/cross-translation-unit-1.cpp

+// Check the vtable layout for classes with key functions defined in different
+// translation units. This TU only manifests the vtable for A.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+#include "cross-tu-header.h"
+
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZN1A3barEv.stub = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+
+// CHECK: @_ZTV1A = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// A::foo() is still available for other modules to use since it is not marked with private or internal linkage.
+// CHECK:      define dso_local void @_ZN1A3fooEv(%class.A* nocapture %this) unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// The proxy that we take a reference to in the vtable has hidden visibility and external linkage so it can be used only by other modules in the same DSO. A::foo() is inlined into this stub since it is defined in the same module.
+// CHECK:      define hidden void @_ZN1A3fooEv.stub(%class.A* nocapture %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// A::bar() is called within the module but not defined, even though the VTable for A is emitted here
+// CHECK: declare void @_ZN1A3barEv(%class.A*) unnamed_addr
+
+// The stub for A::bar() is made private, so it will not appear in the symbol table and is only used in this module. We tail call here because A::bar() is not defined in the same module.
+// CHECK:      define hidden void @_ZN1A3barEv.stub(%class.A* %0) unnamed_addr {{#[0-9]+}} comdat {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   tail call void @_ZN1A3barEv(%class.A* %0)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void A::foo() {}
+void A_foo(A *a) { a->foo(); }
+void A_bar(A *a) { a->bar(); }

clang/test/CodeGenCXX/Fuchsia/cross-translation-unit-2.cpp

+// Check the vtable layout for classes with key functions defined in different
+// translation units. This TU manifests the vtable for B.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+#include "cross-tu-header.h"
+
+// CHECK: $_ZN1B3fooEv.stub = comdat any
+// CHECK: $_ZN1A3barEv.stub = comdat any
+// CHECK: $_ZTI1B.rtti_proxy = comdat any
+
+// CHECK: @_ZTV1B = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// A::bar() is defined outside of the module that defines the vtable for A
+// CHECK:      define dso_local void @_ZN1A3barEv(%class.A* nocapture %this) unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK:      define dso_local void @_ZN1B3fooEv(%class.B* nocapture %this) unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// The stubs for B::foo() and A::bar() are hidden
+// CHECK:      define hidden void @_ZN1B3fooEv.stub(%class.B* nocapture %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK:      define hidden void @_ZN1A3barEv.stub(%class.A* nocapture %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void A::bar() {}
+void B::foo() {}

clang/test/CodeGenCXX/Fuchsia/cross-tu-header.h

+class A {
+public:
+  virtual void foo();
+  virtual void bar();
+};
+
+class B : public A {
+public:
+  void foo() override;
+};

clang/test/CodeGenCXX/Fuchsia/diamond-inheritance.cpp

+// Diamond inheritance.
+// A more complicated multiple inheritance example that includes longer chain of inheritance and a common ancestor.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: %class.B = type { %class.A }
+// CHECK: %class.A = type { i32 (...)** }
+// CHECK: %class.C = type { %class.A }
+// CHECK: %class.D = type { %class.B, %class.C }
+
+// VTable for B should contain offset to top (0), RTTI pointer, A::foo(), and B::barB().
+// CHECK: @_ZTV1B = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B4barBEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// VTable for C should contain offset to top (0), RTTI pointer, A::foo(), and C::barC().
+// CHECK: @_ZTV1C = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1C.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZN1C4barCEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// VTable for D should be similar to the mutiple inheritance example where this
+// vtable contains 2 inner vtables:
+// - 1st table containing D::foo(), B::barB(), and D::baz().
+// - 2nd table containing a thunk to D::foo() and C::barC().
+// CHECK: @_ZTV1D = dso_local unnamed_addr constant { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64 }** @_ZTI1D.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }* @_ZTV1D, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.D*)* @_ZN1D3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }* @_ZTV1D, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B4barBEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }* @_ZTV1D, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.D*)* @_ZN1D3bazEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }* @_ZTV1D, i32 0, i32 0, i32 2) to i64)) to i32) }, { i8*, i32, i32, i32 } { i8* inttoptr (i64 -8 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64 }** @_ZTI1D.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }* @_ZTV1D, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.D*)* @_ZThn8_N1D3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }* @_ZTV1D, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZN1C4barCEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32, i32 }, { i8*, i32, i32, i32 } }* @_ZTV1D, i32 0, i32 1, i32 2) to i64)) to i32) } }, align 8
+
+class A {
+public:
+  virtual void foo();
+};
+
+class B : public A {
+public:
+  virtual void barB();
+};
+
+class C : public A {
+  virtual void barC();
+};
+
+// Should be a struct with 2 arrays from 2 parents.
+// The 1st contains D::foo(), B::barB(), and D::baz().
+// The 2nd contains C::barC(), and a thunk that points to D::foo().
+class D : public B, C {
+public:
+  virtual void baz();
+  void foo() override;
+};
+
+void B::barB() {}
+void C::barC() {}
+void D::foo() {}
+void D::baz() {}
+
+void D_foo(D *d) {
+  d->foo();
+}

clang/test/CodeGenCXX/Fuchsia/diamond-virtual-inheritance.cpp

+// Diamond virtual inheritance.
+// This should cover virtual inheritance, construction vtables, and VTTs.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: %class.B = type { i32 (...)**, %class.A.base }
+// CHECK: %class.A.base = type <{ i32 (...)**, i32 }>
+// CHECK: %class.C = type { i32 (...)**, %class.A.base }
+// CHECK: %class.D = type { %class.B.base, %class.C.base, %class.A.base }
+// CHECK: %class.B.base = type { i32 (...)** }
+// CHECK: %class.C.base = type { i32 (...)** }
+
+// Class A contains a vtable ptr, then int, then padding
+// CHECK: %class.A = type <{ i32 (...)**, i32, [4 x i8] }>
+
+// VTable for B. Contains an extra field at the start for the virtual-base offset.
+// CHECK: @_ZTV1B = dso_local unnamed_addr constant { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } } { { i8*, i8*, i32, i32 } { i8* inttoptr (i64 8 to i8*), i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B4barBEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 3) to i64)) to i32) }, { i8*, i8*, i32, i32 } { i8* null, i8* inttoptr (i64 -8 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 1, i32 3) to i64)) to i32) } }, align 8
+
+// VTT for B
+// CHECK: @_ZTT1B = dso_local unnamed_addr constant [2 x i8*] [i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1B, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1B, i32 0, inrange i32 1, i32 3) to i8*)], align 8
+
+// VTable for C
+// CHECK: @_ZTV1C = dso_local unnamed_addr constant { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } } { { i8*, i8*, i32, i32 } { i8* inttoptr (i64 8 to i8*), i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1C.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZN1C4barCEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 3) to i64)) to i32) }, { i8*, i8*, i32, i32 } { i8* null, i8* inttoptr (i64 -8 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1C.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 1, i32 3) to i64)) to i32) } }, align 8
+
+// VTT for C
+// CHECK: @_ZTT1C = dso_local unnamed_addr constant [2 x i8*] [i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1C, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1C, i32 0, inrange i32 1, i32 3) to i8*)], align 8
+
+// VTable for D
+// CHECK: @_ZTV1D = dso_local unnamed_addr constant { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } } { { i8*, i8*, i32, i32, i32 } { i8* inttoptr (i64 16 to i8*), i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64 }** @_ZTI1D.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B4barBEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, i32 0, i32 3) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.D*)* @_ZN1D3bazEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, i32 0, i32 3) to i64)) to i32) }, { i8*, i8*, i32, i32 } { i8* inttoptr (i64 8 to i8*), i8* inttoptr (i64 -8 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64 }** @_ZTI1D.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZN1C4barCEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, i32 1, i32 3) to i64)) to i32) }, { i8*, i8*, i32, i32 } { i8* null, i8* inttoptr (i64 -16 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64 }** @_ZTI1D.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, i32 2, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, i32 2, i32 3) to i64)) to i32) } }, align 8
+
+// VTT for D
+// CHECK: @_ZTT1D = dso_local unnamed_addr constant [7 x i8*] [i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D0_1B, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D0_1B, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D8_1C, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D8_1C, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32, i32 }, { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTV1D, i32 0, inrange i32 1, i32 3) to i8*)], align 8
+
+// Construction vtable for B-in-D
+// CHECK: @_ZTC1D0_1B = dso_local unnamed_addr constant { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } } { { i8*, i8*, i32, i32 } { i8* inttoptr (i64 16 to i8*), i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D0_1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B4barBEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D0_1B, i32 0, i32 0, i32 3) to i64)) to i32) }, { i8*, i8*, i32, i32 } { i8* null, i8* inttoptr (i64 -16 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D0_1B, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D0_1B, i32 0, i32 1, i32 3) to i64)) to i32) } }, align 8
+
+// Construction vtable for C-in-D
+// CHECK: @_ZTC1D8_1C = dso_local unnamed_addr constant { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } } { { i8*, i8*, i32, i32 } { i8* inttoptr (i64 8 to i8*), i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1C.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D8_1C, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZN1C4barCEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D8_1C, i32 0, i32 0, i32 3) to i64)) to i32) }, { i8*, i8*, i32, i32 } { i8* null, i8* inttoptr (i64 -8 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64 }** @_ZTI1C.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D8_1C, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }, { { i8*, i8*, i32, i32 }, { i8*, i8*, i32, i32 } }* @_ZTC1D8_1C, i32 0, i32 1, i32 3) to i64)) to i32) } }, align 8
+
+// CHECK:      define dso_local void @_Z5D_fooP1D(%class.D* %d) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[d:%[0-9]+]] = bitcast %class.D* %d to i8**
+// CHECK-NEXT:   [[vtable:%[a-z0-9]+]] = load i8*, i8** [[d]], align 8
+
+// This should be -20 since the virtual offset to top is 20 bytes from the address point (8 bytes for the virtual call, 8 bytes for the offset to top, and 4 bytes for the RTTI offset)
+// CHECK-NEXT:   [[vbase_offset_ptr:%[a-z0-9.]+]] = getelementptr i8, i8* [[vtable]], i64 -20
+
+// CHECK-NEXT:   [[vbase_offset_ptr2:%[a-z0-9.]+]] = bitcast i8* [[vbase_offset_ptr]] to i64*
+// CHECK-NEXT:   [[vbase_offset:%[a-z0-9.]+]] = load i64, i64* [[vbase_offset_ptr2]], align 8
+// CHECK-NEXT:   [[d:%[0-9]+]] = bitcast %class.D* %d to i8*
+// CHECK-NEXT:   [[add_ptr:%[a-z0-9.]+]] = getelementptr inbounds i8, i8* [[d]], i64 [[vbase_offset]]
+// CHECK-NEXT:   [[a:%[0-9]+]] = bitcast i8* [[add_ptr]] to %class.A*
+// CHECK-NEXT:   [[a_i8_ptr:%[0-9]+]] = bitcast i8* [[add_ptr]] to i8**
+// CHECK-NEXT:   [[vtable:%[a-z0-9]+]] = load i8*, i8** [[a_i8_ptr]], align 8
+// CHECK-NEXT:   [[ptr:%[0-9]+]] = call i8* @llvm.load.relative.i32(i8* [[vtable]], i32 0)
+// CHECK-NEXT:   [[method:%[0-9]+]] = bitcast i8* [[ptr]] to void (%class.A*)*
+// CHECK-NEXT:   call void [[method]](%class.A* [[a]])
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+  int a;
+};
+
+class B : public virtual A {
+public:
+  virtual void barB();
+};
+
+class C : public virtual A {
+  virtual void barC();
+};
+
+class D : public B, C {
+public:
+  virtual void baz();
+};
+
+void B::barB() {}
+void C::barC() {}
+void D::baz() {}
+
+void D_foo(D *d) {
+  d->foo();
+}

clang/test/CodeGenCXX/Fuchsia/dynamic-cast.cpp

+// dynamic_cast
+// Ensure that dynamic casting works normally
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O3 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK:      define dso_local %class.A* @_Z6upcastP1B(%class.B* readnone %b) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[a:%[0-9]+]] = getelementptr %class.B, %class.B* %b, i64 0, i32 0
+// CHECK-NEXT:   ret %class.A* [[a]]
+// CHECK-NEXT: }
+
+// CHECK:      define dso_local %class.B* @_Z8downcastP1A(%class.A* readonly %a) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[isnull:%[0-9]+]] = icmp eq %class.A* %a, null
+// CHECK-NEXT:   br i1 [[isnull]], label %[[dynamic_cast_end:[a-z0-9._]+]], label %[[dynamic_cast_notnull:[a-z0-9._]+]]
+// CHECK:      [[dynamic_cast_notnull]]:
+// CHECK-NEXT:   [[a:%[0-9]+]] = bitcast %class.A* %a to i8*
+// CHECK-NEXT:   [[as_b:%[0-9]+]] = tail call i8* @__dynamic_cast(i8* nonnull [[a]], i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1B to i8*), i64 0)
+// CHECK-NEXT:   [[b:%[0-9]+]] = bitcast i8* [[as_b]] to %class.B*
+// CHECK-NEXT:   br label %[[dynamic_cast_end]]
+// CHECK:      [[dynamic_cast_end]]:
+// CHECK-NEXT:   [[res:%[0-9]+]] = phi %class.B* [ [[b]], %[[dynamic_cast_notnull]] ], [ null, %entry ]
+// CHECK-NEXT:   ret %class.B* [[res]]
+// CHECK-NEXT: }
+
+// CHECK: declare i8* @__dynamic_cast(i8*, i8*, i8*, i64) local_unnamed_addr
+
+// CHECK:      define dso_local %class.B* @_Z8selfcastP1B(%class.B* readnone returned %b) local_unnamed_addr
+// CHECK-NEXT: entry
+// CHECK-NEXT:   ret %class.B* %b
+// CHECK-NEXT: }
+
+// CHECK: define dso_local i8* @_Z9void_castP1B(%class.B* readonly %b) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[isnull:%[0-9]+]] = icmp eq %class.B* %b, null
+// CHECK-NEXT:   br i1 [[isnull]], label %[[dynamic_cast_end:[a-z0-9._]+]], label %[[dynamic_cast_notnull:[a-z0-9._]+]]
+// CHECK:      [[dynamic_cast_notnull]]:
+// CHECK-NEXT:   [[b:%[0-9]+]] = bitcast %class.B* %b to i8*
+// CHECK-NEXT:   [[b2:%[0-9]+]] = bitcast %class.B* %b to i64**
+// CHECK-NEXT:   [[vtable:%[a-z0-9]+]] = load i64*, i64** [[b2]], align 8
+// CHECK-NEXT:   [[offset_ptr:%.+]] = getelementptr inbounds i64, i64* [[vtable]], i64 -2
+// CHECK-NEXT:   [[offset_to_top:%.+]] = load i64, i64* [[offset_ptr]], align 8
+// CHECK-NEXT:   [[casted:%.+]] = getelementptr inbounds i8, i8* [[b]], i64 [[offset_to_top]]
+// CHECK-NEXT:   br label %[[dynamic_cast_end]]
+// CHECK:      [[dynamic_cast_end]]:
+// CHECK-NEXT:   [[res:%[0-9]+]] = phi i8* [ [[casted]], %[[dynamic_cast_notnull]] ], [ null, %entry ]
+// CHECK-NEXT:   ret i8* [[res]]
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+};
+
+class B : public A {
+public:
+  void foo() override;
+};
+
+void A::foo() {}
+void B::foo() {}
+
+A *upcast(B *b) {
+  return dynamic_cast<A *>(b);
+}
+
+B *downcast(A *a) {
+  return dynamic_cast<B *>(a);
+}
+
+B *selfcast(B *b) {
+  return dynamic_cast<B *>(b);
+}
+
+void *void_cast(B *b) {
+  return dynamic_cast<void *>(b);
+}

clang/test/CodeGenCXX/Fuchsia/inheritted-virtual-function.cpp

+// Check the layout of the vtable for a child class that inherits a virtual
+// function but does not override it.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+class A {
+public:
+  virtual void foo();
+};
+
+// The VTable for B should look similar to the vtable for A but the component for foo() should point to A::foo() and the component for bar() should point to B::bar().
+// CHECK: @_ZTV1B = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+class B : public A {
+public:
+  virtual void bar();
+};
+
+void A::foo() {}
+void B::bar() {}
+
+void A_foo(A *a) {
+  a->foo();
+}
+
+void B_foo(B *b) {
+  b->foo();
+}

clang/test/CodeGenCXX/Fuchsia/inline-virtual-function.cpp

+// The VTable is not in a comdat but the inline methods are.
+// This doesn’t affect the vtable or the stubs we emit.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZN1A3barEv.stub = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+
+// The vtable has a key function (A::foo()) so it does not have a comdat
+// CHECK: @_ZTV1A = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// We do not declare the stub with linkonce_odr so it can be emitted as .globl.
+// CHECK:      define hidden void @_ZN1A3barEv.stub(%class.A* nocapture readnone %0) unnamed_addr #{{[0-9]+}} comdat {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo(); // Key func
+  inline virtual void bar() {}
+};
+
+void A::foo() {}

clang/test/CodeGenCXX/Fuchsia/inlined-key-function.cpp

+// Inline comdat method definition example.
+// The VTable is in a comdat and defined anywhere the inline definition is.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZTV1A = comdat any
+// CHECK: $_ZTS1A = comdat any
+// CHECK: $_ZTI1A = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+
+// The VTable is linkonce_odr and in a comdat here bc it’s key function is inline defined.
+// CHECK: @_ZTV1A = linkonce_odr dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, comdat, align 8
+
+// CHECK:      define hidden void @_ZN1A3fooEv.stub(%class.A* nocapture readnone %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+};
+void A_foo(A *a);
+
+inline void A::foo() {}
+
+void func() {
+  A a;
+  A_foo(&a);
+}

clang/test/CodeGenCXX/Fuchsia/member-function-pointer.cpp

+// Member pointer to virtual function.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O3 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK:      define dso_local void @_Z4funcP1AMS_FvvE(%class.A* %a, [2 x i64] %fn.coerce) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[fn_ptr:%.+]] = extractvalue [2 x i64] %fn.coerce, 0
+// CHECK-NEXT:   [[adjust:%.+]] = extractvalue [2 x i64] %fn.coerce, 1
+// CHECK-NEXT:   [[this:%.+]] = bitcast %class.A* %a to i8*
+// CHECK-NEXT:   [[this_adj:%.+]] = getelementptr inbounds i8, i8* [[this]], i64 [[adjust]]
+// CHECK-NEXT:   [[a:%.+]] = bitcast i8* [[this_adj]] to %class.A*
+// CHECK-NEXT:   [[virtbit:%.+]] = and i64 [[fn_ptr]], 1
+// CHECK-NEXT:   [[isvirt:%.+]] = icmp eq i64 [[virtbit]], 0
+// CHECK-NEXT:   br i1 [[isvirt]], label %[[nonvirt:.+]], label %[[virt:.+]]
+// CHECK:      [[virt]]:
+
+// The loading of the virtual function here should be replaced with a llvm.load.relative() call.
+// CHECK-NEXT:   [[this:%.+]] = bitcast i8* [[this_adj]] to i8**
+// CHECK-NEXT:   [[vtable:%.+]] = load i8*, i8** [[this]], align 8
+// CHECK-NEXT:   [[offset:%.+]] = add i64 [[fn_ptr]], -1
+// CHECK-NEXT:   [[ptr:%.+]] = tail call i8* @llvm.load.relative.i64(i8* [[vtable]], i64 [[offset]])
+// CHECK-NEXT:   [[method:%.+]] = bitcast i8* [[ptr]] to void (%class.A*)*
+// CHECK-NEXT:   br label %[[memptr_end:.+]]
+// CHECK:      [[nonvirt]]:
+// CHECK-NEXT:   [[method2:%.+]] = inttoptr i64 [[fn_ptr]] to void (%class.A*)*
+// CHECK-NEXT:   br label %[[memptr_end]]
+// CHECK:      [[memptr_end]]:
+// CHECK-NEXT:   [[method3:%.+]] = phi void (%class.A*)* [ [[method]], %[[virt]] ], [ [[method2]], %[[nonvirt]] ]
+// CHECK-NEXT:   tail call void [[method3]](%class.A* [[a]])
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+};
+
+class B : public A {
+public:
+  void foo() override;
+};
+
+typedef void (A::*A_foo)();
+
+void func(A *a, A_foo fn) {
+  (a->*fn)();
+}

clang/test/CodeGenCXX/Fuchsia/multiple-inheritance.cpp

+// Multiple inheritance.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: %class.C = type { %class.A, %class.B }
+// CHECK: %class.A = type { i32 (...)** }
+// CHECK: %class.B = type { i32 (...)** }
+
+// VTable for C contains 2 sub-vtables (represented as 2 structs). The first contains the components for B and the second contains the components for C. The RTTI ptr in both arrays still point to the RTTI struct for C.
+// The component for bar() instead points to a thunk which redirects to C::bar() which overrides B::bar().
+// Now that we have a class with 2 parents, the offset to top in the second array is non-zero.
+// CHECK: @_ZTV1C = dso_local unnamed_addr constant { { i8*, i32, i32, i32 }, { i8*, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64 }** @_ZTI1C.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 }, { i8*, i32, i32 } }, { { i8*, i32, i32, i32 }, { i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZN1C3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 }, { i8*, i32, i32 } }, { { i8*, i32, i32, i32 }, { i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZN1C3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 }, { i8*, i32, i32 } }, { { i8*, i32, i32, i32 }, { i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 0, i32 2) to i64)) to i32) }, { i8*, i32, i32 } { i8* inttoptr (i64 -8 to i8*), i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64 }** @_ZTI1C.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 }, { i8*, i32, i32 } }, { { i8*, i32, i32, i32 }, { i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 1, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.C*)* @_ZThn8_N1C3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 }, { i8*, i32, i32 } }, { { i8*, i32, i32, i32 }, { i8*, i32, i32 } }* @_ZTV1C, i32 0, i32 1, i32 2) to i64)) to i32) } }, align 8
+
+// CHECK:      define dso_local void @_Z8C_foobarP1C(%class.C* %c) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[c:%[0-9]+]] = bitcast %class.C* %c to i8**
+// CHECK-NEXT:   [[vtable:%[a-z0-9]+]] = load i8*, i8** [[c]], align 8
+
+// Offset 0 to get first method
+// CHECK-NEXT:   [[ptr1:%[0-9]+]] = call i8* @llvm.load.relative.i32(i8* [[vtable]], i32 0)
+// CHECK-NEXT:   [[method1:%[0-9]+]] = bitcast i8* [[ptr1]] to void (%class.C*)*
+// CHECK-NEXT:   call void [[method1]](%class.C* %c)
+// CHECK-NEXT:   [[vtable:%[a-z0-9]+]] = load i8*, i8** [[c]], align 8
+
+// Offset by 4 to get the next bar()
+// CHECK-NEXT:   [[ptr2:%[0-9]+]] = call i8* @llvm.load.relative.i32(i8* [[vtable]], i32 4)
+// CHECK-NEXT:   [[method2:%[0-9]+]] = bitcast i8* [[ptr2]] to void (%class.C*)*
+// CHECK-NEXT:   call void [[method2]](%class.C* %c)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+};
+
+class B {
+  virtual void bar();
+};
+
+class C : public A, public B {
+public:
+  void foo() override;
+  void bar() override;
+};
+
+void C::foo() {}
+void C::bar() {}
+
+void C_foobar(C *c) {
+  c->foo();
+  c->bar();
+}

clang/test/CodeGenCXX/Fuchsia/override-pure-virtual-method.cpp

+// Override pure virtual function.
+// We instead emit zero for the pure virtual function component. See PR43094 for
+// details.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: @_ZTV1A = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 0, i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// CHECK: @_ZTV1B = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+// CHECK-NOT: declare void @__cxa_pure_virtual() unnamed_addr
+
+class A {
+public:
+  virtual void foo() = 0;
+  virtual void bar();
+};
+
+class B : public A {
+public:
+  void foo() override;
+  void bar() override;
+};
+
+void A::bar() {}
+void B::foo() {}
+void B::bar() {}
+
+void A_foo(A *a) {
+  a->foo();
+}

clang/test/CodeGenCXX/Fuchsia/overriden-virtual-function.cpp

+// Check the layout of the vtable for a child class that inherits a virtual
+// function but does override it.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK: @_ZTV1B = dso_local unnamed_addr constant { { i8*, i32, i32, i32 } } { { i8*, i32, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3barEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32, i32 } }, { { i8*, i32, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+
+class A {
+public:
+  virtual void foo();
+};
+
+class B : public A {
+public:
+  void foo() override;
+  virtual void bar();
+};
+
+void A::foo() {}
+void B::foo() {}
+
+void A_foo(A *a) {
+  a->foo();
+}
+
+void B_foo(B *b) {
+  b->foo();
+}

clang/test/CodeGenCXX/Fuchsia/parent-and-child-in-comdats.cpp

+// Cross comdat example
+// Both the parent and child VTablea are in their own comdat sections.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// Comdats are emitted for both A and B in this module and for their respective implementations of foo().
+// CHECK: $_ZN1A3fooEv = comdat any
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZN1B3fooEv = comdat any
+// CHECK: $_ZN1B3fooEv.stub = comdat any
+// CHECK: $_ZTV1A = comdat any
+// CHECK: $_ZTS1A = comdat any
+// CHECK: $_ZTI1A = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+// CHECK: $_ZTV1B = comdat any
+// CHECK: $_ZTS1B = comdat any
+// CHECK: $_ZTI1B = comdat any
+// CHECK: $_ZTI1B.rtti_proxy = comdat any
+
+// Both the vtables for A and B are emitted and in their own comdats.
+// CHECK: @_ZTV1A = linkonce_odr dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, comdat, align 8
+// CHECK: @_ZTV1B = linkonce_odr dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8*, i8* }** @_ZTI1B.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.B*)* @_ZN1B3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1B, i32 0, i32 0, i32 2) to i64)) to i32) } }, comdat, align 8
+
+// CHECK: declare void @_Z5A_fooP1A(%class.A*)
+
+// The stubs and implementations for foo() are in their own comdat sections.
+// CHECK:      define linkonce_odr dso_local void @_ZN1A3fooEv(%class.A* %this) unnamed_addr #{{[0-9]+}} comdat
+
+// CHECK:      define hidden void @_ZN1A3fooEv.stub(%class.A* %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   tail call void @_ZN1A3fooEv(%class.A* %0)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK:      define linkonce_odr dso_local void @_ZN1B3fooEv(%class.B* %this) unnamed_addr #{{[0-9]+}} comdat
+
+// CHECK:      define hidden void @_ZN1B3fooEv.stub(%class.B* %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   tail call void @_ZN1B3fooEv(%class.B* %0)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  inline virtual void foo() {}
+};
+class B : public A {
+public:
+  inline void foo() override {}
+};
+void A_foo(A *a);
+
+// func() is used so that the vtable for B is accessed when creating the instance.
+void func() {
+  A a;
+  B b;
+  A_foo(&a);
+  A_foo(&b);
+}

clang/test/CodeGenCXX/Fuchsia/parent-vtable-in-comdat.cpp

+// Cross comdat example
+// Parent VTable is in a comdat section.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// A::foo() has a comdat since it is an inline function
+// CHECK: $_ZN1A3fooEv = comdat any
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZTV1A = comdat any
+// CHECK: $_ZTS1A = comdat any
+
+// The VTable for A has its own comdat section bc it has no key function
+// CHECK: $_ZTI1A = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+
+// The VTable for A is emitted here and in a comdat section since it has no key function, and is used in this module when creating an instance of A.
+// CHECK: @_ZTV1A = linkonce_odr dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, comdat, align 8
+// CHECK: @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
+// CHECK: @_ZTS1A = linkonce_odr dso_local constant [3 x i8] c"1A\00", comdat, align 1
+// CHECK: @_ZTI1A = linkonce_odr dso_local constant { i8*, i8* } { i8* getelementptr inbounds (i8, i8* bitcast (i8** @_ZTVN10__cxxabiv117__class_type_infoE to i8*), i32 12), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) }, comdat, align 8
+// CHECK: @_ZTI1A.rtti_proxy = hidden unnamed_addr constant { i8*, i8* }* @_ZTI1A, comdat
+
+// CHECK:      define linkonce_odr dso_local void @_ZN1A3fooEv(%class.A* %this) unnamed_addr #{{[0-9]+}} comdat
+
+// CHECK:      define hidden void @_ZN1A3fooEv.stub(%class.A* %0) unnamed_addr #{{[0-9]+}} comdat {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   tail call void @_ZN1A3fooEv(%class.A* %0)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  inline virtual void foo() {}
+};
+class B : public A {
+public:
+  void foo() override;
+};
+void A_foo(A *a);
+
+void A_foo(A *a) { a->foo(); }
+
+// func() is only used to emit a vtable.
+void func() {
+  A a;
+  A_foo(&a);
+}

clang/test/CodeGenCXX/Fuchsia/pass-byval-attributes.cpp

+// ByVal attributes should propogate through to produce proper assembly and
+// avoid "unpacking" structs within the stubs on x86_64.
+
+// RUN: %clang_cc1 %s -triple=x86_64-unknown-fuchsia -std=c++17 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+typedef unsigned long long uint64_t;
+typedef unsigned int size_t;
+
+struct LargeStruct {
+  char x[24];
+  virtual ~LargeStruct() {}
+};
+
+typedef struct fidl_string {
+  // Number of UTF-8 code units (bytes), must be 0 if |data| is null.
+  uint64_t size;
+
+  // Pointer to UTF-8 code units (bytes) or null
+  char *data;
+} fidl_string_t;
+
+class StringView final : private fidl_string_t {
+public:
+  StringView() : fidl_string_t{} {}
+  constexpr StringView(const char *data, uint64_t size)
+      : fidl_string_t{size, const_cast<char *>(data)} {}
+
+  // Constructs a fidl::StringView referencing a string literal. For example:
+  //
+  //     fidl::StringView view("hello");
+  //     view.size() == 5;
+  //
+  template <size_t N>
+  constexpr explicit StringView(const char (&literal)[N])
+      : fidl_string_t{N - 1, const_cast<char *>(literal)} {
+    static_assert(N > 0, "Empty string should be null-terminated");
+  }
+
+  uint64_t size() const { return fidl_string_t::size; }
+  void set_size(uint64_t size) { fidl_string_t::size = size; }
+
+  const char *data() const { return fidl_string_t::data; }
+  void set_data(const char *data) { fidl_string_t::data = const_cast<char *>(data); }
+
+  bool is_null() const { return fidl_string_t::data == nullptr; }
+  bool empty() const { return fidl_string_t::size == 0; }
+
+  const char &at(size_t offset) const { return data()[offset]; }
+
+  const char &operator[](size_t offset) const { return at(offset); }
+
+  const char *begin() const { return data(); }
+  const char *cbegin() const { return data(); }
+
+  const char *end() const { return data() + size(); }
+  const char *cend() const { return data() + size(); }
+};
+
+class Base {
+public:
+  virtual void func(LargeStruct, StringView, LargeStruct, StringView) = 0;
+};
+
+class Derived : public Base {
+public:
+  void func(LargeStruct, StringView, LargeStruct, StringView) override;
+};
+
+// The original function takes a byval pointer.
+// CHECK: define dso_local void @_ZN7Derived4funcE11LargeStruct10StringViewS0_S1_(%class.Derived* %this, %struct.LargeStruct* %ls, i64 %sv1.coerce0, i8* %sv1.coerce1, %struct.LargeStruct* %ls2, %class.StringView* byval(%class.StringView) align 8 %sv2) unnamed_addr
+
+// So the stub should take and pass one also.
+// CHECK:      define hidden void @_ZN7Derived4funcE11LargeStruct10StringViewS0_S1_.stub(%class.Derived* %0, %struct.LargeStruct* %1, i64 %2, i8* %3, %struct.LargeStruct* %4, %class.StringView* byval(%class.StringView) align 8 %5) unnamed_addr {{#[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   tail call void @_ZN7Derived4funcE11LargeStruct10StringViewS0_S1_(%class.Derived* %0, %struct.LargeStruct* %1, i64 %2, i8* %3, %struct.LargeStruct* %4, %class.StringView* byval(%class.StringView) align 8 %5)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void Derived::func(LargeStruct ls, StringView sv1, LargeStruct ls2, StringView sv2) {}

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

+// Check the layout of the vtable for a normal class.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// We should be emitting comdats for each of the virtual function stubs and RTTI proxies
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+
+// VTable contains offsets and references to the hidden symbols
+// CHECK: @_ZTV1A = dso_local unnamed_addr constant { { i8*, i32, i32 } } { { i8*, i32, i32 } { i8* null, i32 trunc (i64 sub (i64 ptrtoint ({ i8*, i8* }** @_ZTI1A.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (void (%class.A*)* @_ZN1A3fooEv.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV1A, i32 0, i32 0, i32 2) to i64)) to i32) } }, align 8
+// CHECK: @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
+// CHECK: @_ZTS1A = dso_local constant [3 x i8] c"1A\00", align 1
+// CHECK: @_ZTI1A = dso_local constant { i8*, i8* } { i8* getelementptr inbounds (i8, i8* bitcast (i8** @_ZTVN10__cxxabiv117__class_type_infoE to i8*), i32 12), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) }, align 8
+
+// The stub should be in a comdat
+// CHECK: @_ZTI1A.rtti_proxy = hidden unnamed_addr constant { i8*, i8* }* @_ZTI1A, comdat
+
+// CHECK:      define dso_local void @_ZN1A3fooEv(%class.A* nocapture %this) unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// This function should be in a comdat
+// CHECK:      define hidden void @_ZN1A3fooEv.stub(%class.A* nocapture %0) unnamed_addr #{{[0-9]+}} comdat
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+};
+
+void A::foo() {}
+
+void A_foo(A *a) {
+  a->foo();
+}

clang/test/CodeGenCXX/Fuchsia/stub-linkages.cpp

+// If the linkage of the class is internal, then the stubs and proxies should
+// also be internally linked.
+
+// RUN: %clang_cc1 %s -triple=x86_64-unknown-fuchsia -std=c++17 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// External linkage.
+// CHECK: @_ZTV8External = dso_local unnamed_addr constant
+// CHECK: @_ZTI8External.rtti_proxy = hidden unnamed_addr constant { i8*, i8* }* @_ZTI8External, comdat
+
+class External {
+public:
+  virtual void func();
+};
+
+void External::func() {}
+
+// Internal linkage.
+// CHECK: @_ZTVN12_GLOBAL__N_18InternalE = internal unnamed_addr constant
+// CHECK: @_ZTIN12_GLOBAL__N_18InternalE.rtti_proxy = internal unnamed_addr constant { i8*, i8* }* @_ZTIN12_GLOBAL__N_18InternalE
+namespace {
+
+class Internal {
+public:
+  virtual void func();
+};
+
+void Internal::func() {}
+
+} // namespace
+
+// This gets the same treatment as an externally available vtable.
+// CHECK: @_ZTV11LinkOnceODR = linkonce_odr dso_local unnamed_addr constant
+// CHECK: @_ZTI11LinkOnceODR.rtti_proxy = hidden unnamed_addr constant { i8*, i8* }* @_ZTI11LinkOnceODR, comdat
+class LinkOnceODR {
+public:
+  virtual void func() {} // A method defined in the class definition results in this linkage for the vtable.
+};
+
+// Force an emission of a vtable for Internal by using it here.
+void manifest_internal() {
+  Internal internal;
+  (void)internal;
+  LinkOnceODR linkonceodr;
+  (void)linkonceodr;
+}
+
+// CHECK: define dso_local void @_ZN8External4funcEv
+// CHECK: define internal void @_ZN12_GLOBAL__N_18Internal4funcEv.stub
+// CHECK: define hidden void @_ZN11LinkOnceODR4funcEv.stub

clang/test/CodeGenCXX/Fuchsia/thunk-mangling.cpp

+// Check that virtual thunks are unaffected by the relative ABI.
+// The offset of thunks is mangled into the symbol name, which could result in
+// linking errors for binaries that want to look for symbols in SOs made with
+// this ABI.
+// Running that linked binary still won't work since we're using conflicting
+// ABIs, but we should still be able to link.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O1 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// This would be n24 under Itanium
+// CHECK: _ZTv0_n20_N7Derived1fEi
+
+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/Fuchsia/type-info.cpp

+// Check typeid() + type_info
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O3 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm -fcxx-exceptions -fexceptions | FileCheck %s
+
+// CHECK: %class.A = type { i32 (...)** }
+// CHECK: %class.B = type { %class.A }
+// CHECK: %"class.std::type_info" = type { i32 (...)**, i8* }
+
+// CHECK: $_ZN1A3fooEv.stub = comdat any
+// CHECK: $_ZN1B3fooEv.stub = comdat any
+// CHECK: $_ZTI1A.rtti_proxy = comdat any
+// CHECK: $_ZTI1B.rtti_proxy = comdat any
+
+// CHECK: @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
+// CHECK: @_ZTS1A = dso_local constant [3 x i8] c"1A\00", align 1
+// CHECK: @_ZTI1A = dso_local constant { i8*, i8* } { i8* getelementptr inbounds (i8, i8* bitcast (i8** @_ZTVN10__cxxabiv117__class_type_infoE to i8*), i32 12), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) }, align 8
+// CHECK: @_ZTVN10__cxxabiv120__si_class_type_infoE = external global i8*
+// CHECK: @_ZTS1B = dso_local constant [3 x i8] c"1B\00", align 1
+// CHECK: @_ZTI1B = dso_local constant { i8*, i8*, i8* } { i8* getelementptr inbounds (i8, i8* bitcast (i8** @_ZTVN10__cxxabiv120__si_class_type_infoE to i8*), i32 12), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1B, i32 0, i32 0), i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*) }, align 8
+// CHECK: @_ZTI1A.rtti_proxy = hidden unnamed_addr constant { i8*, i8* }* @_ZTI1A, comdat
+// CHECK: @_ZTI1B.rtti_proxy = hidden unnamed_addr constant { i8*, i8*, i8* }* @_ZTI1B, comdat
+
+// CHECK:      define dso_local dereferenceable(16) %"class.std::type_info"* @_Z11getTypeInfov() local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret %"class.std::type_info"* bitcast ({ i8*, i8* }* @_ZTI1A to %"class.std::type_info"*)
+// CHECK-NEXT: }
+
+// CHECK:      define dso_local i8* @_Z7getNamev() local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i64 0, i64 0)
+// CHECK-NEXT: }
+
+// CHECK:      define dso_local i1 @_Z5equalP1A(%class.A* readonly %a) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[isnull:%[0-9]+]] = icmp eq %class.A* %a, null
+// CHECK-NEXT:   br i1 [[isnull]], label %[[bad_typeid:[a-z0-9._]+]], label %[[end:[a-z0-9.+]+]]
+// CHECK:      [[bad_typeid]]:
+// CHECK-NEXT:   tail call void @__cxa_bad_typeid()
+// CHECK-NEXT:   unreachable
+// CHECK:      [[end]]:
+// CHECK-NEXT:   [[type_info_ptr3:%[0-9]+]] = bitcast %class.A* %a to i8**
+// CHECK-NEXT:   [[vtable:%[a-z0-9]+]] = load i8*, i8** [[type_info_ptr3]]
+// CHECK-NEXT:   [[type_info_ptr:%[0-9]+]] = tail call i8* @llvm.load.relative.i32(i8* [[vtable]], i32 -4)
+// CHECK-NEXT:   [[type_info_ptr2:%[0-9]+]] = bitcast i8* [[type_info_ptr]] to %"class.std::type_info"**
+// CHECK-NEXT:   [[type_info_ptr:%[0-9]+]] = load %"class.std::type_info"*, %"class.std::type_info"** [[type_info_ptr2]], align 8
+// CHECK-NEXT:   [[name_ptr:%[a-z0-9._]+]] = getelementptr inbounds %"class.std::type_info", %"class.std::type_info"* [[type_info_ptr]], i64 0, i32 1
+// CHECK-NEXT:   [[name:%[0-9]+]] = load i8*, i8** [[name_ptr]], align 8
+// CHECK-NEXT:   [[eq:%[a-z0-9.]+]] = icmp eq i8* [[name]], getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1B, i64 0, i64 0)
+// CHECK-NEXT:   ret i1 [[eq]]
+// CHECK-NEXT: }
+
+#include "../typeinfo"
+
+class A {
+public:
+  virtual void foo();
+};
+
+class B : public A {
+public:
+  void foo() override;
+};
+
+void A::foo() {}
+void B::foo() {}
+
+const auto &getTypeInfo() {
+  return typeid(A);
+}
+
+const char *getName() {
+  return typeid(A).name();
+}
+
+bool equal(A *a) {
+  return typeid(B) == typeid(*a);
+}

clang/test/CodeGenCXX/Fuchsia/virtual-function-call.cpp

+// Check that we call llvm.load.relative() on a vtable function call.
+
+// RUN: %clang_cc1 %s -triple=aarch64-unknown-fuchsia -std=c++17 -O3 -pic-is-pie -ffunction-sections -fdata-sections -S -o - -emit-llvm | FileCheck %s
+
+// CHECK:      define dso_local void @_Z5A_fooP1A(%class.A* %a) local_unnamed_addr
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   [[this:%[0-9]+]] = bitcast %class.A* %a to i8**
+// CHECK-NEXT:   %vtable1 = load i8*, i8** [[this]]
+// CHECK-NEXT:   [[func_ptr:%[0-9]+]] = tail call i8* @llvm.load.relative.i32(i8* %vtable1, i32 0)
+// CHECK-NEXT:   [[func:%[0-9]+]] = bitcast i8* [[func_ptr]] to void (%class.A*)*
+// CHECK-NEXT:   tail call void [[func]](%class.A* %a)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+class A {
+public:
+  virtual void foo();
+};
+
+void A_foo(A *a) {
+  a->foo();
+}

clang/test/CodeGenCXX/constructor-destructor-return-this.cpp

void test_destructor() {
   E* e2 = gete();
   e2->~E();
 }
 
 // CHECKARM-LABEL,CHECKFUCHSIA-LABEL: define void @_Z15test_destructorv()
 
 // Verify that virtual calls to destructors are not marked with a 'returned'
 // this parameter at the call site...
-// CHECKARM,CHECKFUCHSIA: [[VFN:%.*]] = getelementptr inbounds %class.E* (%class.E*)*, %class.E* (%class.E*)**
-// CHECKARM,CHECKFUCHSIA: [[THUNK:%.*]] = load %class.E* (%class.E*)*, %class.E* (%class.E*)** [[VFN]]
+// CHECKARM: [[VFN:%.*]] = getelementptr inbounds %class.E* (%class.E*)*, %class.E* (%class.E*)**
+// CHECKARM: [[THUNK:%.*]] = load %class.E* (%class.E*)*, %class.E* (%class.E*)** [[VFN]]
+// CHECKFUCHSIA: [[VTABLE:%.+]] = bitcast %class.E* (%class.E*)**
+// CHECKFUCHSIA: [[THUNK_PTR:%.+]] = call i8* @llvm.load.relative.i32(i8* [[VTABLE]], i32 0)
+// CHECKFUCHSIA: [[THUNK:%.+]] = bitcast i8* [[THUNK_PTR]] to %class.E* (%class.E*)*
 // CHECKARM,CHECKFUCHSIA: call %class.E* [[THUNK]](%class.E* %
 
 // ...but static calls create declarations with 'returned' this
 // CHECKARM,CHECKFUCHSIA: {{%.*}} = call %class.E* @_ZN1ED1Ev(%class.E* %
 
 // CHECKARM,CHECKFUCHSIA: declare %class.E* @_ZN1ED1Ev(%class.E* returned)

libcxxabi/src/private_typeinfo.cpp

 
 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
+#ifndef __Fuchsia__
     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]);
+#else
+    // The vtable address will point to the first virtual function, which is 12
+    // bytes after the start of the vtable (8 for the offset from top + 4 for the typeinfo component).
+    uint8_t *vtable = *reinterpret_cast<uint8_t * const *>(static_ptr);
+    ptrdiff_t offset_to_derived = *(reinterpret_cast<ptrdiff_t *>(vtable - 12));
+
+    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 = *reinterpret_cast<int32_t *>(vtable - 4);
+    uint8_t *ptr_to_ti_proxy = vtable + offset_to_ti_proxy;
+    const __class_type_info* dynamic_type = *(reinterpret_cast<__class_type_info **>(ptr_to_ti_proxy));
+#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,};
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

MCSymbol *AsmPrinter::getSymbolPreferLocal(const GlobalValue &GV) const {
   // exact definion (intersection of GlobalValue::hasExactDefinition() and
   // !isInterposable()). These linkages include: external, appending, internal,
   // private. It may be profitable to use a local alias for external. The
   // assembler would otherwise be conservative and assume a global default
   // visibility symbol can be interposable, even if the code generator already
   // assumed it.
   if (TM.getTargetTriple().isOSBinFormatELF() &&
       GlobalObject::isExternalLinkage(GV.getLinkage()) && GV.isDSOLocal() &&
-      !GV.isDeclaration() && !isa<GlobalIFunc>(GV))
+      !GV.isDeclaration() && !isa<GlobalIFunc>(GV) && !GV.hasComdat())
     return getSymbolWithGlobalValueBase(&GV, "$local");
   return TM.getSymbol(&GV);
 }
 
 /// EmitGlobalVariable - Emit the specified global variable to the .s file.
 void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   bool IsEmuTLSVar = TM.useEmulatedTLS() && GV->isThreadLocal();
   assert(!(IsEmuTLSVar && GV->hasCommonLinkage()) &&

llvm/lib/IR/Constants.cpp

if (CE->getOpcode() == Instruction::Sub) {
         // function.  This is a common idiom when creating a table for the
         // indirect goto extension, so we handle it efficiently here.
         if (isa<BlockAddress>(LHSOp0) && isa<BlockAddress>(RHSOp0) &&
             cast<BlockAddress>(LHSOp0)->getFunction() ==
                 cast<BlockAddress>(RHSOp0)->getFunction())
           return false;
 
         // Relative pointers do not need to be dynamically relocated.
-        if (auto *LHSGV = dyn_cast<GlobalValue>(LHSOp0->stripPointerCasts()))
-          if (auto *RHSGV = dyn_cast<GlobalValue>(RHSOp0->stripPointerCasts()))
+        if (auto *LHSGV =
+                dyn_cast<GlobalValue>(LHSOp0->stripInBoundsConstantOffsets()))
+          if (auto *RHSGV =
+                  dyn_cast<GlobalValue>(RHSOp0->stripInBoundsConstantOffsets()))
             if (LHSGV->isDSOLocal() && RHSGV->isDSOLocal())
               return false;
       }
     }
   }
 
   bool Result = false;
   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)

llvm/test/CodeGen/X86/relptr-rodata.ll

 ; CHECK: relro1:
 ; CHECK: .long default-relro1
 @relro1 = hidden constant i32 trunc (i64 sub (i64 ptrtoint (i8* @default to i64), i64 ptrtoint (i32* @relro1 to i64)) to i32)
 
 ; CHECK: .section .data.rel.ro.relro2
 ; CHECK: relro2:
 ; CHECK: .long hidden-relro2
 @relro2 = constant i32 trunc (i64 sub (i64 ptrtoint (i8* @hidden to i64), i64 ptrtoint (i32* @relro2 to i64)) to i32)
+
+; CHECK:      .section .rodata.cst16
+; CHECK-NEXT: .globl _ZTV4Test
+; CHECK:      _ZTV4Test
+; CHECK:      .quad 0
+; CHECK:      .long (_ZTI4Test.rtti_proxy-_ZTV4Test)-8
+; CHECK:      .long (_ZN4TestD1Ev.stub@PLT-_ZTV4Test)-12
+
+@_ZTI4Test = external global i8
+@_ZTI4Test.rtti_proxy = hidden unnamed_addr constant i8* @_ZTI4Test
+
+declare void @_ZN4TestD2Ev()
+define hidden void @_ZN4TestD1Ev.stub() unnamed_addr {
+entry:
+  tail call void @_ZN4TestD2Ev()
+  ret void
+}
+
+@_ZTV4Test = dso_local unnamed_addr constant { { i8*, i32, i32 } } {
+  { i8*, i32, i32 } {
+    i8* null,
+    i32 trunc (i64 sub (i64 ptrtoint (i8** @_ZTI4Test.rtti_proxy to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV4Test, i32 0, i32 0, i32 1) to i64)) to i32),
+    i32 trunc (i64 sub (i64 ptrtoint (void ()* @_ZN4TestD1Ev.stub to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i8*, i32, i32 } }, { { i8*, i32, i32 } }* @_ZTV4Test, i32 0, i32 0, i32 2) to i64)) to i32)
+  } }, align 8