This is an archive of the discontinued LLVM Phabricator instance.

Differential D47092

downgrade strong type info names to weak_odr linkage
Needs ReviewPublic

Authored by rsmith on May 18 2018, 3:26 PM.

Details

Reviewers
EricWF
rjmccall
eli.friedman
javed.absar
jgorbe
Summary

After https://reviews.llvm.org/D46665 / rC332028, we now emit linkonce_odr definitions of type info names for incomplete class types. This results in formal violations of LLVM's linkage rules (which, for example, cause ASan's ODR violation checker to complain) if the type info name is declared with external linkage in another IR module. To solve this, downgrade any type info names that we would give external linkage to instead have weak_odr linkage. Exception: if we would emit a non-unique type_info name anyway, leave the linkage alone.

This required a bit of rearrangement: the uniqueness of the name can no longer depend on the linkage of the name, because the linkage of the name now depends on the uniqueness of the name! Fortunately, the uniqueness doesn't *really* depend on the linkage of the name, it only depends on the uniqueness of the type. I've split out the type uniqueness / name uniqueness / type_info uniqueness calculations to try to make this a bit clearer.

Diff Detail

Repository
rC Clang

Event Timeline

rsmith created this revision.May 18 2018, 3:26 PM
Herald added a reviewer: javed.absar. · View Herald TranscriptMay 18 2018, 3:26 PM
efriedma added a subscriber: efriedma.May 18 2018, 4:05 PM

This results in formal violations of LLVM's linkage rules

I'm pretty sure this isn't actually a violation of LLVM's linkage rules as they are described in LangRef... at least, my understanding is that "equivalent" doesn't imply anything about linkage. (If this should be a violation, we need to clarify the rules.)

rjmccall added a comment.May 18 2018, 4:13 PM

Incomplete classes are a curse. I don't suppose we can just modify the language specification to make it illegal to use typeid(Incomplete*)? Or make equality/hashing undefined in these cases?

test/CodeGenCXX/arm64.cpp
48

The way the Darwin ARM64 ABI handles non-unique RTTI is by setting a flag indicating that clients should do string comparisons/hashes; it does not rely on the type name symbols being uniqued. So this should stay external and the _ZTI definition should change to set the bit.

test/CodeGenCXX/windows-itanium-type-info.cpp
31

Is this actually okay? I didn't think dllexport supported weak symbols.

rjmccall added a comment.May 18 2018, 4:28 PM
In D47092#1105317, @rjmccall wrote:

Incomplete classes are a curse. I don't suppose we can just modify the language specification to make it illegal to use typeid(Incomplete*)? Or make equality/hashing undefined in these cases?

Honestly, I'm somewhat inclined to just declare this for Darwin and make us non-conformant. It's not like this has ever previously worked, and this patch is going to be disruptive for our internal C++ developers by introducing new global weak symbols that they can't get rid of except by disabling RTTI. (It would always have been a problem if they were actually using RTTI, of course, but one of the whole problems with RTTI is that you live with the consequences whether you use it or not.)

EricWF added a comment.May 18 2018, 4:31 PM

Sorry @rsmith, I was just about to tackle this.

rsmith added a comment.May 18 2018, 4:55 PM
In D47092#1105315, @efriedma wrote:

I'm pretty sure this isn't actually a violation of LLVM's linkage rules as they are described in LangRef... at least, my understanding is that "equivalent" doesn't imply anything about linkage. (If this should be a violation, we need to clarify the rules.)

This is a fair point. (Though I would note that the LangRef doesn't even say that you can't have two external definitions of the same symbol, so it would clearly benefit from some clarification in this area.)

We could certainly teach ASan to just ignore "odr violations" on type info names, if we think that the IR generated here is in fact correct.

If we go down that path, do we still need changes for the Darwin ARM64 case? (That is, is it OK to emit some weak_odr definitions along with an external definition for the same _ZTS symbol, and not use the 'non-unique type info name' flag? Or should we still be treating that case -- and, as a consequence, all external-linkage _ZTS symbols for classes -- as non-unique?)

test/CodeGenCXX/arm64.cpp
48

OK. I was trying to avoid introducing more cases where we do string comparisons, but if you prefer string comparisons over link-time deduplication in all cases for that target, that seems easy enough to support.

(Out of curiosity, does the link-time deduplication not reliably work on that platform? If so, how do you deal with the other cases that require deduplication? If not, what's the motivation for using string comparisons?)

test/CodeGenCXX/windows-itanium-type-info.cpp
31

Good question, I don't know. Do we have some way to specify "weak_odr within this DSO but strong at the DSO boundary"? I suppose a COMDAT would give that effect.

rjmccall added inline comments.May 18 2018, 7:27 PM
test/CodeGenCXX/arm64.cpp
48

Static and dynamic linking work the same on ARM64 as on any other Mach-O platform. As you say, there are language features that depend on symbols resolving to the same object; we haven't changed that. The issue is that, while deduplication in the *static* linker is great, deduplication in the *dynamic* linker means extra, unavoidable work at load time — mostly, paging in a bunch of data from the symbol table. For an implicitly-activated language feature like RTTI, that can add up to a lot of overhead, which hits you regardless of whether you actually ever use any of the language features that depend on it. On Darwin we really like dynamic libraries, and we really like processes to launch quickly. So the ARM64 ABI says that RTTI which would otherwise need to be potentially deduplicated across a dynamic-library boundary (because the type is external and not hidden) is instead hidden and must be compared using the string data — a classic load-time vs. execution-time trade-off, in this case easy to make because the features that depend on dynamic type matching are rarely used and generally slow anyway.

The GCC type_info ABI uses string comparisons for a completely different purpose: they assume that users can't be trusted to mark visibility correctly on types, so they use string comparisons as a fallback. Darwin ARM64 is still as strict about type visibility as we are on every other platform, so if you use -fvisibility=hidden and forget to mark a type as visible, dynamic_cast and EH will fail across library boundaries.

It occurs to me that all this might be unnecessary, though:

  1. It's never possible to ask for the type_info of an incomplete class type directly.
  2. The features that use RTTI which can actually do pointer conversions don't allow pointers to incomplete class types, either — at best, you can have pointers-to-pointers.
  3. As far as I know, none of those features would ever depend on the pointee type_info object of a pointer-to-pointer. For example, you cannot do a dynamic_cast from a Base** to a Derived**. They only care about the direct pointee type, which cannot be incomplete.
  4. I think the only feature that allows a pointer to an incomplete class type is typeid.
  5. None of the standard operations on a type_info actually cares about the pointee type_info. They care about the name symbol for the pointer type, but that already has to be deduplicated (modulo the ARM64 trick) because we don't eagerly emit RTTI for pointer types.
  6. You can get at the pointee type_info with the cxxabi.h interface, but I would argue that we should not make the ABI worse solely for the benefit of clients of the cxxabi.h interface, especially in a corner case of a corner case (a pointer to an incomplete type which would have turned out to be a dynamic class with a key function).
  7. So I think we could actually get away with always using internal linkage for the ZTSes of incomplete class types, as long as we continue to use the standard rule for the ZTSes of *pointers* to incomplete class types, because the only thing that would break would be the cxxabi.h interface.
  8. And if we find a way to convince LLVM / ASan to let us use weak linkage even if there might also be a strong definition out there, we don't even have that problem long-term.
jgorbe resigned from this revision.Mar 26 2019, 5:14 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 26 2019, 5:14 PM
Herald added subscribers: jdoerfert, mstorsjo. · View Herald Transcript
rprichard added a subscriber: rprichard.Jan 17 2020, 2:25 PM
ldionne added a subscriber: ldionne.May 21 2020, 4:14 AM

I'm revisiting http://llvm.org/PR37398 as it looks like a pretty serious bug to me.

I read http://llvm.org/D46665, this patch and http://llvm.org/PR37545, and my understanding is that this patch supersedes @EricWF 's original patch http://llvm.org/D46665. The only remaining problem would be http://llvm.org/PR37545. Is that correct?

efriedma added a comment.May 21 2020, 1:05 PM

I think the preferred solution is something like https://bugs.llvm.org/show_bug.cgi?id=37545#c4, which is slightly different from both this patch and D46665.

ldionne added a comment.May 22 2020, 1:07 PM
In D47092#2049842, @efriedma wrote:

I think the preferred solution is something like https://bugs.llvm.org/show_bug.cgi?id=37545#c4, which is slightly different from both this patch and D46665.

My understanding was that once the ASAN issue in PR37545 is solved (and https://bugs.llvm.org/show_bug.cgi?id=37545#c4 is a suggestion about how to do that), we can apply this change (D47092). Is that correct? If so, I can see how easy it might be to fix PR37545 in order to unblock this.

efriedma added a comment.May 22 2020, 3:42 PM

Oh, you're right, sorry, the suggestion was to make asan instrumentation introduce the alias, not the frontend. In which case you'd want that fix plus D46665, I think: external linkage optimizes better.

Revision Contents

Diff 147600

lib/CodeGen/ItaniumCXXABI.cpp

Show First 20 Lines • Show All 2,998 Lines • ▼ Show 20 Lines#include "clang/AST/TypeNodes.def"
llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2); llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
VTable = VTable =
llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two); llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy); VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
Fields.push_back(VTable); Fields.push_back(VTable);
} }
/// Return the linkage that the type info and type info name constants /// Return the linkage that the type info constant should have for the given
/// should have for the given type. /// type. This does not take into account the demotion of incomplete type info
static std::pair<llvm::GlobalVariable::LinkageTypes, /// to internal linkage required by the Itanium ABI.
llvm::GlobalVariable::LinkageTypes> static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
getTypeInfoLinkage(CodeGenModule &CGM, QualType Ty) { QualType Ty) {
llvm::GlobalValue::LinkageTypes TypeLinkage = [&]() {
switch (Ty->getLinkage()) { switch (Ty->getLinkage()) {
case NoLinkage: case NoLinkage:
case InternalLinkage: case InternalLinkage:
case UniqueExternalLinkage: case UniqueExternalLinkage:
return llvm::GlobalValue::InternalLinkage; return llvm::GlobalValue::InternalLinkage;
case VisibleNoLinkage: case VisibleNoLinkage:
case ModuleInternalLinkage: case ModuleInternalLinkage:
case ModuleLinkage: case ModuleLinkage:
case ExternalLinkage: case ExternalLinkage:
// RTTI is not enabled, which means that this type info struct is going // RTTI is not enabled, which means that this type info struct is going
// to be used for exception handling. Give it linkonce_odr linkage. // to be used for exception handling. Give it linkonce_odr linkage.
if (!CGM.getLangOpts().RTTI) if (!CGM.getLangOpts().RTTI)
return llvm::GlobalValue::LinkOnceODRLinkage; return llvm::GlobalValue::LinkOnceODRLinkage;
if (const RecordType *Record = dyn_cast<RecordType>(Ty)) { if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
if (RD->hasAttr<WeakAttr>()) if (RD->hasAttr<WeakAttr>())
return llvm::GlobalValue::WeakODRLinkage; return llvm::GlobalValue::WeakODRLinkage;
if (CGM.getTriple().isWindowsItaniumEnvironment()) if (CGM.getTriple().isWindowsItaniumEnvironment())
if (RD->hasAttr<DLLImportAttr>() && if (RD->hasAttr<DLLImportAttr>() &&
ShouldUseExternalRTTIDescriptor(CGM, Ty)) ShouldUseExternalRTTIDescriptor(CGM, Ty))
return llvm::GlobalValue::ExternalLinkage; return llvm::GlobalValue::ExternalLinkage;
// MinGW always uses LinkOnceODRLinkage for type info. // MinGW always uses LinkOnceODRLinkage for type info.
if (RD->isCompleteDefinition() && RD->isDynamicClass() && if (RD->isCompleteDefinition() && RD->isDynamicClass() &&
!CGM.getContext() !CGM.getContext()
.getTargetInfo() .getTargetInfo()
.getTriple() .getTriple()
.isWindowsGNUEnvironment()) .isWindowsGNUEnvironment())
return CGM.getVTableLinkage(RD); return CGM.getVTableLinkage(RD);
} }
return llvm::GlobalValue::LinkOnceODRLinkage; return llvm::GlobalValue::LinkOnceODRLinkage;
} }
llvm_unreachable("Invalid linkage!"); llvm_unreachable("Invalid linkage!");
}(); }
// Itanium C++ ABI 2.9.5p7:
// In addition, it and all of the intermediate abi::__pointer_type_info /// Determine the linkage that the type info name constant should have for
// structs in the chain down to the abi::__class_type_info for the /// the given type in the current translation unit.
// incomplete class type must be prevented from resolving to the static llvm::GlobalVariable::LinkageTypes
// corresponding type_info structs for the complete class type, possibly getTypeInfoNameLinkage(CodeGenModule &CGM, QualType Ty,
// by making them local static objects. Finally, a dummy class RTTI is llvm::GlobalVariable::LinkageTypes TypeLinkage,
// generated for the incomplete type that will not resolve to the final ItaniumCXXABI::RTTIUniquenessKind NameUniqueness) {
// complete class RTTI (because the latter need not exist), possibly by // If a class could be forward-declared in another translation unit, and
// making it a local static object. // we want a globally unique type info name constant, we cannot emit its type
if (ContainsIncompleteClassType(Ty)) // info name with external linkage even if this TU contains the type's key
return {llvm::GlobalValue::InternalLinkage, TypeLinkage}; // function, because we might emit a linkonce_odr type info name for the type
return {TypeLinkage, TypeLinkage}; // in the other TU.
if (TypeLinkage == llvm::GlobalValue::ExternalLinkage &&
NameUniqueness == ItaniumCXXABI::RUK_Unique)
return llvm::GlobalValue::WeakODRLinkage;
return TypeLinkage;
} }
llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force, llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force,
bool DLLExport) { bool DLLExport) {
// We want to operate on the canonical type. // We want to operate on the canonical type.
Ty = Ty.getCanonicalType(); Ty = Ty.getCanonicalType();
// Check if we've already emitted an RTTI descriptor for this type. // Check if we've already emitted an RTTI descriptor for this type.
Show All 10 Linesllvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force,
} }
// Check if there is already an external RTTI descriptor for this type. // Check if there is already an external RTTI descriptor for this type.
bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty); bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty);
if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty))) if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty)))
return GetAddrOfExternalRTTIDescriptor(Ty); return GetAddrOfExternalRTTIDescriptor(Ty);
// Emit the standard library with external linkage. // Emit the standard library with external linkage.
llvm::GlobalVariable::LinkageTypes InfoLinkage, NameLinkage; llvm::GlobalVariable::LinkageTypes TypeLinkage;
if (IsStdLib) if (IsStdLib)
InfoLinkage = NameLinkage = llvm::GlobalValue::ExternalLinkage; TypeLinkage = llvm::GlobalValue::ExternalLinkage;
else { else
auto LinkagePair = getTypeInfoLinkage(CGM, Ty); TypeLinkage = getTypeInfoLinkage(CGM, Ty);
InfoLinkage = LinkagePair.first;
NameLinkage = LinkagePair.second; // Determine the uniqueness and linkage to use for the name.
} ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
CXXABI.classifyRTTIUniqueness(Ty, TypeLinkage);
llvm::GlobalVariable::LinkageTypes NameLinkage =
getTypeInfoNameLinkage(CGM, Ty, TypeLinkage, RTTIUniqueness);
// Determine the linkage to use for this type_info object.
//
// 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.
llvm::GlobalVariable::LinkageTypes InfoLinkage =
ContainsIncompleteClassType(Ty) ? llvm::GlobalValue::InternalLinkage
: TypeLinkage;
// Add the vtable pointer. // Add the vtable pointer.
BuildVTablePointer(cast<Type>(Ty)); BuildVTablePointer(cast<Type>(Ty));
// And the name. // Add the name.
llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, NameLinkage); llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, NameLinkage);
llvm::Constant *TypeNameField; llvm::Constant *TypeNameField;
// If we're supposed to demote the visibility, be sure to set a flag // If we're supposed to demote the visibility, be sure to set a flag
// to use a string comparison for type_info comparisons. // to use a string comparison for type_info comparisons.
ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
CXXABI.classifyRTTIUniqueness(Ty, NameLinkage);
if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) { if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
// The flag is the sign bit, which on ARM64 is defined to be clear // The flag is the sign bit, which on ARM64 is defined to be clear
// for global pointers. This is very ARM64-specific. // for global pointers. This is very ARM64-specific.
TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty); TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
llvm::Constant *flag = llvm::Constant *flag =
llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63); llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag); TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
TypeNameField = TypeNameField =
▲ Show 20 Lines • Show All 988 Lines • Show Last 20 Lines

test/CodeGenCXX/arm64.cpp

Show All 39 Lines
// ARM64 uses string comparisons for what would otherwise be // ARM64 uses string comparisons for what would otherwise be
// default-visibility weak RTTI. rdar://12650568 // default-visibility weak RTTI. rdar://12650568
namespace test2 { namespace test2 {
struct A { struct A {
virtual void foo(); virtual void foo();
}; };
void A::foo() {} void A::foo() {}
// CHECK-GLOBALS-DAG: @_ZTSN5test21AE = constant [11 x i8] // CHECK-GLOBALS-DAG: @_ZTSN5test21AE = weak_odr constant [11 x i8]
rjmccallUnsubmitted
Not Done
ReplyInline Actions

The way the Darwin ARM64 ABI handles non-unique RTTI is by setting a flag indicating that clients should do string comparisons/hashes; it does not rely on the type name symbols being uniqued. So this should stay external and the _ZTI definition should change to set the bit.

rjmccall: The way the Darwin ARM64 ABI handles non-unique RTTI is by setting a flag indicating that…
rsmithAuthorUnsubmitted
Not Done
ReplyInline Actions

OK. I was trying to avoid introducing more cases where we do string comparisons, but if you prefer string comparisons over link-time deduplication in all cases for that target, that seems easy enough to support.

(Out of curiosity, does the link-time deduplication not reliably work on that platform? If so, how do you deal with the other cases that require deduplication? If not, what's the motivation for using string comparisons?)

rsmith: OK. I was trying to avoid introducing more cases where we do string comparisons, but if you…
rjmccallUnsubmitted
Not Done
ReplyInline Actions

Static and dynamic linking work the same on ARM64 as on any other Mach-O platform. As you say, there are language features that depend on symbols resolving to the same object; we haven't changed that. The issue is that, while deduplication in the *static* linker is great, deduplication in the *dynamic* linker means extra, unavoidable work at load time — mostly, paging in a bunch of data from the symbol table. For an implicitly-activated language feature like RTTI, that can add up to a lot of overhead, which hits you regardless of whether you actually ever use any of the language features that depend on it. On Darwin we really like dynamic libraries, and we really like processes to launch quickly. So the ARM64 ABI says that RTTI which would otherwise need to be potentially deduplicated across a dynamic-library boundary (because the type is external and not hidden) is instead hidden and must be compared using the string data — a classic load-time vs. execution-time trade-off, in this case easy to make because the features that depend on dynamic type matching are rarely used and generally slow anyway.

The GCC type_info ABI uses string comparisons for a completely different purpose: they assume that users can't be trusted to mark visibility correctly on types, so they use string comparisons as a fallback. Darwin ARM64 is still as strict about type visibility as we are on every other platform, so if you use -fvisibility=hidden and forget to mark a type as visible, dynamic_cast and EH will fail across library boundaries.

It occurs to me that all this might be unnecessary, though:

  1. It's never possible to ask for the type_info of an incomplete class type directly.
  2. The features that use RTTI which can actually do pointer conversions don't allow pointers to incomplete class types, either — at best, you can have pointers-to-pointers.
  3. As far as I know, none of those features would ever depend on the pointee type_info object of a pointer-to-pointer. For example, you cannot do a dynamic_cast from a Base** to a Derived**. They only care about the direct pointee type, which cannot be incomplete.
  4. I think the only feature that allows a pointer to an incomplete class type is typeid.
  5. None of the standard operations on a type_info actually cares about the pointee type_info. They care about the name symbol for the pointer type, but that already has to be deduplicated (modulo the ARM64 trick) because we don't eagerly emit RTTI for pointer types.
  6. You can get at the pointee type_info with the cxxabi.h interface, but I would argue that we should not make the ABI worse solely for the benefit of clients of the cxxabi.h interface, especially in a corner case of a corner case (a pointer to an incomplete type which would have turned out to be a dynamic class with a key function).
  7. So I think we could actually get away with always using internal linkage for the ZTSes of incomplete class types, as long as we continue to use the standard rule for the ZTSes of *pointers* to incomplete class types, because the only thing that would break would be the cxxabi.h interface.
  8. And if we find a way to convince LLVM / ASan to let us use weak linkage even if there might also be a strong definition out there, we don't even have that problem long-term.
rjmccall: Static and dynamic linking work the same on ARM64 as on any other Mach-O platform. As you say…
// CHECK-GLOBALS-DAG: @_ZTIN5test21AE = constant { {{.*}}, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @_ZTSN5test21AE, i32 0, i32 0) } // CHECK-GLOBALS-DAG: @_ZTIN5test21AE = constant { {{.*}}, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @_ZTSN5test21AE, i32 0, i32 0) }
struct __attribute__((visibility("hidden"))) B {}; struct __attribute__((visibility("hidden"))) B {};
const std::type_info &b0 = typeid(B); const std::type_info &b0 = typeid(B);
// CHECK-GLOBALS-DAG: @_ZTSN5test21BE = linkonce_odr hidden constant // CHECK-GLOBALS-DAG: @_ZTSN5test21BE = linkonce_odr hidden constant
// CHECK-GLOBALS-DAG: @_ZTIN5test21BE = linkonce_odr hidden constant { {{.*}}, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @_ZTSN5test21BE, i32 0, i32 0) } // CHECK-GLOBALS-DAG: @_ZTIN5test21BE = linkonce_odr hidden constant { {{.*}}, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @_ZTSN5test21BE, i32 0, i32 0) }
const std::type_info &b1 = typeid(B*); const std::type_info &b1 = typeid(B*);
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/CodeGenCXX/rtti-linkage.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
// CHECK: _ZTIN12_GLOBAL__N_11EE = internal constant // CHECK: _ZTIN12_GLOBAL__N_11EE = internal constant
// CHECK: _ZTSA10_i = linkonce_odr constant // CHECK: _ZTSA10_i = linkonce_odr constant
// CHECK: _ZTIA10_i = linkonce_odr constant // CHECK: _ZTIA10_i = linkonce_odr constant
// CHECK: _ZTI1TILj0EE = linkonce_odr constant // CHECK: _ZTI1TILj0EE = linkonce_odr constant
// CHECK: _ZTI1TILj1EE = weak_odr constant // CHECK: _ZTI1TILj1EE = weak_odr constant
// CHECK: _ZTI1TILj2EE = external constant // CHECK: _ZTI1TILj2EE = external constant
// CHECK: _ZTSZ2t5vE1A = internal constant // CHECK: _ZTSZ2t5vE1A = internal constant
// CHECK: _ZTIZ2t5vE1A = internal constant // CHECK: _ZTIZ2t5vE1A = internal constant
// CHECK: _ZTS1B = constant // CHECK: _ZTS1B = weak_odr constant
// CHECK: _ZTI1B = constant // CHECK: _ZTI1B = constant
// CHECK: _ZTS1F = linkonce_odr constant // CHECK: _ZTS1F = linkonce_odr constant
// CHECK: _ZTSZ2t6vE1A = linkonce_odr constant // CHECK: _ZTSZ2t6vE1A = linkonce_odr constant
// CHECK: _ZTIZ2t6vE1A = linkonce_odr constant // CHECK: _ZTIZ2t6vE1A = linkonce_odr constant
// CHECK: _ZTSPZ2t7vE1A = linkonce_odr constant // CHECK: _ZTSPZ2t7vE1A = linkonce_odr constant
// CHECK: _ZTSZ2t7vE1A = linkonce_odr constant // CHECK: _ZTSZ2t7vE1A = linkonce_odr constant
// CHECK: _ZTIZ2t7vE1A = linkonce_odr constant // CHECK: _ZTIZ2t7vE1A = linkonce_odr constant
// CHECK: _ZTIPZ2t7vE1A = linkonce_odr constant // CHECK: _ZTIPZ2t7vE1A = linkonce_odr constant
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

test/CodeGenCXX/type_visibility.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
namespace type0 { namespace type0 {
struct TYPE_DEFAULT A { struct TYPE_DEFAULT A {
virtual void foo(); virtual void foo();
}; };
void A::foo() {} void A::foo() {}
// FUNS-LABEL: define void @_ZN5type01A3fooEv( // FUNS-LABEL: define void @_ZN5type01A3fooEv(
// VARS: @_ZTVN5type01AE = unnamed_addr constant // VARS: @_ZTVN5type01AE = unnamed_addr constant
// VARS: @_ZTSN5type01AE = constant // VARS: @_ZTSN5type01AE = weak_odr constant
// VARS: @_ZTIN5type01AE = constant // VARS: @_ZTIN5type01AE = constant
// FUNS-HIDDEN-LABEL: define hidden void @_ZN5type01A3fooEv( // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type01A3fooEv(
// VARS-HIDDEN: @_ZTVN5type01AE = unnamed_addr constant // VARS-HIDDEN: @_ZTVN5type01AE = unnamed_addr constant
// VARS-HIDDEN: @_ZTSN5type01AE = constant // VARS-HIDDEN: @_ZTSN5type01AE = weak_odr constant
// VARS-HIDDEN: @_ZTIN5type01AE = constant // VARS-HIDDEN: @_ZTIN5type01AE = constant
} }
namespace type1 { namespace type1 {
struct HIDDEN TYPE_DEFAULT A { struct HIDDEN TYPE_DEFAULT A {
virtual void foo(); virtual void foo();
}; };
void A::foo() {} void A::foo() {}
// FUNS-LABEL: define hidden void @_ZN5type11A3fooEv( // FUNS-LABEL: define hidden void @_ZN5type11A3fooEv(
// VARS: @_ZTVN5type11AE = unnamed_addr constant // VARS: @_ZTVN5type11AE = unnamed_addr constant
// VARS: @_ZTSN5type11AE = constant // VARS: @_ZTSN5type11AE = weak_odr constant
// VARS: @_ZTIN5type11AE = constant // VARS: @_ZTIN5type11AE = constant
// FUNS-HIDDEN-LABEL: define hidden void @_ZN5type11A3fooEv( // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type11A3fooEv(
// VARS-HIDDEN: @_ZTVN5type11AE = unnamed_addr constant // VARS-HIDDEN: @_ZTVN5type11AE = unnamed_addr constant
// VARS-HIDDEN: @_ZTSN5type11AE = constant // VARS-HIDDEN: @_ZTSN5type11AE = weak_odr constant
// VARS-HIDDEN: @_ZTIN5type11AE = constant // VARS-HIDDEN: @_ZTIN5type11AE = constant
} }
namespace type2 { namespace type2 {
struct TYPE_HIDDEN A { struct TYPE_HIDDEN A {
virtual void foo(); virtual void foo();
}; };
void A::foo() {} void A::foo() {}
// FUNS-LABEL: define void @_ZN5type21A3fooEv( // FUNS-LABEL: define void @_ZN5type21A3fooEv(
// VARS: @_ZTVN5type21AE = hidden unnamed_addr constant // VARS: @_ZTVN5type21AE = hidden unnamed_addr constant
// VARS: @_ZTSN5type21AE = hidden constant // VARS: @_ZTSN5type21AE = weak_odr hidden constant
// VARS: @_ZTIN5type21AE = hidden constant // VARS: @_ZTIN5type21AE = hidden constant
// FUNS-HIDDEN-LABEL: define hidden void @_ZN5type21A3fooEv( // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type21A3fooEv(
// VARS-HIDDEN: @_ZTVN5type21AE = hidden unnamed_addr constant // VARS-HIDDEN: @_ZTVN5type21AE = hidden unnamed_addr constant
// VARS-HIDDEN: @_ZTSN5type21AE = hidden constant // VARS-HIDDEN: @_ZTSN5type21AE = weak_odr hidden constant
// VARS-HIDDEN: @_ZTIN5type21AE = hidden constant // VARS-HIDDEN: @_ZTIN5type21AE = hidden constant
} }
namespace type3 { namespace type3 {
struct DEFAULT TYPE_HIDDEN A { struct DEFAULT TYPE_HIDDEN A {
virtual void foo(); virtual void foo();
}; };
void A::foo() {} void A::foo() {}
// FUNS-LABEL: define void @_ZN5type31A3fooEv( // FUNS-LABEL: define void @_ZN5type31A3fooEv(
// VARS: @_ZTVN5type31AE = hidden unnamed_addr constant // VARS: @_ZTVN5type31AE = hidden unnamed_addr constant
// VARS: @_ZTSN5type31AE = hidden constant // VARS: @_ZTSN5type31AE = weak_odr hidden constant
// VARS: @_ZTIN5type31AE = hidden constant // VARS: @_ZTIN5type31AE = hidden constant
// FUNS-HIDDEN-LABEL: define void @_ZN5type31A3fooEv( // FUNS-HIDDEN-LABEL: define void @_ZN5type31A3fooEv(
// VARS-HIDDEN: @_ZTVN5type31AE = hidden unnamed_addr constant // VARS-HIDDEN: @_ZTVN5type31AE = hidden unnamed_addr constant
// VARS-HIDDEN: @_ZTSN5type31AE = hidden constant // VARS-HIDDEN: @_ZTSN5type31AE = weak_odr hidden constant
// VARS-HIDDEN: @_ZTIN5type31AE = hidden constant // VARS-HIDDEN: @_ZTIN5type31AE = hidden constant
} }

test/CodeGenCXX/vtable-available-externally.cpp

Show All 39 Lines
} }
// Test2::A's key function (f) is defined in this translation unit, but when // Test2::A's key function (f) is defined in this translation unit, but when
// we're doing codegen for the typeid(A) call, we don't know that yet. // we're doing codegen for the typeid(A) call, we don't know that yet.
// This tests mainly that the typeinfo and typename constants have their linkage // This tests mainly that the typeinfo and typename constants have their linkage
// updated correctly. // updated correctly.
// CHECK-TEST2: @_ZTSN5Test21AE = constant // CHECK-TEST2: @_ZTSN5Test21AE = weak_odr constant
// CHECK-TEST2: @_ZTIN5Test21AE = constant // CHECK-TEST2: @_ZTIN5Test21AE = constant
// CHECK-TEST2: @_ZTVN5Test21AE = unnamed_addr constant // CHECK-TEST2: @_ZTVN5Test21AE = unnamed_addr constant
namespace Test2 { namespace Test2 {
struct A { struct A {
virtual void f(); virtual void f();
}; };
const std::type_info &g() { const std::type_info &g() {
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

test/CodeGenCXX/vtable-key-function-arm.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linesstruct Test2a {
Test2a(); Test2a();
virtual void foo(); virtual void foo();
virtual void bar(); virtual void bar();
}; };
// V-table should be defined with strong linkage. // V-table should be defined with strong linkage.
Test2a::Test2a() { use(typeid(Test2a)); } Test2a::Test2a() { use(typeid(Test2a)); }
// CHECK: @_ZTV6Test2a = unnamed_addr constant // CHECK: @_ZTV6Test2a = unnamed_addr constant
// CHECK-LATE: @_ZTS6Test2a = constant // CHECK-LATE: @_ZTS6Test2a = weak_odr constant
// CHECK-LATE: @_ZTI6Test2a = constant // CHECK-LATE: @_ZTI6Test2a = constant
// 'bar' becomes the key function when 'foo' is defined inline. // 'bar' becomes the key function when 'foo' is defined inline.
void Test2a::bar() {} void Test2a::bar() {}
inline void Test2a::foo() {} inline void Test2a::foo() {}
/*** Test2b ******************************************************************/ /*** Test2b ******************************************************************/
struct Test2b { struct Test2b {
Test2b(); Test2b();
virtual void foo(); virtual void foo();
virtual void bar(); virtual void bar();
}; };
// 'bar' becomes the key function when 'foo' is defined inline. // 'bar' becomes the key function when 'foo' is defined inline.
void Test2b::bar() {} void Test2b::bar() {}
// V-table should be defined with strong linkage. // V-table should be defined with strong linkage.
Test2b::Test2b() { use(typeid(Test2b)); } Test2b::Test2b() { use(typeid(Test2b)); }
// CHECK: @_ZTV6Test2b = unnamed_addr constant // CHECK: @_ZTV6Test2b = unnamed_addr constant
// CHECK-LATE: @_ZTS6Test2b = constant // CHECK-LATE: @_ZTS6Test2b = weak_odr constant
// CHECK-LATE: @_ZTI6Test2b = constant // CHECK-LATE: @_ZTI6Test2b = constant
inline void Test2b::foo() {} inline void Test2b::foo() {}
/*** Test2c ******************************************************************/ /*** Test2c ******************************************************************/
struct Test2c { struct Test2c {
Test2c(); Test2c();
virtual void foo(); virtual void foo();
virtual void bar(); virtual void bar();
}; };
// 'bar' becomes the key function when 'foo' is defined inline. // 'bar' becomes the key function when 'foo' is defined inline.
void Test2c::bar() {} void Test2c::bar() {}
inline void Test2c::foo() {} inline void Test2c::foo() {}
// V-table should be defined with strong linkage. // V-table should be defined with strong linkage.
Test2c::Test2c() { use(typeid(Test2c)); } Test2c::Test2c() { use(typeid(Test2c)); }
// CHECK: @_ZTV6Test2c = unnamed_addr constant // CHECK: @_ZTV6Test2c = unnamed_addr constant
// CHECK: @_ZTS6Test2c = constant // CHECK: @_ZTS6Test2c = weak_odr constant
// CHECK: @_ZTI6Test2c = constant // CHECK: @_ZTI6Test2c = constant
/*** Test3a ******************************************************************/ /*** Test3a ******************************************************************/
struct Test3a { struct Test3a {
Test3a(); Test3a();
virtual void foo(); virtual void foo();
virtual void bar(); virtual void bar();
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

test/CodeGenCXX/vtable-linkage.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
// CHECK-DAG: @_ZTV1C = linkonce_odr unnamed_addr constant {{.*}}, comdat, // CHECK-DAG: @_ZTV1C = linkonce_odr unnamed_addr constant {{.*}}, comdat,
// CHECK-DAG: @_ZTS1C = linkonce_odr constant {{.*}}, comdat{{$}} // CHECK-DAG: @_ZTS1C = linkonce_odr constant {{.*}}, comdat{{$}}
// CHECK-DAG: @_ZTI1C = linkonce_odr constant {{.*}}, comdat{{$}} // CHECK-DAG: @_ZTI1C = linkonce_odr constant {{.*}}, comdat{{$}}
// CHECK-DAG: @_ZTT1C = linkonce_odr unnamed_addr constant {{.*}}, comdat{{$}} // CHECK-DAG: @_ZTT1C = linkonce_odr unnamed_addr constant {{.*}}, comdat{{$}}
// D has a key function that is defined in this translation unit so its vtable is // D has a key function that is defined in this translation unit so its vtable is
// defined in the translation unit. // defined in the translation unit.
// CHECK-DAG: @_ZTV1D = unnamed_addr constant // CHECK-DAG: @_ZTV1D = unnamed_addr constant
// CHECK-DAG: @_ZTS1D = constant // CHECK-DAG: @_ZTS1D = weak_odr constant
// CHECK-DAG: @_ZTI1D = constant // CHECK-DAG: @_ZTI1D = constant
// E<char> is an explicit specialization with a key function defined // E<char> is an explicit specialization with a key function defined
// in this translation unit, so its vtable should have external // in this translation unit, so its vtable should have external
// linkage. // linkage.
// CHECK-DAG: @_ZTV1EIcE = unnamed_addr constant // CHECK-DAG: @_ZTV1EIcE = unnamed_addr constant
// CHECK-DAG: @_ZTS1EIcE = constant // CHECK-DAG: @_ZTS1EIcE = weak_odr constant
// CHECK-DAG: @_ZTI1EIcE = constant // CHECK-DAG: @_ZTI1EIcE = constant
// E<short> is an explicit template instantiation with a key function // E<short> is an explicit template instantiation with a key function
// defined in this translation unit, so its vtable should have // defined in this translation unit, so its vtable should have
// weak_odr linkage. // weak_odr linkage.
// CHECK-DAG: @_ZTV1EIsE = weak_odr unnamed_addr constant {{.*}}, comdat, // CHECK-DAG: @_ZTV1EIsE = weak_odr unnamed_addr constant {{.*}}, comdat,
// CHECK-DAG: @_ZTS1EIsE = weak_odr constant {{.*}}, comdat{{$}} // CHECK-DAG: @_ZTS1EIsE = weak_odr constant {{.*}}, comdat{{$}}
// CHECK-DAG: @_ZTI1EIsE = weak_odr constant {{.*}}, comdat{{$}} // CHECK-DAG: @_ZTI1EIsE = weak_odr constant {{.*}}, comdat{{$}}
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
public: public:
virtual ~H(); virtual ~H();
}; };
void use_H() { void use_H() {
H<int> h; H<int> h;
} }
// local_class()::J is local to this translation unit, so is given internal
// linkage.
// CHECK-DAG: @_ZTVZ11local_classvE1J = internal unnamed_addr constant
// CHECK-DAG: @_ZTSZ11local_classvE1J = internal constant
// CHECK-DAG: @_ZTIZ11local_classvE1J = internal constant
void local_class() {
struct J {
virtual void f() {}
};
J().f();
}
// I<int> has an explicit instantiation declaration and needs a VTT and // I<int> has an explicit instantiation declaration and needs a VTT and
// construction vtables. // construction vtables.
// CHECK-DAG: @_ZTV1IIiE = external unnamed_addr constant // CHECK-DAG: @_ZTV1IIiE = external unnamed_addr constant
// CHECK-DAG: @_ZTT1IIiE = external unnamed_addr constant // CHECK-DAG: @_ZTT1IIiE = external unnamed_addr constant
// CHECK-NOT: @_ZTC1IIiE // CHECK-NOT: @_ZTC1IIiE
// //
// CHECK-OPT-DAG: @_ZTV1IIiE = available_externally unnamed_addr constant // CHECK-OPT-DAG: @_ZTV1IIiE = available_externally unnamed_addr constant
// CHECK-OPT-DAG: @_ZTT1IIiE = available_externally unnamed_addr constant // CHECK-OPT-DAG: @_ZTT1IIiE = available_externally unnamed_addr constant
struct VBase1 { virtual void f(); }; struct VBase2 : virtual VBase1 {}; struct VBase1 { virtual void f(); }; struct VBase2 : virtual VBase1 {};
template<typename T> template<typename T>
struct I : VBase2 {}; struct I : VBase2 {};
extern template struct I<int>; extern template struct I<int>;
I<int> i; I<int> i;

test/CodeGenCXX/windows-itanium-type-info.cpp

Show All 22 Lines
void f() { void f() {
throw base(); throw base();
} }
// CHECK-DAG: @_ZTIi = dso_local dllexport constant // CHECK-DAG: @_ZTIi = dso_local dllexport constant
// CHECK-DAG: @_ZTSi = dso_local dllexport constant // CHECK-DAG: @_ZTSi = dso_local dllexport constant
// CHECK-DAG: @_ZTI7derived = dso_local dllexport constant // CHECK-DAG: @_ZTI7derived = dso_local dllexport constant
// CHECK-DAG: @_ZTS7derived = dso_local dllexport constant // CHECK-DAG: @_ZTS7derived = weak_odr dso_local dllexport constant
rjmccallUnsubmitted
Not Done
ReplyInline Actions

Is this actually okay? I didn't think dllexport supported weak symbols.

rjmccall: Is this actually okay? I didn't think dllexport supported weak symbols.
rsmithAuthorUnsubmitted
Not Done
ReplyInline Actions

Good question, I don't know. Do we have some way to specify "weak_odr within this DSO but strong at the DSO boundary"? I suppose a COMDAT would give that effect.

rsmith: Good question, I don't know. Do we have some way to specify "weak_odr within this DSO but…
// CHECK-DAG: @_ZTV7derived = dso_local dllexport unnamed_addr constant // CHECK-DAG: @_ZTV7derived = dso_local dllexport unnamed_addr constant
// CHECK-DAG: @_ZTI4base = external dllimport constant // CHECK-DAG: @_ZTI4base = external dllimport constant
// CHECK-EH-IMPORT: @_ZTS4base = linkonce_odr dso_local constant // CHECK-EH-IMPORT: @_ZTS4base = linkonce_odr dso_local constant
// CHECK-EH-IMPORT: @_ZTI4base = linkonce_odr dso_local constant // CHECK-EH-IMPORT: @_ZTI4base = linkonce_odr dso_local constant
struct __declspec(dllimport) gatekeeper {}; struct __declspec(dllimport) gatekeeper {};
struct zuul : gatekeeper { struct zuul : gatekeeper {
virtual ~zuul(); virtual ~zuul();
}; };
zuul::~zuul() {} zuul::~zuul() {}
// CHECK-DAG: @_ZTI10gatekeeper = linkonce_odr dso_local constant // CHECK-DAG: @_ZTI10gatekeeper = linkonce_odr dso_local constant
// CHECK-DAG: @_ZTS10gatekeeper = linkonce_odr dso_local constant // CHECK-DAG: @_ZTS10gatekeeper = linkonce_odr dso_local constant