[Itanium] Emit type info names with external linkage.

[EricWF]

Summary

The Itanium ABI requires that the type info for pointer-to-incomplete types to have internal linkage, so that it doesn't interfere with the type info once completed. Currently it also marks the type info name as internal as well. However, this causes a bug with the STL implementations, which use the type info name pointer to perform ordering and hashing of type infos.
For example:

// header.h
struct T;
extern std::type_info const& Info;

// tu_one.cpp
#include "header.h"
std::type_info const& Info = typeid(T*);

// tu_two.cpp
#include "header.h"
struct T {};
int main() {
  auto &TI1 = Info;
  auto &TI2 = typeid(T*);
  assert(TI1 == TI2); // Fails
  assert(TI1.hash_code() == TI2.hash_code()); // Fails
}

This patch fixes the STL bug by emitting the type info name as linkonce_odr when the type-info is for a pointer-to-incomplete type.

Note that libc++ could fix this without a compiler change, but the quality of fix would be poor. The library would either have to:

(A) Always perform strcmp/string hashes.
(B) Determine if we have a pointer-to-incomplete type, and only do strcmp then. This would require an ABI break for libc++.

[EricWF]

• Correct copy-paste error.

[rsmith]

lib/CodeGen/ItaniumCXXABI.cpp

3033

Shouldn't this be based on the type's linkage? Eg:

namespace { struct Incomplete; }
auto x = typeid(Incomplete*);

should have an internal type info name, not a linkonce_odr name. I think we should compute the linkage per the code below and then demote the type's linkage to internal in the incomplete-class case.

3034–3035

Should we promote the type info name in this case too? (We get here for the incomplete-class type info we generate as a detail of the pointer type info, but the names of such types are accessible via the <cxx_abi.h> interface, so it seems reasonable to apply the same global-uniqueness to them too.)

[EricWF]

@rsmith What should the visibility of the type name be in cases where the type info is hidden?

lib/CodeGen/ItaniumCXXABI.cpp

3033

That sounds correct to me.

3034–3035

Hmm. I think it seems reasonable.

I don't think there exists a case where a user can perform type_info equality or hashing on an incomplete class type, so in terms of solving the libc++ bug I think it's unneeded. (which is why I omitted it).

I also don't see exactly what part of cxxabi.h might expose the type_info to users in a way where type name pointer equality is important to the user.

What would you rather?

[EricWF]

Address @rsmith's inline comments.

• Calculate the linkage for the type name using the linkage for the type.
• Promote the type name visibility for the incomplete class types as well as for pointer and member pointers.

[rjmccall]

lib/CodeGen/ItaniumCXXABI.cpp

3098

I think we could probably just have the function return both instead of requiring the callee to make two calls.

3098

"caller" instead of "callee", of course.

3110

This should be the name linkage, I think. The targets using non-unique RTTI names (i.e. Darwin ARM64) would want this bit to be set for the types they use non-unique RTTI names for, i.e. for external types with default visibility, even if the type is incomplete in the current translation unit and thus the type_info object has been demoted to internal linkage. (A complete type with internal linkage should not have the bit set.)

[EricWF]

Address @rjmccall's comments.

[rjmccall]

Looks really good, thanks.

[EricWF]

@rjmccall Thank you for the quick review!

[EricWF]

Re-opening. I had to revert the last commit since it seemed to cause error (which looked unrelated?) on ppc64le-linux.

[rsmith]

This is causing ASan's ODR violation detector to fire. I think the problematic case looks like this:

TU 1:

struct X;
/*...*/ typeid(X*); /*...*/

TU 2:

struct X { virtual void f(); };
void X::f() {}

Now, TU 1 will emit a linkonce_odr definition of the _ZTS symbol, and TU 2 will emit a strong definition of it. ASan doesn't like that.

There's no way we can know that there will be a strong definition of the typeinfo name at the point where we emit the tentative copy for the pointer type_info. It seems to me there are two things we could do about this:

1. decide this is not a bug and suppress the ASan ODR checker report, or
2. decide this is a bug, and only emit linkonce_odr typeinfo names for pointers to incomplete classes, not for incomplete classes themselves (this would mean that operator== etc would do the wrong thing for users who use the <cxxabi.h> to inspect the pointee type of a pointer type info; in particular, we'd need to check that ubsan's vptr sanitizer can cope with this -- right now it assumes that it can compare the type name address except on iOS64, just like libc++'s <type_info> does).

[rjmccall]

I believe static and dynamic linkers — at least on ELF and Mach-O — will always drop weak symbols for strong ones. Now, I think that isn't LLVM's posted semantics for linkonce_odr, but to me that means that LLVM's semantics are inadequate, not that we should decline to take advantage of them.

If we can't rely on that, it probably means that the type name symbol for class types always has to be linkonce_odr, even if it's for a type with a key function.

[rsmith]

In D46665#1102290, @rjmccall wrote:

I believe static and dynamic linkers — at least on ELF and Mach-O — will always drop weak symbols for strong ones. Now, I think that isn't LLVM's posted semantics for linkonce_odr, but to me that means that LLVM's semantics are inadequate, not that we should decline to take advantage of them.

If we can't rely on that, it probably means that the type name symbol for class types always has to be linkonce_odr, even if it's for a type with a key function.

That all makes sense to me. (But I think weak_odr would be more formally correct, even though the symbol will never actually be discarded as it's referenced from the type_info and vtable.)

The rule that ASan is using is that if there is an external definition for a global variable, there should not be any other definitions for that symbol, which seems right given LLVM's semantics, but wrong here.

For now, the simplest thing to do seem to be to weaken external linkage to weak_odr for the type info name.

[efriedma]

The only difference between weak_odr and linkonce_odr is that the LLVM optimizers can discard linkonce_odr globals. From your description, you want to remove the odr-ness, by changing the linkage to "linkonce", I think?

That said, I don't think the usage here violates LangRef's definition of linkonce_odr; the "odr"-ness refers to the global's initializer, not its linkage.

[rsmith]

In D46665#1102361, @efriedma wrote:

The only difference between weak_odr and linkonce_odr is that the LLVM optimizers can discard linkonce_odr globals. From your description, you want to remove the odr-ness, by changing the linkage to "linkonce", I think?

The odr-ness is fine; the definitions are all the same. The symbol emitted with the key function should be non-discardable, which is why I'm suggesting we change the linkage to weak_odr rather than changing it to linkonce_odr.

[efriedma]

What exactly is the asan odr checker actually checking for? The distinction between common/linkonce_odr/linkonce/weak_odr/weak only affects IR optimizers, not code generation.

[rsmith]

In D46665#1102413, @efriedma wrote:

What exactly is the asan odr checker actually checking for? The distinction between common/linkonce_odr/linkonce/weak_odr/weak only affects IR optimizers, not code generation.

It's checking that there is only one definition of each global variable for which only one definition is expected; it believes that if there is an external definition, then there should not be any other definitions.

[rjmccall]

In D46665#1102348, @rsmith wrote:

In D46665#1102290, @rjmccall wrote:

I believe static and dynamic linkers — at least on ELF and Mach-O — will always drop weak symbols for strong ones. Now, I think that isn't LLVM's posted semantics for linkonce_odr, but to me that means that LLVM's semantics are inadequate, not that we should decline to take advantage of them.

If we can't rely on that, it probably means that the type name symbol for class types always has to be linkonce_odr, even if it's for a type with a key function.

That all makes sense to me. (But I think weak_odr would be more formally correct, even though the symbol will never actually be discarded as it's referenced from the type_info and vtable.)

Yes, of course.

The rule that ASan is using is that if there is an external definition for a global variable, there should not be any other definitions for that symbol, which seems right given LLVM's semantics, but wrong here.

I agree.

For now, the simplest thing to do seem to be to weaken external linkage to weak_odr for the type info name.

Yes.

[rsmith]

Please see https://reviews.llvm.org/D47092 for the external -> weak_odr change.

[ldionne]

Note: this commit was re-reverted in

commit bbb2655de0049f8e6cf4482702aa616011c851c1
Author: Richard Smith <[e-mail]>
Date:   Mon May 21 20:10:54 2018 +0000

    Revert r332028; see PR37545 for details.

    llvm-svn: 332879

lib/CodeGen/ItaniumCXXABI.cpp

VTable =
       llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
   VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
 
   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) {
-  // Itanium C++ ABI 2.9.5p7:
-  //   In addition, it and all of the intermediate abi::__pointer_type_info
-  //   structs in the chain down to the abi::__class_type_info for the
-  //   incomplete class type must be prevented from resolving to the
-  //   corresponding type_info structs for the complete class type, possibly
-  //   by making them local static objects. Finally, a dummy class RTTI is
-  //   generated for the incomplete type that will not resolve to the final
-  //   complete class RTTI (because the latter need not exist), possibly by
-  //   making it a local static object.
-  if (ContainsIncompleteClassType(Ty))
-    return llvm::GlobalValue::InternalLinkage;
-
+static std::pair<llvm::GlobalVariable::LinkageTypes,
+                 llvm::GlobalVariable::LinkageTypes>
+getTypeInfoLinkage(CodeGenModule &CGM, QualType Ty) {
+  llvm::GlobalValue::LinkageTypes TypeLinkage = [&]() {
     switch (Ty->getLinkage()) {
     case NoLinkage:
     case InternalLinkage:
     case UniqueExternalLinkage:
       return llvm::GlobalValue::InternalLinkage;
 
     case VisibleNoLinkage:
     case ModuleInternalLinkage:
     case ModuleLinkage:
     case ExternalLinkage:
       // RTTI is not enabled, which means that this type info struct is going
       // to be used for exception handling. Give it linkonce_odr linkage.
       if (!CGM.getLangOpts().RTTI)
         return llvm::GlobalValue::LinkOnceODRLinkage;
 
       if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
         const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
         if (RD->hasAttr<WeakAttr>())
           return llvm::GlobalValue::WeakODRLinkage;
         if (CGM.getTriple().isWindowsItaniumEnvironment())
           if (RD->hasAttr<DLLImportAttr>() &&
               ShouldUseExternalRTTIDescriptor(CGM, Ty))
             return llvm::GlobalValue::ExternalLinkage;
         // MinGW always uses LinkOnceODRLinkage for type info.
-      if (RD->isDynamicClass() &&
+        if (RD->isCompleteDefinition() && RD->isDynamicClass() &&
             !CGM.getContext()
                  .getTargetInfo()
                  .getTriple()
                  .isWindowsGNUEnvironment())
           return CGM.getVTableLinkage(RD);
       }
 
       return llvm::GlobalValue::LinkOnceODRLinkage;
     }
-
     llvm_unreachable("Invalid linkage!");
+  }();
+  // Itanium C++ ABI 2.9.5p7:
+  //   In addition, it and all of the intermediate abi::__pointer_type_info
+  //   structs in the chain down to the abi::__class_type_info for the
+  //   incomplete class type must be prevented from resolving to the
+  //   corresponding type_info structs for the complete class type, possibly
+  //   by making them local static objects. Finally, a dummy class RTTI is
+  //   generated for the incomplete type that will not resolve to the final
+  //   complete class RTTI (because the latter need not exist), possibly by
+  //   making it a local static object.
+  if (ContainsIncompleteClassType(Ty))
+    return {llvm::GlobalValue::InternalLinkage, TypeLinkage};
+  return {TypeLinkage, TypeLinkage};
 }
 
 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force,
                                                   bool DLLExport) {
   // We want to operate on the canonical type.
   Ty = Ty.getCanonicalType();
 
   // Check if we've already emitted an RTTI descriptor for this type.
llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force,
   }
 
   // Check if there is already an external RTTI descriptor for this type.
   bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty);
   if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty)))
     return GetAddrOfExternalRTTIDescriptor(Ty);
 
   // Emit the standard library with external linkage.
-  llvm::GlobalVariable::LinkageTypes Linkage;
+  llvm::GlobalVariable::LinkageTypes InfoLinkage, NameLinkage;
   if (IsStdLib)
-    Linkage = llvm::GlobalValue::ExternalLinkage;
-  else
-    Linkage = getTypeInfoLinkage(CGM, Ty);
-
+    InfoLinkage = NameLinkage = llvm::GlobalValue::ExternalLinkage;
+  else {
+    auto LinkagePair = getTypeInfoLinkage(CGM, Ty);
+    InfoLinkage = LinkagePair.first;
+    NameLinkage = LinkagePair.second;
+  }
   // Add the vtable pointer.
   BuildVTablePointer(cast<Type>(Ty));
 
   // And the name.
-  llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
+  llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, NameLinkage);
   llvm::Constant *TypeNameField;
 
   // If we're supposed to demote the visibility, be sure to set a flag
   // to use a string comparison for type_info comparisons.
   ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
-      CXXABI.classifyRTTIUniqueness(Ty, Linkage);
+      CXXABI.classifyRTTIUniqueness(Ty, NameLinkage);
   if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
     // The flag is the sign bit, which on ARM64 is defined to be clear
     // for global pointers.  This is very ARM64-specific.
     TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
     llvm::Constant *flag =
         llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
     TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
     TypeNameField =
         llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.Int8PtrTy);
   } else {
     TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
case Type::Atomic:
     break;
   }
 
   llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
 
   llvm::Module &M = CGM.getModule();
   llvm::GlobalVariable *GV =
       new llvm::GlobalVariable(M, Init->getType(),
-                               /*Constant=*/true, Linkage, Init, Name);
+                               /*Constant=*/true, InfoLinkage, Init, Name);
 
   // If there's already an old global variable, replace it with the new one.
   if (OldGV) {
     GV->takeName(OldGV);
     llvm::Constant *NewPtr =
       llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
     OldGV->replaceAllUsesWith(NewPtr);
     OldGV->eraseFromParent();
#include "clang/AST/TypeNodes.def"
   // implementation of dynamic_cast to rely on address equality tests,
   // which is much faster.
 
   // All of this is to say that it's important that both the type_info
   // object and the type_info name be uniqued when weakly emitted.
 
   // Give the type_info object and name the formal visibility of the
   // type itself.
-  llvm::GlobalValue::VisibilityTypes llvmVisibility;
+  auto computeVisibility = [&](llvm::GlobalValue::LinkageTypes Linkage) {
     if (llvm::GlobalValue::isLocalLinkage(Linkage))
       // If the linkage is local, only default visibility makes sense.
-    llvmVisibility = llvm::GlobalValue::DefaultVisibility;
+      return llvm::GlobalValue::DefaultVisibility;
     else if (RTTIUniqueness == ItaniumCXXABI::RUK_NonUniqueHidden)
-    llvmVisibility = llvm::GlobalValue::HiddenVisibility;
+      return llvm::GlobalValue::HiddenVisibility;
     else
-    llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
+      return CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
+  };
 
-  TypeName->setVisibility(llvmVisibility);
+  TypeName->setVisibility(computeVisibility(NameLinkage));
   CGM.setDSOLocal(TypeName);
 
-  GV->setVisibility(llvmVisibility);
+  GV->setVisibility(computeVisibility(InfoLinkage));
   CGM.setDSOLocal(GV);
 
   if (CGM.getTriple().isWindowsItaniumEnvironment()) {
     auto RD = Ty->getAsCXXRecordDecl();
     if (DLLExport || (RD && RD->hasAttr<DLLExportAttr>())) {
       TypeName->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
       GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
     } else if (RD && RD->hasAttr<DLLImportAttr>() &&

test/CodeGenCXX/rtti-linkage.cpp

-// RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-BOTH
-// RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -fvisibility hidden -emit-llvm -o - | FileCheck -check-prefix=CHECK-WITH-HIDDEN -check-prefix=CHECK-BOTH %s
+// RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -o - | \
+// RUN:    FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-BOTH \
+// RUN:   -DLINKONCE_VIS_CONSTANT='linkonce_odr constant'
+// RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -fvisibility hidden -emit-llvm -o - | \
+// RUN:    FileCheck %s -check-prefix=CHECK-WITH-HIDDEN -check-prefix=CHECK-BOTH \
+// RUN:   -DLINKONCE_VIS_CONSTANT='linkonce_odr hidden constant'
 
 #include <typeinfo>
 
-// CHECK-BOTH: _ZTSP1C = internal constant
-// CHECK-BOTH: _ZTS1C = internal constant
+// CHECK-BOTH: _ZTSP1C = [[LINKONCE_VIS_CONSTANT]]
+// CHECK-BOTH: _ZTS1C = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTI1C = internal constant
 // CHECK-BOTH: _ZTIP1C = internal constant
-// CHECK-BOTH: _ZTSPP1C = internal constant
+// CHECK-BOTH: _ZTSPP1C = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTIPP1C = internal constant
-// CHECK-BOTH: _ZTSM1Ci = internal constant
+// CHECK-BOTH: _ZTSM1Ci = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTIM1Ci = internal constant
-// CHECK-BOTH: _ZTSPM1Ci = internal constant
+// CHECK-BOTH: _ZTSPM1Ci = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTIPM1Ci = internal constant
-// CHECK-BOTH: _ZTSM1CS_ = internal constant
+// CHECK-BOTH: _ZTSM1CS_ = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTIM1CS_ = internal constant
-// CHECK-BOTH: _ZTSM1CPS_ = internal constant
+// CHECK-BOTH: _ZTSM1CPS_ = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTIM1CPS_ = internal constant
-// CHECK-BOTH: _ZTSM1A1C = internal constant
-// CHECK: _ZTS1A = linkonce_odr constant
-// CHECK-WITH-HIDDEN: _ZTS1A = linkonce_odr hidden constant
-// CHECK: _ZTI1A = linkonce_odr constant
-// CHECK-WITH-HIDDEN: _ZTI1A = linkonce_odr hidden constant
+// CHECK-BOTH: _ZTSM1A1C = [[LINKONCE_VIS_CONSTANT]]
+// CHECK-BOTH: _ZTS1A = [[LINKONCE_VIS_CONSTANT]]
+// CHECK-BOTH: _ZTI1A = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTIM1A1C = internal constant
-// CHECK-BOTH: _ZTSM1AP1C = internal constant
+// CHECK-BOTH: _ZTSM1AP1C = [[LINKONCE_VIS_CONSTANT]]
 // CHECK-BOTH: _ZTIM1AP1C = internal constant
 
 // CHECK-WITH-HIDDEN: _ZTSFN12_GLOBAL__N_11DEvE = internal constant
 // CHECK-WITH-HIDDEN: @_ZTSPK2T4 = linkonce_odr hidden constant 
 // CHECK-WITH-HIDDEN: @_ZTS2T4 = linkonce_odr hidden constant 
 // CHECK-WITH-HIDDEN: @_ZTI2T4 = linkonce_odr hidden constant 
 // CHECK-WITH-HIDDEN: @_ZTIPK2T4 = linkonce_odr hidden constant 
 // CHECK-WITH-HIDDEN: @_ZTSZ2t5vE1A = internal constant

 // CHECK: _ZTSFN12_GLOBAL__N_11DEvE = internal constant
 // CHECK: _ZTIFN12_GLOBAL__N_11DEvE = internal constant
 // CHECK: _ZTSFvN12_GLOBAL__N_11DEE = internal constant
 // CHECK: _ZTIFvN12_GLOBAL__N_11DEE = internal constant
 // CHECK: _ZTSPFvvE = linkonce_odr constant
 // CHECK: _ZTSFvvE = linkonce_odr constant
 // CHECK: _ZTIFvvE = linkonce_odr constant
 // CHECK: _ZTIPFvvE = linkonce_odr constant
+// CHECK: _ZTSPN12_GLOBAL__N_12DIE = internal constant
+// CHECK: _ZTSN12_GLOBAL__N_12DIE = internal constant
+// CHECK: _ZTIN12_GLOBAL__N_12DIE = internal constant
+// CHECK: _ZTIPN12_GLOBAL__N_12DIE = internal constant
+// CHECK: _ZTSMN12_GLOBAL__N_12DIEFvvE = internal constant
+// CHECK: _ZTIMN12_GLOBAL__N_12DIEFvvE = internal constant
 // CHECK: _ZTSN12_GLOBAL__N_11EE = internal constant
 // CHECK: _ZTIN12_GLOBAL__N_11EE = internal constant
 // CHECK: _ZTSA10_i = linkonce_odr constant
 // CHECK: _ZTIA10_i = linkonce_odr constant
 // CHECK: _ZTI1TILj0EE = linkonce_odr constant
 // CHECK: _ZTI1TILj1EE = weak_odr constant
 // CHECK: _ZTI1TILj2EE = external constant
 // CHECK: _ZTSZ2t5vE1A = internal constant
void t1() {
   (void)typeid(int C::**);
   (void)typeid(C C::*);
   (void)typeid(C *C::*);
   (void)typeid(C A::*);
   (void)typeid(C* A::*);
 }
 
 namespace {
-  // D is inside an anonymous namespace, so all type information related to D should have
-  // internal linkage.
-  struct D { };
-  
-  // E is also inside an anonymous namespace.
-  enum E { };
+// D and DI are inside an anonymous namespace, so all type information related
+// to both should have internal linkage.
+struct D {};
+struct DI;
+enum E {};
   
 };
 
 // F has a key function defined in the translation unit, but it is inline so the RTTI
 // data should be emitted with linkonce_odr linkage.
 struct F {
   virtual void f();
 };
 
 inline void F::f() { }
 const D getD();
 
 const std::type_info &t2() {
   (void)typeid(const D);
   (void)typeid(D *);
   (void)typeid(D (*)());
   (void)typeid(void (*)(D));
   (void)typeid(void (*)(D&));
   // The exception specification is not part of the RTTI descriptor, so it should not have
   // internal linkage.
   (void)typeid(void (*)() throw (D));
-  
+  (void)typeid(DI *);
+  (void)typeid(void (DI::*)());
+
   (void)typeid(E);
   
   return typeid(getD());  
 }
 
 namespace Arrays {
   struct A {
     static const int a[10];