test/CodeGenCXX/debug-info-thunk.cpp

// RUN: %clang_cc1 %s -triple=x86_64-pc-windows-msvc -debug-info-kind=limited -S -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -triple %itanium_abi_triple -debug-info-kind=limited -S -emit-llvm -o - | FileCheck %s -check-prefix=ITANIUM
//
// Validate we emit a "DIFlagThunk" flag on DISubprogram entries for thunks.
// This flag is used for emitting S_THUNK32 symbols for CodeView debugging.
//
// NOTE:
// Because thunks are compiler generated and don't exist in the source, this
// test is dependent upon the linkage name to identify the thunk.  Any changes
// in the name mangling may require this test to be updated.
//
// NOTE:
// The FileCheck directives below use CHECK-DAG because the thunks may not be
// emitted in source order.
//

namespace Test1 {
  struct A {
    virtual void f();
  };
  
  struct B {
    virtual void f();
  };
  
  struct C : A, B {
    virtual void c();
    
    virtual void f();
  };
  
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test1@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
  void C::f() { }
}

namespace Test2 {
  struct V1 { };
  struct V2 : virtual V1 { };
  
  struct A {
    virtual V1 *f();
  };
  
  struct B : A {
    virtual void b();
    
    virtual V2 *f();
  };
  
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@B@Test2@@QEAAPEAUV1@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
  V2 *B::f() { return 0; }
}

namespace Test3 {
  struct A {
    virtual void f();
  };
  
  struct B {
    virtual void f();
  };
  
  struct __attribute__((visibility("protected"))) C : A, B {
    virtual void c();
    
    virtual void f();
  };
  
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test3@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
  void C::f() { }
}

namespace Test4 {
  struct A {
    virtual void f();
  };

  struct B {
    virtual void f();
  };

  namespace {
    struct C : A, B {
      virtual void c();
      virtual void f();
    };
  }
  void C::c() {}
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@?A0x{{[^@]*}}@Test4@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
  void C::f() {}

  // Force C::f to be used.
  void f() { 
    C c; 
    c.f();
  }
}

namespace Test5 {
  struct X {
    X();
    X(const X&);
    X &operator=(const X&);
    ~X();
  };

  struct P {
    P();
    P(const P&);
    ~P();
    X first;
    X second;
  };

  P getP();

  struct Base1 {
    int i;

    virtual X f() { return X(); }
  };

  struct Base2 {
    float real;

    virtual X f() { return X(); }
  };

  struct Thunks : Base1, Base2 {
    long l;

    virtual X f();
  };

// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@Thunks@Test5@@WBA@EAA?AUX@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
  X Thunks::f() { return X(); }
}

namespace Test6 {
  struct X {
    X();
    X(const X&);
    X &operator=(const X&);
    ~X();
  };

  struct Small { short s; };
  struct Large {
    char array[1024];
  };

  class A {
  protected:
    virtual void foo() = 0;
  };

  class B : public A {
  protected:
    virtual void bar() = 0;
  };

  class C : public A  {
  protected:
    virtual void baz(X, X&, _Complex float, Small, Small&, Large) = 0;
  };

  class D : public B,
            public C {
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo@D@Test6@@G7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
    void foo() {}
    void bar() {}
    void baz(X, X&, _Complex float, Small, Small&, Large);
  };

  void D::baz(X, X&, _Complex float, Small, Small&, Large) { }

  void testD() { D d; }
}

namespace Test7 {
  struct A { virtual void foo(); };
  struct B { virtual void foo(); };
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo@C@Test7@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
  struct C : A, B { void foo() {} };

  // Test later.
  void test() {
    C c;
  }
}

namespace Test8 {
  struct A {             virtual A* f(); };
  struct B : virtual A { virtual A* f(); };
  struct C : B         { virtual C* f(); };
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test8@@QEAAPEAUA@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
  C* C::f() { return 0; }
}

namespace Test9 {
  struct B1 {
    virtual B1 &foo1();
  };
  struct Pad1 {
    virtual ~Pad1();
  };
  struct Proxy1 : Pad1, B1 {
    virtual ~Proxy1();
  };
  struct D : virtual Proxy1 {
    virtual ~D();
    virtual D &foo1();
  };
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo1@D@Test9@@$4PPPPPPPE@A@EAAAEAUB1@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo1@D@Test9@@$4PPPPPPPE@A@EAAAEAU12@XZ"{{.*}} flags: {{.*}}DIFlagThunk
  D& D::foo1() {
    return *this;
  }
}

namespace Test10 {
  class A {
    virtual void f();
  };
  class B {
    virtual void f();
  };
  class C : public A, public B  {
    virtual void f();
  };
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test10@@G7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
  void C::f() {
  }
}

namespace Test11 {
  class A {
  public:
    virtual void f();
  };

  void test() {
// CHECK-DAG: DISubprogram{{.*}}linkageName: "??_9A@Test11@@$BA@AA"{{.*}} flags: {{.*}}DIFlagThunk
    void (A::*p)() = &A::f;
  }
}

namespace Test12 {
  struct A {
    virtual void f();
  };
  
  struct B {
    virtual void f();
  };
  
  struct C : A, B {
    virtual void f();
  };
  
  void C::f() { }
  // ITANIUM: define {{.*}}void @_ZThn{{[48]}}_N6Test121C1fEv
  // ITANIUM-SAME: !dbg ![[SP:[0-9]+]]
  // ITANIUM-NOT: {{ret }}
  // ITANIUM: = load{{.*}} !dbg ![[DBG:[0-9]+]]
  // ITANIUM-NOT: {{ret }}
  // ITANIUM: ret void, !dbg ![[DBG]]
  //
  // ITANIUM: ![[SP]] = distinct !DISubprogram(linkageName: "_ZThn{{[48]}}_N6Test121C1fEv"
  // ITANIUM-SAME:          line: 261
  // ITANIUM-SAME:          DIFlagArtificial
  // ITANIUM-SAME:          DIFlagThunk
  // ITANIUM-SAME:          DISPFlagDefinition
  // ITANIUM-SAME:          ){{$}}
  //
  // ITANIUM: ![[DBG]] = !DILocation(line: 0
}