[BROKEN][clang] Try to fix thunk function types

[lebedev.ri]

Summary

@rsmith this seems to work on the two testcases from D99790,
but apparently doesn't work on many more tests.
I don't know what i'm doing here.

[rsmith]

clang/include/clang/Basic/ABI.h

43

Instead of the changes you made to GlobalDecl, I think this should be a GlobalDecl itself. Different function variants could have different signatures, so in principle at least, what we want to know is the function variant not the function declaration.

clang/lib/AST/VTableBuilder.cpp

1157–1159

Can you modify the thunk info in-place, instead of this erase + insert dance?

[lebedev.ri]

clang/lib/AST/VTableBuilder.cpp

1157–1159

Absolutely. I had to change that because i needed to weed out all the places where Thunk is created.

[lebedev.ri]

@rsmith thank you for taking a look!
This still feels pretty much like doing it while blindfolded.
I've tried to store GlobalDecl, but i'm clearly missing something else, since there are still 23 test failures,
and not all of then are simple tests that need updates.

E.g.:

******************** TEST 'Clang :: CodeGenCXX/debug-info-thunk.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp -triple=x86_64-pc-windows-msvc -debug-info-kind=limited -S -emit-llvm -o - | /builddirs/llvm-project/build-Clang11/bin/FileCheck /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp
: 'RUN: at line 2';   /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp -triple x86_64-unknown-linux-gnu -debug-info-kind=limited -S -emit-llvm -o - | /builddirs/llvm-project/build-Clang11/bin/FileCheck /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp -check-prefix=ITANIUM
--
Exit Code: 2

Command Output (stderr):
--
clang: /repositories/llvm-project/clang/lib/CodeGen/CGVTables.cpp:518: llvm::Constant *clang::CodeGen::CodeGenVTables::maybeEmitThunk(clang::GlobalDecl, const clang::ThunkInfo &, bool): Assertion `OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.      Program arguments: /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp -triple=x86_64-pc-windows-msvc -debug-info-kind=limited -S -emit-llvm -o -
1.      /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp:221:1: current parser token 'namespace'
2.      /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp:200:11: LLVM IR generation of declaration 'Test9'
3.      /repositories/llvm-project/clang/test/CodeGenCXX/debug-info-thunk.cpp:216:9: Generating code for declaration 'Test9::D::foo1'
 #0 0x00007f9f54af2e43 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) /repositories/llvm-project/llvm/lib/Support/Unix/Signals.inc:565:13
 #1 0x00007f9f54af09a0 llvm::sys::RunSignalHandlers() /repositories/llvm-project/llvm/lib/Support/Signals.cpp:77:18
 #2 0x00007f9f54af335f SignalHandler(int) /repositories/llvm-project/llvm/lib/Support/Unix/Signals.inc:407:1
 #3 0x00007f9f597ee140 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x14140)
 #4 0x00007f9f54400ce1 raise ./signal/../sysdeps/unix/sysv/linux/raise.c:51:1
 #5 0x00007f9f543ea537 abort ./stdlib/abort.c:81:7
 #6 0x00007f9f543ea40f get_sysdep_segment_value ./intl/loadmsgcat.c:509:8
 #7 0x00007f9f543ea40f _nl_load_domain ./intl/loadmsgcat.c:970:34
 #8 0x00007f9f543f9662 (/lib/x86_64-linux-gnu/libc.so.6+0x34662)
 #9 0x00007f9f58958c30 clang::CodeGen::CodeGenVTables::maybeEmitThunk(clang::GlobalDecl, clang::ThunkInfo const&, bool) /repositories/llvm-project/clang/lib/CodeGen/CGVTables.cpp:0:0

********************
FAIL: Clang :: CodeGenCXX/thunks.cpp (29 of 1127)
******************** TEST 'Clang :: CodeGenCXX/thunks.cpp' FAILED ********************
Script:
--
: 'RUN: at line 3';   /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp -triple=sparc64-pc-linux-gnu -munwind-tables -emit-llvm -o -      | /builddirs/llvm-project/build-Clang11/bin/FileCheck --check-prefixes=CHECK,CHECK-CLONE,CHECK-NONOPT /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp
: 'RUN: at line 5';   /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp -triple=sparc64-pc-linux-gnu -debug-info-kind=standalone -dwarf-version=5 -munwind-tables -emit-llvm -o -      | /builddirs/llvm-project/build-Clang11/bin/FileCheck --check-prefixes=CHECK,CHECK-CLONE,CHECK-NONOPT,CHECK-DBG /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp
: 'RUN: at line 7';   /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp -triple=sparc64-pc-linux-gnu -munwind-tables -emit-llvm -o - -O1 -disable-llvm-passes      | /builddirs/llvm-project/build-Clang11/bin/FileCheck --check-prefixes=CHECK,CHECK-CLONE,CHECK-OPT /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp
: 'RUN: at line 11';   /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp -triple=x86_64-pc-linux-gnu -munwind-tables -emit-llvm -o - -O1 -disable-llvm-passes      | /builddirs/llvm-project/build-Clang11/bin/FileCheck --check-prefixes=CHECK,CHECK-TAIL,CHECK-OPT /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp
: 'RUN: at line 15';   /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp -triple=x86_64-windows-msvc -munwind-tables -emit-llvm -o - -O1 -disable-llvm-passes      | /builddirs/llvm-project/build-Clang11/bin/FileCheck --check-prefixes=WIN64 /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp
--
Exit Code: 2

Command Output (stderr):
--
clang: /repositories/llvm-project/llvm/lib/IR/Value.cpp:500: void llvm::Value::doRAUW(llvm::Value *, llvm::Value::ReplaceMetadataUses): Assertion `New->getType() == getType() && "replaceAllUses of value with new value of different type!"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.      Program arguments: /builddirs/llvm-project/build-Clang11/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang11/lib/clang/13.0.0/include -nostdsysteminc /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp -triple=sparc64-pc-linux-gnu -munwind-tables -emit-llvm -o -
1.      /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp:390:1: current parser token 'namespace'
2.      /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp:342:11: LLVM IR generation of declaration 'Test12'
3.      /repositories/llvm-project/clang/test/CodeGenCXX/thunks.cpp:354:9: Generating code for declaration 'Test12::C::f'
 #0 0x00007ff8c7c7ae43 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) /repositories/llvm-project/llvm/lib/Support/Unix/Signals.inc:565:13
 #1 0x00007ff8c7c789a0 llvm::sys::RunSignalHandlers() /repositories/llvm-project/llvm/lib/Support/Signals.cpp:77:18
 #2 0x00007ff8c7c7b35f SignalHandler(int) /repositories/llvm-project/llvm/lib/Support/Unix/Signals.inc:407:1
 #3 0x00007ff8cc976140 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x14140)
 #4 0x00007ff8c7588ce1 raise ./signal/../sysdeps/unix/sysv/linux/raise.c:51:1
 #5 0x00007ff8c7572537 abort ./stdlib/abort.c:81:7
 #6 0x00007ff8c757240f get_sysdep_segment_value ./intl/loadmsgcat.c:509:8
 #7 0x00007ff8c757240f _nl_load_domain ./intl/loadmsgcat.c:970:34
 #8 0x00007ff8c7581662 (/lib/x86_64-linux-gnu/libc.so.6+0x34662)
 #9 0x00007ff8c825b8d5 llvm::cast_retty<llvm::BasicBlock, llvm::Value*>::ret_type llvm::cast<llvm::BasicBlock, llvm::Value>(llvm::Value*) /repositories/llvm-project/llvm/include/llvm/Support/Casting.h:269:3
#10 0x00007ff8c825b8d5 llvm::Value::doRAUW(llvm::Value*, llvm::Value::ReplaceMetadataUses) /repositories/llvm-project/llvm/lib/IR/Value.cpp:523:38
#11 0x00007ff8cbade0fb clang::CodeGen::CodeGenFunction::GenerateVarArgsThunk(llvm::Function*, clang::CodeGen::CGFunctionInfo const&, clang::GlobalDecl, llvm::FunctionCallee, clang::ThunkInfo const&) /repositories/llvm-project/clang/lib/CodeGen/CGVTables.cpp:184:10
#12 0x00007ff8cbae0a0f clang::CodeGen::CodeGenVTables::maybeEmitThunk(clang::GlobalDecl, clang::ThunkInfo const&, bool) /repositories/llvm-project/clang/lib/CodeGen/CGVTables.cpp:584:36

[rsmith]

clang/include/clang/Basic/Thunk.h

158

Isn't this the same as BaseMethod.getDecl()? (I'd expect "overridee" and "overridden" to be synonymous, contrasting with the "overrider" which would be the derived-class function.)

clang/lib/AST/VTableBuilder.cpp

1636–1641

This looks suspicious: we're going to add two vtable slots, one for the deleting destructor and one for the complete object destructor. It doesn't matter in practice because we never form a thunk for a destructor, but it would seem more correct to pass the CXXMethodDecl* into AddMethod and have it form the appropriate GlobalDecl(s) itself.

clang/lib/CodeGen/CGVTables.cpp

451–452

Is this done somewhere else now?

465–466

This bitcast seems to have gone missing.

508

When do we get here for a destructor? I can't see any evidence that this is reachable at all: in our testsuite there doesn't seem to be any mention of a destructor thunk mangling.

Generally, though, thunk mangling uses the mangled name of the target of the thunk, which should be GD.getDtorType() here. (This might matter if we somehow emitted a thunk from the complete destructor to the base subobject destructor via this function.)

517–519

I think this should probably be checking the base method type, but the difference probably doesn't matter in practice.

524–525

This doesn't look right: the target of the thunk shouldn't itself be treated as a musttail thunk. Presumably we should unconditionally use arrangeGlobalDeclaration(GD) for the target.

530–533

It's confusing to call these Base* when (in the vtable thunk case) they're information about the derived-class function. Maybe Target*?

544

Hm, I think we probably want to use MD rather than BaseMethod here. Eg, if the base method is [[noreturn]] but the overrider is not, we want a non-[[noreturn]] thunk, and conversely if the overrider is [[noreturn]] the thunk should be regardless of whether the base method was.

Perhaps there are some attributes for which we want to look at the BaseMethod instead. If so, I suppose we'll need to pass both the caller-side declaration and the callee-side declaration to ConstructAttributeList (or maybe extend CGFunctionInfo to store both) and let it pick which one it wants to inspect for each attribute.

566

This should be passing GD rather than BaseMethod.

577

This should be passing GD rather than BaseMethod.

611

This should be passing GD rather than BaseMethod.

[lebedev.ri]

You know, somehow i don't think me wasting 30 more hours on this to experimentally find a working permutation is productive.

clang/include/clang/Basic/Thunk.h

158

Oh, hmm. That makes more sense indeed.

[lebedev.ri]

@rsmith i was able to make some forward progress here.
What do you think about this?

(I haven't updated all tests because i don't want to waste hours doing that if this is still wrong)

[lebedev.ri]

ping @rsmith - any further thoughts here?

In D100388#2709870, @lebedev.ri wrote:

@rsmith i was able to make some forward progress here.
What do you think about this?

(I haven't updated all tests because i don't want to waste hours doing that if this is still wrong)

[lebedev.ri]

ping @rsmith / @efriedma - if there are any further thoughts on the problem, i would love to hear them

[efriedma]

Made a couple suggestions to make this easier to review.

The test changes you've made so far seem reasonable.

Is there some specific section of the code you want feedback on?

clang/include/clang/Basic/Thunk.h

2

Can you split the new Thunk.h, and the minimal set of changes required to use it, into a separate NFC patch?

clang/lib/CodeGen/CGVTables.cpp

741

Can land this separately.

[lebedev.ri]

In D100388#2749115, @efriedma wrote:

Made a couple suggestions to make this easier to review.

The test changes you've made so far seem reasonable.

Is there some specific section of the code you want feedback on?

Thank you for taking a look!
Basically, i'm not sure this is right, and i'm not sure what is going wrong.
For example

$ ./bin/llvm-lit /repositories/llvm-project/clang/test/CodeGen/available-externally-hidden.cpp -v
llvm-lit: /repositories/llvm-project/llvm/utils/lit/lit/llvm/config.py:428: note: using clang: /builddirs/llvm-project/build-Clang12/bin/clang
-- Testing: 1 tests, 1 workers --
FAIL: Clang :: CodeGen/available-externally-hidden.cpp (1 of 1)
******************** TEST 'Clang :: CodeGen/available-externally-hidden.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /builddirs/llvm-project/build-Clang12/bin/clang -cc1 -internal-isystem /builddirs/llvm-project/build-Clang12/lib/clang/13.0.0/include -nostdsysteminc -O2 -fvisibility hidden -std=c++11 -emit-llvm -o - -triple x86_64-apple-darwin10 /repositories/llvm-project/clang/test/CodeGen/available-externally-hidden.cpp | /builddirs/llvm-project/build-Clang12/bin/FileCheck /repositories/llvm-project/clang/test/CodeGen/available-externally-hidden.cpp
--
Exit Code: 2

Command Output (stderr):
--
/repositories/llvm-project/clang/test/CodeGen/available-externally-hidden.cpp:14:16: error: cannot compile this thunk for forward declaration yet
  virtual bool Send(Message* msg) = 0;
               ^
1 error generated.
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /builddirs/llvm-project/build-Clang12/bin/FileCheck /repositories/llvm-project/clang/test/CodeGen/available-externally-hidden.cpp

--

********************
********************
Failed Tests (1):
  Clang :: CodeGen/available-externally-hidden.cpp


Testing Time: 0.18s
  Failed: 1

Would it be reasonable to instead start with a stopgap measure of not adding attributes for this/return of thunks?

[efriedma]

Would it be reasonable to instead start with a stopgap measure of not adding attributes for this/return of thunks?

You mean, add align attributes to "this" on regular methods, but not thunks? I can't see how that could do any harm.

clang/lib/CodeGen/CGVTables.cpp

467

"IsUnprototyped" means that we have to generate a thunk, but we don't have the proper types. We emit some special IR with known incorrect types, and mark it with the "thunk" attribute to let the optimizer know what we're doing.

It should be fine to continue using a fake type on the IsUnprototyped codepath.

[lebedev.ri]

In D100388#2754872, @efriedma wrote:

Would it be reasonable to instead start with a stopgap measure of not adding attributes for this/return of thunks?

You mean, add align attributes to "this" on regular methods, but not thunks?

Yes, just so the rG6270b3a1eafaba4279e021418c5a2c5a35abc002 can be reverted.
Unless of course we can get this going..

I can't see how that could do any harm.

[lebedev.ri]

clang/lib/CodeGen/CGVTables.cpp

467

IsUnprototyped is false here for that test though..

[efriedma]

clang/lib/CodeGen/CGVTables.cpp

467

Oh, hmm, right. My comment still holds, but doesn't apply to that test.

In that test, the derived class method is defined, but the base class method isn't. You should be able to compute the LLVM function type for the base class method in that case. The types have to be the same, barring pointer variance, so being able to compute the type of the derived class method implies you can compute the type of the base class method.

So I'm not sure why you'd need to error out in that case; the computation should work the same way whether or not we can see the definition of the base class method.

clang/include/clang/AST/VTableBuilder.h

 #ifndef LLVM_CLANG_AST_VTABLEBUILDER_H
 #define LLVM_CLANG_AST_VTABLEBUILDER_H
 
 #include "clang/AST/BaseSubobject.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/Basic/ABI.h"
+#include "clang/Basic/Thunk.h"
 #include "llvm/ADT/DenseMap.h"
 #include <memory>
 #include <utility>
 
 namespace clang {
   class CXXRecordDecl;
 
 /// Represents a single component in a vtable.
private:
   // the virtual table group. To save a little memory in the common case where
   // the vtable group contains a single vtable, an empty vector here represents
   // the vector {0}.
   OwningArrayRef<size_t> VTableIndices;
 
   OwningArrayRef<VTableComponent> VTableComponents;
 
   /// Contains thunks needed by vtables, sorted by indices.
-  OwningArrayRef<VTableThunkTy> VTableThunks;
+  std::vector<VTableThunkTy> VTableThunks;
 
   /// Address points for all vtables.
   AddressPointsMapTy AddressPoints;
 
   /// Address points for all vtable indices.
   AddressPointsIndexMapTy AddressPointIndices;
 
 public:

clang/include/clang/Basic/ABI.h

 /// C++ destructor types.
 enum CXXDtorType {
     Dtor_Deleting, ///< Deleting dtor
     Dtor_Complete, ///< Complete object dtor
     Dtor_Base,     ///< Base object dtor
     Dtor_Comdat    ///< The COMDAT used for dtors
 };
 
-/// A return adjustment.
-struct ReturnAdjustment {
-  /// The non-virtual adjustment from the derived object to its
-  /// nearest virtual base.
-  int64_t NonVirtual;
-
-  /// Holds the ABI-specific information about the virtual return
-  /// adjustment, if needed.
-  union VirtualAdjustment {
-    // Itanium ABI
-    struct {
-      /// The offset (in bytes), relative to the address point
-      /// of the virtual base class offset.
-      int64_t VBaseOffsetOffset;
-    } Itanium;
-
-    // Microsoft ABI
-    struct {
-      /// The offset (in bytes) of the vbptr, relative to the beginning
-      /// of the derived class.
-      uint32_t VBPtrOffset;
-
-      /// Index of the virtual base in the vbtable.
-      uint32_t VBIndex;
-    } Microsoft;
-
-    VirtualAdjustment() {
-      memset(this, 0, sizeof(*this));
-    }
-
-    bool Equals(const VirtualAdjustment &Other) const {
-      return memcmp(this, &Other, sizeof(Other)) == 0;
-    }
-
-    bool isEmpty() const {
-      VirtualAdjustment Zero;
-      return Equals(Zero);
-    }
-
-    bool Less(const VirtualAdjustment &RHS) const {
-      return memcmp(this, &RHS, sizeof(RHS)) < 0;
-    }
-  } Virtual;
-
-  ReturnAdjustment() : NonVirtual(0) {}
-
-  bool isEmpty() const { return !NonVirtual && Virtual.isEmpty(); }
-
-  friend bool operator==(const ReturnAdjustment &LHS,
-                         const ReturnAdjustment &RHS) {
-    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual);
-  }
-
-  friend bool operator!=(const ReturnAdjustment &LHS, const ReturnAdjustment &RHS) {
-    return !(LHS == RHS);
-  }
-
-  friend bool operator<(const ReturnAdjustment &LHS,
-                        const ReturnAdjustment &RHS) {
-    if (LHS.NonVirtual < RHS.NonVirtual)
-      return true;
-
-    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Less(RHS.Virtual);
-  }
-};
-
-/// A \c this pointer adjustment.
-struct ThisAdjustment {
-  /// The non-virtual adjustment from the derived object to its
-  /// nearest virtual base.
-  int64_t NonVirtual;
-
-  /// Holds the ABI-specific information about the virtual this
-  /// adjustment, if needed.
-  union VirtualAdjustment {
-    // Itanium ABI
-    struct {
-      /// The offset (in bytes), relative to the address point,
-      /// of the virtual call offset.
-      int64_t VCallOffsetOffset;
-    } Itanium;
-
-    struct {
-      /// The offset of the vtordisp (in bytes), relative to the ECX.
-      int32_t VtordispOffset;
-
-      /// The offset of the vbptr of the derived class (in bytes),
-      /// relative to the ECX after vtordisp adjustment.
-      int32_t VBPtrOffset;
-
-      /// The offset (in bytes) of the vbase offset in the vbtable.
-      int32_t VBOffsetOffset;
-    } Microsoft;
-
-    VirtualAdjustment() {
-      memset(this, 0, sizeof(*this));
-    }
-
-    bool Equals(const VirtualAdjustment &Other) const {
-      return memcmp(this, &Other, sizeof(Other)) == 0;
-    }
-
-    bool isEmpty() const {
-      VirtualAdjustment Zero;
-      return Equals(Zero);
-    }
-
-    bool Less(const VirtualAdjustment &RHS) const {
-      return memcmp(this, &RHS, sizeof(RHS)) < 0;
-    }
-  } Virtual;
-
-  ThisAdjustment() : NonVirtual(0) { }
-
-  bool isEmpty() const { return !NonVirtual && Virtual.isEmpty(); }
-
-  friend bool operator==(const ThisAdjustment &LHS,
-                         const ThisAdjustment &RHS) {
-    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual);
-  }
-
-  friend bool operator!=(const ThisAdjustment &LHS, const ThisAdjustment &RHS) {
-    return !(LHS == RHS);
-  }
-
-  friend bool operator<(const ThisAdjustment &LHS,
-                        const ThisAdjustment &RHS) {
-    if (LHS.NonVirtual < RHS.NonVirtual)
-      return true;
-
-    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Less(RHS.Virtual);
-  }
-};
-
-class CXXMethodDecl;
-
-/// The \c this pointer adjustment as well as an optional return
-/// adjustment for a thunk.
-struct ThunkInfo {
-  /// The \c this pointer adjustment.
-  ThisAdjustment This;
-
-  /// The return adjustment.
-  ReturnAdjustment Return;
-
-  /// Holds a pointer to the overridden method this thunk is for,
-  /// if needed by the ABI to distinguish different thunks with equal
-  /// adjustments. Otherwise, null.
-  /// CAUTION: In the unlikely event you need to sort ThunkInfos, consider using
-  /// an ABI-specific comparator.
-  const CXXMethodDecl *Method;
-
-  ThunkInfo() : Method(nullptr) { }
-
-  ThunkInfo(const ThisAdjustment &This, const ReturnAdjustment &Return,
-            const CXXMethodDecl *Method = nullptr)
-      : This(This), Return(Return), Method(Method) {}
-
-  friend bool operator==(const ThunkInfo &LHS, const ThunkInfo &RHS) {
-    return LHS.This == RHS.This && LHS.Return == RHS.Return &&
-           LHS.Method == RHS.Method;
-  }
-
-  bool isEmpty() const {
-    return This.isEmpty() && Return.isEmpty() && Method == nullptr;
-  }
-};
-
 } // end namespace clang
 
 #endif

clang/include/clang/Basic/Thunk.h

+//===----- Thunk.h - Declarations related to VTable Thunks ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Enums/classes describing THUNK related information about constructors,
+/// destructors and thunks.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_THUNK_H
+#define LLVM_CLANG_BASIC_THUNK_H
+
+#include "clang/AST/GlobalDecl.h"
+
+namespace clang {
+
+/// A return adjustment.
+struct ReturnAdjustment {
+  /// The non-virtual adjustment from the derived object to its
+  /// nearest virtual base.
+  int64_t NonVirtual;
+
+  /// Holds the ABI-specific information about the virtual return
+  /// adjustment, if needed.
+  union VirtualAdjustment {
+    // Itanium ABI
+    struct {
+      /// The offset (in bytes), relative to the address point
+      /// of the virtual base class offset.
+      int64_t VBaseOffsetOffset;
+    } Itanium;
+
+    // Microsoft ABI
+    struct {
+      /// The offset (in bytes) of the vbptr, relative to the beginning
+      /// of the derived class.
+      uint32_t VBPtrOffset;
+
+      /// Index of the virtual base in the vbtable.
+      uint32_t VBIndex;
+    } Microsoft;
+
+    VirtualAdjustment() { memset(this, 0, sizeof(*this)); }
+
+    bool Equals(const VirtualAdjustment &Other) const {
+      return memcmp(this, &Other, sizeof(Other)) == 0;
+    }
+
+    bool isEmpty() const {
+      VirtualAdjustment Zero;
+      return Equals(Zero);
+    }
+
+    bool Less(const VirtualAdjustment &RHS) const {
+      return memcmp(this, &RHS, sizeof(RHS)) < 0;
+    }
+  } Virtual;
+
+  ReturnAdjustment() : NonVirtual(0) {}
+
+  bool isEmpty() const { return !NonVirtual && Virtual.isEmpty(); }
+
+  friend bool operator==(const ReturnAdjustment &LHS,
+                         const ReturnAdjustment &RHS) {
+    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual);
+  }
+
+  friend bool operator!=(const ReturnAdjustment &LHS,
+                         const ReturnAdjustment &RHS) {
+    return !(LHS == RHS);
+  }
+
+  friend bool operator<(const ReturnAdjustment &LHS,
+                        const ReturnAdjustment &RHS) {
+    if (LHS.NonVirtual < RHS.NonVirtual)
+      return true;
+
+    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Less(RHS.Virtual);
+  }
+};
+
+/// A \c this pointer adjustment.
+struct ThisAdjustment {
+  /// The non-virtual adjustment from the derived object to its
+  /// nearest virtual base.
+  int64_t NonVirtual;
+
+  /// Holds the ABI-specific information about the virtual this
+  /// adjustment, if needed.
+  union VirtualAdjustment {
+    // Itanium ABI
+    struct {
+      /// The offset (in bytes), relative to the address point,
+      /// of the virtual call offset.
+      int64_t VCallOffsetOffset;
+    } Itanium;
+
+    struct {
+      /// The offset of the vtordisp (in bytes), relative to the ECX.
+      int32_t VtordispOffset;
+
+      /// The offset of the vbptr of the derived class (in bytes),
+      /// relative to the ECX after vtordisp adjustment.
+      int32_t VBPtrOffset;
+
+      /// The offset (in bytes) of the vbase offset in the vbtable.
+      int32_t VBOffsetOffset;
+    } Microsoft;
+
+    VirtualAdjustment() { memset(this, 0, sizeof(*this)); }
+
+    bool Equals(const VirtualAdjustment &Other) const {
+      return memcmp(this, &Other, sizeof(Other)) == 0;
+    }
+
+    bool isEmpty() const {
+      VirtualAdjustment Zero;
+      return Equals(Zero);
+    }
+
+    bool Less(const VirtualAdjustment &RHS) const {
+      return memcmp(this, &RHS, sizeof(RHS)) < 0;
+    }
+  } Virtual;
+
+  ThisAdjustment() : NonVirtual(0) {}
+
+  bool isEmpty() const { return !NonVirtual && Virtual.isEmpty(); }
+
+  friend bool operator==(const ThisAdjustment &LHS, const ThisAdjustment &RHS) {
+    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual);
+  }
+
+  friend bool operator!=(const ThisAdjustment &LHS, const ThisAdjustment &RHS) {
+    return !(LHS == RHS);
+  }
+
+  friend bool operator<(const ThisAdjustment &LHS, const ThisAdjustment &RHS) {
+    if (LHS.NonVirtual < RHS.NonVirtual)
+      return true;
+
+    return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Less(RHS.Virtual);
+  }
+};
+
+/// The \c this pointer adjustment as well as an optional return
+/// adjustment for a thunk.
+struct ThunkInfo {
+  /// Holds a pointer to the overridden (i.e. base) method this thunk is for.
+  /// CAUTION: In the unlikely event you need to sort ThunkInfos, consider using
+  /// an ABI-specific comparator.
+  GlobalDecl BaseMethod;
+
+  /// The \c this pointer adjustment.
+  ThisAdjustment This;
+
+  /// The return adjustment.
+  ReturnAdjustment Return;
+
+  ThunkInfo() = delete;
+
+  ThunkInfo(GlobalDecl BaseMethod, const ThisAdjustment &This,
+            const ReturnAdjustment &Return)
+      : BaseMethod(BaseMethod), This(This), Return(Return) {}
+
+  friend bool operator==(const ThunkInfo &LHS, const ThunkInfo &RHS) {
+    return LHS.BaseMethod == RHS.BaseMethod && LHS.This == RHS.This &&
+           LHS.Return == RHS.Return;
+  }
+
+  bool isEmpty() const { return This.isEmpty() && Return.isEmpty(); }
+};
+
+} // end namespace clang
+
+#endif

clang/lib/AST/ItaniumMangle.cpp

 //===--- ItaniumMangle.cpp - Itanium C++ Name Mangling ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements C++ name mangling according to the Itanium C++ ABI,
 // which is used in GCC 3.2 and newer (and many compilers that are
 // ABI-compatible with GCC):
 //
 //   http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/Mangle.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
-#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
+#include "clang/AST/Mangle.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/Thunk.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 
 namespace {
 

clang/lib/AST/MicrosoftMangle.cpp

void MicrosoftMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
   Mangler.mangleName(MD);
 
   // Usually the thunk uses the access specifier of the new method, but if this
   // is a covariant return thunk, then MSVC always uses the public access
   // specifier, and we do the same.
   AccessSpecifier AS = Thunk.Return.isEmpty() ? MD->getAccess() : AS_public;
   mangleThunkThisAdjustment(AS, Thunk.This, Mangler, MHO);
 
-  if (!Thunk.Return.isEmpty())
-    assert(Thunk.Method != nullptr &&
-           "Thunk info should hold the overridee decl");
-
-  const CXXMethodDecl *DeclForFPT = Thunk.Method ? Thunk.Method : MD;
-  Mangler.mangleFunctionType(
-      DeclForFPT->getType()->castAs<FunctionProtoType>(), MD);
+  Mangler.mangleFunctionType(MD->getType()->castAs<FunctionProtoType>(), MD);
 }
 
 void MicrosoftMangleContextImpl::mangleCXXDtorThunk(
     const CXXDestructorDecl *DD, CXXDtorType Type,
     const ThisAdjustment &Adjustment, raw_ostream &Out) {
   // FIXME: Actually, the dtor thunk should be emitted for vector deleting
   // dtors rather than scalar deleting dtors. Just use the vector deleting dtor
   // mangling manually until we support both deleting dtor types.

clang/lib/AST/VTableBuilder.cpp

private:
   /// final overrider.
   ThisAdjustment
   ComputeThisAdjustment(const CXXMethodDecl *MD,
                         CharUnits BaseOffsetInLayoutClass,
                         FinalOverriders::OverriderInfo Overrider);
 
   /// AddMethod - Add a single virtual member function to the vtable
   /// components vector.
-  void AddMethod(const CXXMethodDecl *MD, ReturnAdjustment ReturnAdjustment);
+  void AddMethod(const CXXMethodDecl *BaseMethod, const CXXMethodDecl *MD,
+                 ReturnAdjustment ReturnAdjustment);
 
   /// IsOverriderUsed - Returns whether the overrider will ever be used in this
   /// part of the vtable.
   ///
   /// Itanium C++ ABI 2.5.2:
   ///
   ///   struct A { virtual void f(); };
   ///   struct B : virtual public A { int i; };
void ItaniumVTableBuilder::ComputeThisAdjustments() {
   // Now go through the method info map and see if any of the methods need
   // 'this' pointer adjustments.
   for (const auto &MI : MethodInfoMap) {
     const CXXMethodDecl *MD = MI.first;
     const MethodInfo &MethodInfo = MI.second;
 
     // Ignore adjustments for unused function pointers.
     uint64_t VTableIndex = MethodInfo.VTableIndex;
-    if (Components[VTableIndex].getKind() ==
-        VTableComponent::CK_UnusedFunctionPointer)
+    const VTableComponent &component = Components[VTableIndex];
+    if (component.getKind() == VTableComponent::CK_UnusedFunctionPointer)
       continue;
 
+    GlobalDecl GD = component.getGlobalDecl();
+
     // Get the final overrider for this method.
     FinalOverriders::OverriderInfo Overrider =
       Overriders.getOverrider(MD, MethodInfo.BaseOffset);
 
     // Check if we need an adjustment at all.
     if (MethodInfo.BaseOffsetInLayoutClass == Overrider.Offset) {
       // When a return thunk is needed by a derived class that overrides a
       // virtual base, gcc uses a virtual 'this' adjustment as well.
       // While the thunk itself might be needed by vtables in subclasses or
       // in construction vtables, there doesn't seem to be a reason for using
       // the thunk in this vtable. Still, we do so to match gcc.
-      if (VTableThunks.lookup(VTableIndex).Return.isEmpty())
+      auto it = VTableThunks.find(VTableIndex);
+      if (it == VTableThunks.end() || it->second.Return.isEmpty())
         continue;
     }
 
     ThisAdjustment ThisAdjustment =
       ComputeThisAdjustment(MD, MethodInfo.BaseOffsetInLayoutClass, Overrider);
 
     if (ThisAdjustment.isEmpty())
       continue;
 
-    // Add it.
-    VTableThunks[VTableIndex].This = ThisAdjustment;
+    auto ApplyThisAdjustment = [&](unsigned Idx) {
+      Optional<ThunkInfo> TI;
+
+      auto it = VTableThunks.find(Idx);
+      if (it != VTableThunks.end()) {
+        TI = it->second;
+        TI->This = ThisAdjustment;
+      } else
+        TI = {GD, ThisAdjustment, ReturnAdjustment()};
+
+      // Override it. Note that there may or may not be a thunk already.
+      VTableThunks.erase(Idx);
+      VTableThunks.insert({Idx, *TI});
+    };
+
+    ApplyThisAdjustment(VTableIndex);
 
     if (isa<CXXDestructorDecl>(MD)) {
       // Add an adjustment for the deleting destructor as well.
-      VTableThunks[VTableIndex + 1].This = ThisAdjustment;
+      ApplyThisAdjustment(VTableIndex + 1);
     }
   }
 
   /// Clear the method info map.
   MethodInfoMap.clear();
 
   if (isBuildingConstructorVTable()) {
     // We don't need to store thunk information for construction vtables.
ThisAdjustment ItaniumVTableBuilder::ComputeThisAdjustment(
   }
 
   // Set the non-virtual part of the adjustment.
   Adjustment.NonVirtual = Offset.NonVirtualOffset.getQuantity();
 
   return Adjustment;
 }
 
-void ItaniumVTableBuilder::AddMethod(const CXXMethodDecl *MD,
+void ItaniumVTableBuilder::AddMethod(const CXXMethodDecl *BaseMethod,
+                                     const CXXMethodDecl *MD,
                                      ReturnAdjustment ReturnAdjustment) {
   if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
     assert(ReturnAdjustment.isEmpty() &&
            "Destructor can't have return adjustment!");
 
     // Add both the complete destructor and the deleting destructor.
     Components.push_back(VTableComponent::MakeCompleteDtor(DD));
     Components.push_back(VTableComponent::MakeDeletingDtor(DD));
   } else {
     // Add the return adjustment if necessary.
-    if (!ReturnAdjustment.isEmpty())
-      VTableThunks[Components.size()].Return = ReturnAdjustment;
+    if (!ReturnAdjustment.isEmpty()) {
+      assert(VTableThunks.find(Components.size()) == VTableThunks.end() &&
+             "ZZZ");
+      VTableThunks.insert(
+          {Components.size(),
+           ThunkInfo(BaseMethod, ThisAdjustment(), ReturnAdjustment)});
+    }
 
     // Add the function.
     Components.push_back(VTableComponent::MakeFunction(MD));
   }
 }
 
 /// OverridesIndirectMethodInBase - Return whether the given member function
 /// overrides any methods in the set of given bases.
if (const CXXMethodDecl *OverriddenMD =
         // method.
         assert(MethodInfoMap.count(OverriddenMD) &&
                "Did not find the overridden method!");
         MethodInfo &OverriddenMethodInfo = MethodInfoMap[OverriddenMD];
 
         MethodInfo MethodInfo(Base.getBaseOffset(), BaseOffsetInLayoutClass,
                               OverriddenMethodInfo.VTableIndex);
 
+        uint64_t VTableIndex = MethodInfo.VTableIndex;
+        const VTableComponent &component = Components[VTableIndex];
+        GlobalDecl GD = component.getGlobalDecl();
+
         assert(!MethodInfoMap.count(MD) &&
                "Should not have method info for this method yet!");
 
         MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
         MethodInfoMap.erase(OverriddenMD);
 
         // If the overridden method exists in a virtual base class or a direct
         // or indirect base class of a virtual base class, we need to emit a
if (const CXXMethodDecl *OverriddenMD =
             // the final overrider.
             BaseOffset ReturnAdjustmentOffset =
               ComputeReturnAdjustmentBaseOffset(Context, Overrider.Method, MD);
             ReturnAdjustment ReturnAdjustment =
               ComputeReturnAdjustment(ReturnAdjustmentOffset);
 
             // This is a virtual thunk for the most derived class, add it.
             AddThunk(Overrider.Method,
-                     ThunkInfo(ThisAdjustment, ReturnAdjustment));
+                     ThunkInfo(GD, ThisAdjustment, ReturnAdjustment));
           }
         }
 
         continue;
       }
     }
 
     if (MD->isImplicit())
for (const CXXMethodDecl *MD : NewVirtualFunctions) {
     // Check if this overrider needs a return adjustment.
     // We don't want to do this for pure virtual member functions.
     BaseOffset ReturnAdjustmentOffset;
     if (!OverriderMD->isPure()) {
       ReturnAdjustmentOffset =
         ComputeReturnAdjustmentBaseOffset(Context, OverriderMD, MD);
     }
 
     ReturnAdjustment ReturnAdjustment =
       ComputeReturnAdjustment(ReturnAdjustmentOffset);
 
-    AddMethod(Overrider.Method, ReturnAdjustment);
+    AddMethod(MD, Overrider.Method, ReturnAdjustment);
   }
 }
 
 void ItaniumVTableBuilder::LayoutVTable() {
   LayoutPrimaryAndSecondaryVTables(BaseSubobject(MostDerivedClass,
                                                  CharUnits::Zero()),
                                    /*BaseIsMorallyVirtual=*/false,
                                    MostDerivedClassIsVirtual,
                                    MostDerivedClassOffset);
 
case VTableComponent::CK_FunctionPointer: {
                                     MD);
       Out << Str;
       if (MD->isPure())
         Out << " [pure]";
 
       if (MD->isDeleted())
         Out << " [deleted]";
 
-      ThunkInfo Thunk = VTableThunks.lookup(I);
-      if (!Thunk.isEmpty()) {
+      auto it = VTableThunks.find(I);
+      if (it != VTableThunks.end()) {
+        ThunkInfo Thunk = it->second;
         // If this function pointer has a return adjustment, dump it.
         if (!Thunk.Return.isEmpty()) {
           Out << "\n       [return adjustment: ";
           Out << Thunk.Return.NonVirtual << " non-virtual";
 
           if (Thunk.Return.Virtual.Itanium.VBaseOffsetOffset) {
             Out << ", " << Thunk.Return.Virtual.Itanium.VBaseOffsetOffset;
             Out << " vbase offset offset";
case VTableComponent::CK_DeletingDtorPointer: {
       if (IsComplete)
         Out << "() [complete]";
       else
         Out << "() [deleting]";
 
       if (DD->isPure())
         Out << " [pure]";
 
-      ThunkInfo Thunk = VTableThunks.lookup(I);
-      if (!Thunk.isEmpty()) {
+      auto it = VTableThunks.find(I);
+      if (it != VTableThunks.end()) {
+        ThunkInfo Thunk = it->second;
         // If this destructor has a 'this' pointer adjustment, dump it.
         if (!Thunk.This.isEmpty()) {
           Out << "\n       [this adjustment: ";
           Out << Thunk.This.NonVirtual << " non-virtual";
 
           if (Thunk.This.Virtual.Itanium.VCallOffsetOffset) {
             Out << ", " << Thunk.This.Virtual.Itanium.VCallOffsetOffset;
             Out << " vcall offset offset";
if (!Thunks.empty()) {
     }
 
     for (const auto &I : MethodNamesAndDecls) {
       const std::string &MethodName = I.first;
       const CXXMethodDecl *MD = I.second;
 
       ThunkInfoVectorTy ThunksVector = Thunks[MD];
       llvm::sort(ThunksVector, [](const ThunkInfo &LHS, const ThunkInfo &RHS) {
-        assert(LHS.Method == nullptr && RHS.Method == nullptr);
         return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return);
       });
 
       Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size();
       Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n";
 
       for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) {
         const ThunkInfo &Thunk = ThunksVector[I];
private:
   /// method, relative to the beginning of the MostDerivedClass.
   CharUnits ComputeThisOffset(FinalOverriders::OverriderInfo Overrider);
 
   void CalculateVtordispAdjustment(FinalOverriders::OverriderInfo Overrider,
                                    CharUnits ThisOffset, ThisAdjustment &TA);
 
   /// AddMethod - Add a single virtual member function to the vftable
   /// components vector.
-  void AddMethod(const CXXMethodDecl *MD, ThunkInfo TI) {
-    if (!TI.isEmpty()) {
-      VTableThunks[Components.size()] = TI;
-      AddThunk(MD, TI);
-    }
+  void AddMethod(const CXXMethodDecl *BaseMD, const CXXMethodDecl *MD,
+                 ThisAdjustment This, ReturnAdjustment Return) {
     if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
-      assert(TI.Return.isEmpty() &&
-             "Destructor can't have return adjustment!");
+      assert(Return.isEmpty() && "Destructor can't have return adjustment!");
       Components.push_back(VTableComponent::MakeDeletingDtor(DD));
     } else {
       Components.push_back(VTableComponent::MakeFunction(MD));
     }
+
+    GlobalDecl GD;
+    if (isa<CXXDestructorDecl>(BaseMD))
+      GD = GlobalDecl(cast<CXXDestructorDecl>(BaseMD),
+                      CXXDtorType::Dtor_Deleting);
+    else
+      GD = BaseMD;
+
+    ThunkInfo TI(GD, This, Return);
+    if (!TI.isEmpty()) {
+      assert(VTableThunks.find(Components.size() - 1) == VTableThunks.end() &&
+             "ZZZ");
+      VTableThunks.insert({Components.size() - 1, TI});
+      AddThunk(MD, TI);
+    }
   }
 
   /// AddMethods - Add the methods of this base subobject and the relevant
   /// subbases to the vftable we're currently laying out.
   void AddMethods(BaseSubobject Base, unsigned BaseDepth,
                   const CXXRecordDecl *LastVBase,
                   BasesSetVectorTy &VisitedBases);
 
if (!ReturnAdjustmentOffset.isEmpty()) {
         ReturnAdjustment.Virtual.Microsoft.VBPtrOffset =
             DerivedLayout.getVBPtrOffset().getQuantity();
         ReturnAdjustment.Virtual.Microsoft.VBIndex =
             VTables.getVBTableIndex(ReturnAdjustmentOffset.DerivedClass,
                                     ReturnAdjustmentOffset.VirtualBase);
       }
     }
 
-    AddMethod(FinalOverriderMD,
-              ThunkInfo(ThisAdjustmentOffset, ReturnAdjustment,
-                        ForceReturnAdjustmentMangling ? MD : nullptr));
+    AddMethod(MD, FinalOverriderMD, ThisAdjustmentOffset, ReturnAdjustment);
   }
 }
 
 static void PrintBasePath(const VPtrInfo::BasePath &Path, raw_ostream &Out) {
   for (const CXXRecordDecl *Elem :
        llvm::make_range(Path.rbegin(), Path.rend())) {
     Out << "'";
     Elem->printQualifiedName(Out);
     Out << "' in ";
   }
 }
 
 static void dumpMicrosoftThunkAdjustment(const ThunkInfo &TI, raw_ostream &Out,
                                          bool ContinueFirstLine) {
   const ReturnAdjustment &R = TI.Return;
   bool Multiline = false;
   const char *LinePrefix = "\n       ";
-  if (!R.isEmpty() || TI.Method) {
+  if (!R.isEmpty()) {
     if (!ContinueFirstLine)
       Out << LinePrefix;
     Out << "[return adjustment (to type '"
-        << TI.Method->getReturnType().getCanonicalType().getAsString()
+        << cast<CXXMethodDecl>(TI.BaseMethod.getDecl())
+               ->getReturnType()
+               .getCanonicalType()
+               .getAsString()
         << "'): ";
     if (R.Virtual.Microsoft.VBPtrOffset)
       Out << "vbptr at offset " << R.Virtual.Microsoft.VBPtrOffset << ", ";
     if (R.Virtual.Microsoft.VBIndex)
       Out << "vbase #" << R.Virtual.Microsoft.VBIndex << ", ";
     Out << R.NonVirtual << " non-virtual]";
     Multiline = true;
   }
case VTableComponent::CK_FunctionPointer: {
           PredefinedExpr::PrettyFunctionNoVirtual, MD);
       Out << Str;
       if (MD->isPure())
         Out << " [pure]";
 
       if (MD->isDeleted())
         Out << " [deleted]";
 
-      ThunkInfo Thunk = VTableThunks.lookup(I);
-      if (!Thunk.isEmpty())
+      auto it = VTableThunks.find(I);
+      if (it != VTableThunks.end()) {
+        ThunkInfo Thunk = it->second;
         dumpMicrosoftThunkAdjustment(Thunk, Out, /*ContinueFirstLine=*/false);
+      }
 
       break;
     }
 
     case VTableComponent::CK_DeletingDtorPointer: {
       const CXXDestructorDecl *DD = Component.getDestructorDecl();
 
       DD->printQualifiedName(Out);
       Out << "() [scalar deleting]";
 
       if (DD->isPure())
         Out << " [pure]";
 
-      ThunkInfo Thunk = VTableThunks.lookup(I);
-      if (!Thunk.isEmpty()) {
+      auto it = VTableThunks.find(I);
+      if (it != VTableThunks.end()) {
+        ThunkInfo Thunk = it->second;
         assert(Thunk.Return.isEmpty() &&
                "No return adjustment needed for destructors!");
         dumpMicrosoftThunkAdjustment(Thunk, Out, /*ContinueFirstLine=*/false);
       }
 
       break;
     }
 

clang/lib/CodeGen/CGVTables.cpp

void CodeGenFunction::FinishThunk() {
   // Clear these to restore the invariants expected by
   // StartFunction/FinishFunction.
   CurCodeDecl = nullptr;
   CurFuncDecl = nullptr;
 
   FinishFunction();
 }
 
-void CodeGenFunction::EmitCallAndReturnForThunk(llvm::FunctionCallee Callee,
+void CodeGenFunction::EmitCallAndReturnForThunk(const CGFunctionInfo &CallInfo,
+                                                llvm::FunctionCallee Callee,
+                                                GlobalDecl CalleeGD,
                                                 const ThunkInfo *Thunk,
                                                 bool IsUnprototyped) {
   assert(isa<CXXMethodDecl>(CurGD.getDecl()) &&
          "Please use a new CGF for this thunk");
   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CurGD.getDecl());
 
   // Adjust the 'this' pointer if necessary
   llvm::Value *AdjustedThisPtr =
#endif
   if (!ResultType->isVoidType() &&
       (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect ||
        hasAggregateEvaluationKind(ResultType)))
     Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified(),
                            /*IsUnused=*/false, /*IsExternallyDestructed=*/true);
 
   // Now emit our call.
   llvm::CallBase *CallOrInvoke;
-  RValue RV = EmitCall(*CurFnInfo, CGCallee::forDirect(Callee, CurGD), Slot,
+  RValue RV = EmitCall(CallInfo, CGCallee::forDirect(Callee, CalleeGD), Slot,
                        CallArgs, &CallOrInvoke);
 
   // Consider return adjustment if we have ThunkInfo.
   if (Thunk && !Thunk->Return.isEmpty())
     RV = PerformReturnAdjustment(*this, ResultType, RV, *Thunk);
   else if (llvm::CallInst* Call = dyn_cast<llvm::CallInst>(CallOrInvoke))
     Call->setTailCallKind(llvm::CallInst::TCK_Tail);
 
void CodeGenFunction::EmitMustTailThunk(GlobalDecl GD,
 
   // Finish the function to maintain CodeGenFunction invariants.
   // FIXME: Don't emit unreachable code.
   EmitBlock(createBasicBlock());
 
   FinishThunk();
 }
 
-void CodeGenFunction::generateThunk(llvm::Function *Fn,
-                                    const CGFunctionInfo &FnInfo, GlobalDecl GD,
-                                    const ThunkInfo &Thunk,
+void CodeGenFunction::generateThunk(llvm::Function *ThunkFn,
+                                    const CGFunctionInfo &ThunkFnInfo,
+                                    GlobalDecl GD, const ThunkInfo &Thunk,
                                     bool IsUnprototyped) {
-  StartThunk(Fn, GD, FnInfo, IsUnprototyped);
+  StartThunk(ThunkFn, Thunk.BaseMethod, ThunkFnInfo, IsUnprototyped);
   // Create a scope with an artificial location for the body of this function.
   auto AL = ApplyDebugLocation::CreateArtificial(*this);
 
+  const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD);
+  llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
+
   // Get our callee. Use a placeholder type if this method is unprototyped so
   // that CodeGenModule doesn't try to set attributes.
   llvm::Type *Ty;
   if (IsUnprototyped)
     Ty = llvm::StructType::get(getLLVMContext());
   else
     Ty = CGM.getTypes().GetFunctionType(FnInfo);
 
   llvm::Constant *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 
   // Fix up the function type for an unprototyped musttail call.
   if (IsUnprototyped)
-    Callee = llvm::ConstantExpr::getBitCast(Callee, Fn->getType());
+    Callee = llvm::ConstantExpr::getBitCast(Callee, FnTy);
 
   // Make the call and return the result.
-  EmitCallAndReturnForThunk(llvm::FunctionCallee(Fn->getFunctionType(), Callee),
+  EmitCallAndReturnForThunk(FnInfo, llvm::FunctionCallee(FnTy, Callee), GD,
                             &Thunk, IsUnprototyped);
 }
 
 static bool shouldEmitVTableThunk(CodeGenModule &CGM, const CXXMethodDecl *MD,
                                   bool IsUnprototyped, bool ForVTable) {
   // Always emit thunks in the MS C++ ABI. We cannot rely on other TUs to
   // provide thunks for us.
   if (CGM.getTarget().getCXXABI().isMicrosoft())
llvm::Constant *CodeGenVTables::maybeEmitThunk(GlobalDecl GD,
 
   // First, get a declaration. Compute the mangled name. Don't worry about
   // getting the function prototype right, since we may only need this
   // declaration to fill in a vtable slot.
   SmallString<256> Name;
   MangleContext &MCtx = CGM.getCXXABI().getMangleContext();
   llvm::raw_svector_ostream Out(Name);
   if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD))
     MCtx.mangleCXXDtorThunk(DD, GD.getDtorType(), TI.This, Out);
   else
     MCtx.mangleThunk(MD, TI, Out);
+
   llvm::Type *ThunkVTableTy = CGM.getTypes().GetFunctionTypeForVTable(GD);
   llvm::Constant *Thunk = CGM.GetAddrOfThunk(Name, ThunkVTableTy, GD);
 
   // If we don't need to emit a definition, return this declaration as is.
   bool IsUnprototyped = !CGM.getTypes().isFuncTypeConvertible(
-      MD->getType()->castAs<FunctionType>());
+      cast<CXXMethodDecl>(TI.BaseMethod.getDecl())
+          ->getType()
+          ->castAs<FunctionType>());
   if (!shouldEmitVTableThunk(CGM, MD, IsUnprototyped, ForVTable))
     return Thunk;
 
-  // Arrange a function prototype appropriate for a function definition. In some
+  // Arrange a thunk function prototype appropriate for a function def. In some
   // cases in the MS ABI, we may need to build an unprototyped musttail thunk.
-  const CGFunctionInfo &FnInfo =
-      IsUnprototyped ? CGM.getTypes().arrangeUnprototypedMustTailThunk(MD)
-                     : CGM.getTypes().arrangeGlobalDeclaration(GD);
-  llvm::FunctionType *ThunkFnTy = CGM.getTypes().GetFunctionType(FnInfo);
+  const CGFunctionInfo &ThunkFnInfo =
+      IsUnprototyped ? CGM.getTypes().arrangeUnprototypedMustTailThunk(
+                           cast<CXXMethodDecl>(TI.BaseMethod.getDecl()))
+                     : CGM.getTypes().arrangeGlobalDeclaration(TI.BaseMethod);
+  llvm::FunctionType *ThunkFnTy = CGM.getTypes().GetFunctionType(ThunkFnInfo);
 
   // If the type of the underlying GlobalValue is wrong, we'll have to replace
   // it. It should be a declaration.
   llvm::Function *ThunkFn = cast<llvm::Function>(Thunk->stripPointerCasts());
   if (ThunkFn->getFunctionType() != ThunkFnTy) {
     llvm::GlobalValue *OldThunkFn = ThunkFn;
 
-    assert(OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration");
+    // assert(OldThunkFn->isDeclaration() && "Shouldn't replace
+    // non-declaration");
 
     // Remove the name from the old thunk function and get a new thunk.
     OldThunkFn->setName(StringRef());
     ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage,
                                      Name.str(), &CGM.getModule());
-    CGM.SetLLVMFunctionAttributes(MD, FnInfo, ThunkFn);
+    CGM.SetLLVMFunctionAttributes(GD, ThunkFnInfo, ThunkFn);
 
     // If needed, replace the old thunk with a bitcast.
     if (!OldThunkFn->use_empty()) {
       llvm::Constant *NewPtrForOldDecl =
           llvm::ConstantExpr::getBitCast(ThunkFn, OldThunkFn->getType());
       OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
     }
 
     // Remove the old thunk.
     OldThunkFn->eraseFromParent();
   }
 
   bool ABIHasKeyFunctions = CGM.getTarget().getCXXABI().hasKeyFunctions();
   bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions;
 
   if (!ThunkFn->isDeclaration()) {
     if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) {
       // There is already a thunk emitted for this function, do nothing.
       return ThunkFn;
     }
 
     setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD);
     return ThunkFn;
   }
 
   // If this will be unprototyped, add the "thunk" attribute so that LLVM knows
   // that the return type is meaningless. These thunks can be used to call
   // functions with differing return types, and the caller is required to cast
   // the prototype appropriately to extract the correct value.
   if (IsUnprototyped)
     ThunkFn->addFnAttr("thunk");
 
-  CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn);
+  CGM.SetLLVMFunctionAttributesForDefinition(MD, ThunkFn);
 
   // Thunks for variadic methods are special because in general variadic
   // arguments cannot be perfectly forwarded. In the general case, clang
   // implements such thunks by cloning the original function body. However, for
   // thunks with no return adjustment on targets that support musttail, we can
   // use musttail to perfectly forward the variadic arguments.
   bool ShouldCloneVarArgs = false;
   if (!IsUnprototyped && ThunkFn->isVarArg()) {
if (TI.Return.isEmpty()) {
       }
     }
   }
 
   if (ShouldCloneVarArgs) {
     if (UseAvailableExternallyLinkage)
       return ThunkFn;
     ThunkFn =
-        CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, TI);
+        CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, ThunkFnInfo, GD, TI);
   } else {
     // Normal thunk body generation.
-    CodeGenFunction(CGM).generateThunk(ThunkFn, FnInfo, GD, TI, IsUnprototyped);
+    CodeGenFunction(CGM).generateThunk(ThunkFn, ThunkFnInfo, GD, TI,
+                                       IsUnprototyped);
   }
 
   setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD);
   return ThunkFn;
 }
 
 void CodeGenVTables::EmitThunks(GlobalDecl GD) {
   const CXXMethodDecl *MD =
     cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
 
   // We don't need to generate thunks for the base destructor.
if (useRelativeLayout())
                                   vtableHasLocalLinkage,
                                   /*isCompleteDtor=*/false);
     else
       return builder.add(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()) {
-    default:
-      llvm_unreachable("Unexpected vtable component kind");
-    case VTableComponent::CK_FunctionPointer:
-      GD = component.getFunctionDecl();
-      break;
-    case VTableComponent::CK_CompleteDtorPointer:
-      GD = GlobalDecl(component.getDestructorDecl(), Dtor_Complete);
-      break;
-    case VTableComponent::CK_DeletingDtorPointer:
-      GD = GlobalDecl(component.getDestructorDecl(), Dtor_Deleting);
-      break;
-    }
+    GlobalDecl GD = component.getGlobalDecl();
 
     if (CGM.getLangOpts().CUDA) {
       // Emit NULL for methods we can't codegen on this
       // side. Otherwise we'd end up with vtable with unresolved
       // references.
       const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
       // OK on device side: functions w/ __device__ attribute
       // OK on host side: anything except __device__-only functions.

clang/lib/CodeGen/CodeGenFunction.h

public:
 
   /// FinishFunction - Complete IR generation of the current function. It is
   /// legal to call this function even if there is no current insertion point.
   void FinishFunction(SourceLocation EndLoc=SourceLocation());
 
   void StartThunk(llvm::Function *Fn, GlobalDecl GD,
                   const CGFunctionInfo &FnInfo, bool IsUnprototyped);
 
-  void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee,
-                                 const ThunkInfo *Thunk, bool IsUnprototyped);
+  void EmitCallAndReturnForThunk(const CGFunctionInfo &CallInfo,
+                                 llvm::FunctionCallee Callee,
+                                 GlobalDecl CalleeGD, const ThunkInfo *Thunk,
+                                 bool IsUnprototyped);
 
   void FinishThunk();
 
   /// Emit a musttail call for a thunk with a potentially adjusted this pointer.
   void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr,
                          llvm::FunctionCallee Callee);
 
   /// Generate a thunk for the given method.
-  void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
+  void generateThunk(llvm::Function *ThunkFn, const CGFunctionInfo &ThunkFnInfo,
                      GlobalDecl GD, const ThunkInfo &Thunk,
                      bool IsUnprototyped);
 
   llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
                                        const CGFunctionInfo &FnInfo,
                                        GlobalDecl GD, const ThunkInfo &Thunk);
 
   void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,

clang/test/CodeGenCXX/thunk-linkonce-odr.cpp

 
 int g() {
   D d;
   return f(&d);
 }
 
 // Thunks should be marked as "linkonce ODR" not "weak".
 //
-// CHECK: define linkonce_odr i32 @_ZThn{{[48]}}_N1D1fEv
 // CHECK: define linkonce_odr i32 @_ZThn{{[48]}}_N1C1fEv
+// CHECK: define linkonce_odr i32 @_ZThn{{[48]}}_N1D1fEv

clang/test/CodeGenCXX/thunk-returning-memptr.cpp

 };
 
 C::C() {}
 
 // Make sure the member pointer is returned from the thunk via the return slot.
 // Because of the tail call, the return value cannot be copied into a local
 // alloca. (PR39901)
 
-// CHECK-LABEL: define linkonce_odr void @_ZThn4_N1C1fEv({ i32, i32 }* noalias sret({ i32, i32 }) align 4 %agg.result, %struct.C* {{[^,]*}} %this)
+// CHECK-LABEL: define linkonce_odr void @_ZThn4_N1C1fEv({ i32, i32 }* noalias sret({ i32, i32 }) align 4 %agg.result, %struct.B* {{[^,]*}} %this.coerce)
 // CHECK: tail call void @_ZN1C1fEv({ i32, i32 }* sret({ i32, i32 }) align 4 %agg.result

clang/test/CodeGenCXX/thunk-wrong-return-type.cpp

+// RUN: %clang_cc1 -emit-llvm-only -triple %itanium_abi_triple %s -emit-llvm -o - %s | FileCheck %s
+
+struct A {};
+struct alignas(32) B : virtual A {
+  char c[32];
+};
+struct Pad {
+  char c[7];
+};
+struct C : B, Pad, virtual A {};
+
+struct X {
+  virtual A &f();
+};
+struct U {
+  virtual ~U();
+};
+C c;
+struct Y : U, X {
+  virtual B &f() override { return c; }
+};
+
+Y y;
+
+// CHECK: define linkonce_odr nonnull align 1 dereferenceable(1) %struct.A.8* @_ZTchn8_v0_n24_N1Y1fEv(%struct.X.7* nonnull dereferenceable(8) %this.coerce) #1 comdat align 2 {

clang/test/CodeGenCXX/thunk-wrong-this.cpp

+// RUN: %clang_cc1 -emit-llvm-only -triple %itanium_abi_triple %s -emit-llvm -o - %s | FileCheck %s
+
+class Base1 {
+  virtual void Foo1();
+};
+
+class Base2 {
+  virtual void Foo2();
+};
+
+class alignas(16) Obj : public Base1, public Base2 {
+  void Foo1() override;
+  void Foo2() override;
+  ~Obj();
+};
+
+void Obj::Foo1() {}
+void Obj::Foo2() {}
+
+// CHECK: define dso_local void @_ZThn8_N3Obj4Foo2Ev(%class.Base2.2* nonnull dereferenceable(8) %this.coerce) #1 align 2 {
+// CHECK: tail call void @_ZN3Obj4Foo2Ev(%class.Obj.0* nonnull dereferenceable(16) %2)