This is an archive of the discontinued LLVM Phabricator instance.

Differential D106319

[IR] Rename `comdat noduplicates` to `comdat nodeduplicate`
ClosedPublic

Authored by MaskRay on Jul 19 2021, 3:08 PM.

Details

Reviewers
rnk
sbc100
tejohnson
deadalnix
Commits
rG392487793248: [IR] Rename `comdat noduplicates` to `comdat nodeduplicate`
Summary

In the textual format, noduplicates means no COMDAT/section group
deduplication is performed. Therefore, if both sets of sections are retained, and
they happen to define strong external symbols with the same names,
there will be a duplicate definition linker error.

In PE/COFF, the selection kind lowers to IMAGE_COMDAT_SELECT_NODUPLICATES.
The name describes the corollary instead of the immediate semantics. The name
can cause confusion to other binary formats (ELF, wasm) which have implemented/
want to implement the "no deduplication" selection kind. Rename it to be clearer.

Diff Detail

Event Timeline

MaskRay created this revision.Jul 19 2021, 3:08 PM
Herald added subscribers: ormris, dexonsmith, jdoerfert and 4 others. · View Herald TranscriptJul 19 2021, 3:08 PM
MaskRay requested review of this revision.Jul 19 2021, 3:08 PM
Herald added a project: Restricted Project. · View Herald TranscriptJul 19 2021, 3:08 PM
Herald added subscribers: llvm-commits, aheejin. · View Herald Transcript
MaskRay mentioned this in D106300: [LangRef] Clarify comdat.Jul 19 2021, 3:11 PM
rnk accepted this revision.Jul 19 2021, 3:40 PM

So, the reason the current name might feel inaccurate is that if you were writing a linker, you might imagine that two groups with the same name should be a linker error, but that is not in fact the case: it just means that both sets of sections are retained, and later symbol resolution may report duplicate symbols of the same name, if the group happens to contain strong external symbols with the same names.

I'm OK with the renaming.

This revision is now accepted and ready to land.Jul 19 2021, 3:40 PM
MaskRay edited the summary of this revision. (Show Details)Jul 19 2021, 3:53 PM
Harbormaster completed remote builds in B114961: Diff 359936.Jul 19 2021, 4:26 PM
MaskRay updated this revision to Diff 360182.Jul 20 2021, 9:50 AM

update comments

Herald added a reviewer: deadalnix. · View Herald TranscriptJul 20 2021, 9:50 AM
MaskRay added a comment.Jul 20 2021, 9:52 AM

Will comdat nodeduplication be a better name? deduplicate is a verb, not a noun.

Harbormaster completed remote builds in B115132: Diff 360182.Jul 20 2021, 11:42 AM
MaskRay added a comment.Jul 20 2021, 12:45 PM

nodeduplicate should be fine. We have --no-foobar style command line options For example, Mach-O ld64 has a -no_deduplicate

This revision was landed with ongoing or failed builds.Jul 20 2021, 12:47 PM
Closed by commit rG392487793248: [IR] Rename `comdat noduplicates` to `comdat nodeduplicate` (authored by MaskRay). · Explain Why
This revision was automatically updated to reflect the committed changes.
MaskRay added a commit: rG392487793248: [IR] Rename `comdat noduplicates` to `comdat nodeduplicate`.

Revision Contents

PathSize
llvm/
bindings/
go/
llvm/
2 lines
docs/
2 lines
4 lines
include/
llvm-c/
3 lines
llvm/
AsmParser/
2 lines
IR/
10 lines
lib/
AsmParser/
2 lines
4 lines
Bitcode/
Reader/
2 lines
Writer/
2 lines
CodeGen/
8 lines
IR/
4 lines
8 lines
Linker/
4 lines
Transforms/
IPO/
8 lines
Instrumentation/
4 lines
4 lines
2 lines
test/
Bitcode/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
CodeGen/
X86/
2 lines
4 lines
4 lines
Instrumentation/
AddressSanitizer/
4 lines
InstrProfiling/
8 lines
SanitizerCoverage/
4 lines
2 lines
4 lines
4 lines
Linker/
Inputs/
2 lines
4 lines
SymbolRewriter/
4 lines
Transforms/
Internalize/
4 lines

Diff 360241

llvm/bindings/go/llvm/ir.go

Show First 20 Lines • Show All 284 Lines • ▼ Show 20 Lines
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// llvm.ComdatSelectionKind // llvm.ComdatSelectionKind
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
const ( const (
AnyComdatSelectionKind ComdatSelectionKind = C.LLVMAnyComdatSelectionKind AnyComdatSelectionKind ComdatSelectionKind = C.LLVMAnyComdatSelectionKind
ExactMatchComdatSelectionKind ComdatSelectionKind = C.LLVMExactMatchComdatSelectionKind ExactMatchComdatSelectionKind ComdatSelectionKind = C.LLVMExactMatchComdatSelectionKind
LargestComdatSelectionKind ComdatSelectionKind = C.LLVMLargestComdatSelectionKind LargestComdatSelectionKind ComdatSelectionKind = C.LLVMLargestComdatSelectionKind
NoDuplicatesComdatSelectionKind ComdatSelectionKind = C.LLVMNoDuplicatesComdatSelectionKind NoDeduplicateComdatSelectionKind ComdatSelectionKind = C.LLVMNoDeduplicateComdatSelectionKind
SameSizeComdatSelectionKind ComdatSelectionKind = C.LLVMSameSizeComdatSelectionKind SameSizeComdatSelectionKind ComdatSelectionKind = C.LLVMSameSizeComdatSelectionKind
) )
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// llvm.IntPredicate // llvm.IntPredicate
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
const ( const (
▲ Show 20 Lines • Show All 1,715 Lines • Show Last 20 Lines

llvm/docs/BitCodeFormat.rst

Show First 20 Lines • Show All 1,007 Lines • ▼ Show 20 Lines
* code 4: ``inlinehint`` * code 4: ``inlinehint``
* code 5: ``inreg`` * code 5: ``inreg``
* code 6: ``minsize`` * code 6: ``minsize``
* code 7: ``naked`` * code 7: ``naked``
* code 8: ``nest`` * code 8: ``nest``
* code 9: ``noalias`` * code 9: ``noalias``
* code 10: ``nobuiltin`` * code 10: ``nobuiltin``
* code 11: ``nocapture`` * code 11: ``nocapture``
* code 12: ``noduplicates`` * code 12: ``nodeduplicate``
* code 13: ``noimplicitfloat`` * code 13: ``noimplicitfloat``
* code 14: ``noinline`` * code 14: ``noinline``
* code 15: ``nonlazybind`` * code 15: ``nonlazybind``
* code 16: ``noredzone`` * code 16: ``noredzone``
* code 17: ``noreturn`` * code 17: ``noreturn``
* code 18: ``nounwind`` * code 18: ``nounwind``
* code 19: ``optsize`` * code 19: ``optsize``
* code 20: ``readnone`` * code 20: ``readnone``
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

llvm/docs/LangRef.rst

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 932 Lines • ▼ Show 20 Lines
``any`` ``any``
The linker may choose any COMDAT key, the choice is arbitrary. The linker may choose any COMDAT key, the choice is arbitrary.
``exactmatch`` ``exactmatch``
The linker may choose any COMDAT key but the sections must contain the The linker may choose any COMDAT key but the sections must contain the
same data. same data.
``largest`` ``largest``
The linker will choose the section containing the largest COMDAT key. The linker will choose the section containing the largest COMDAT key.
``noduplicates`` ``nodeduplicate``
The linker requires that only section with this COMDAT key exist. No deduplication is performed.
``samesize`` ``samesize``
The linker may choose any COMDAT key but the sections must contain the The linker may choose any COMDAT key but the sections must contain the
same amount of data. same amount of data.
Note that XCOFF and the Mach-O platform don't support COMDATs, and ELF and Note that XCOFF and the Mach-O platform don't support COMDATs, and ELF and
WebAssembly only support ``any`` as a selection kind. WebAssembly only support ``any`` as a selection kind.
Here is an example of a COMDAT group where a function will only be selected if Here is an example of a COMDAT group where a function will only be selected if
▲ Show 20 Lines • Show All 21,691 Lines • Show Last 20 Lines

llvm/include/llvm-c/Comdat.h

Show All 19 Lines
LLVM_C_EXTERN_C_BEGIN LLVM_C_EXTERN_C_BEGIN
typedef enum { typedef enum {
LLVMAnyComdatSelectionKind, ///< The linker may choose any COMDAT. LLVMAnyComdatSelectionKind, ///< The linker may choose any COMDAT.
LLVMExactMatchComdatSelectionKind, ///< The data referenced by the COMDAT must LLVMExactMatchComdatSelectionKind, ///< The data referenced by the COMDAT must
///< be the same. ///< be the same.
LLVMLargestComdatSelectionKind, ///< The linker will choose the largest LLVMLargestComdatSelectionKind, ///< The linker will choose the largest
///< COMDAT. ///< COMDAT.
LLVMNoDuplicatesComdatSelectionKind, ///< No other Module may specify this LLVMNoDeduplicateComdatSelectionKind, ///< No deduplication is performed.
///< COMDAT.
LLVMSameSizeComdatSelectionKind ///< The data referenced by the COMDAT must be LLVMSameSizeComdatSelectionKind ///< The data referenced by the COMDAT must be
///< the same size. ///< the same size.
} LLVMComdatSelectionKind; } LLVMComdatSelectionKind;
/** /**
* Return the Comdat in the module with the specified name. It is created * Return the Comdat in the module with the specified name. It is created
* if it didn't already exist. * if it didn't already exist.
* *
Show All 35 Lines

llvm/include/llvm/AsmParser/LLToken.h

Show First 20 Lines • Show All 255 Lines • ▼ Show 20 Linesenum Kind {
kw_opaque, kw_opaque,
kw_comdat, kw_comdat,
// Comdat types // Comdat types
kw_any, kw_any,
kw_exactmatch, kw_exactmatch,
kw_largest, kw_largest,
kw_noduplicates, kw_nodeduplicate,
kw_samesize, kw_samesize,
kw_eq, kw_eq,
kw_ne, kw_ne,
kw_slt, kw_slt,
kw_sgt, kw_sgt,
kw_sle, kw_sle,
kw_sge, kw_sge,
▲ Show 20 Lines • Show All 225 Lines • Show Last 20 Lines

llvm/include/llvm/IR/Comdat.h

Show All 25 Lines
// This is a Name X SelectionKind pair. The reason for having this be an // This is a Name X SelectionKind pair. The reason for having this be an
// independent object instead of just adding the name and the SelectionKind // independent object instead of just adding the name and the SelectionKind
// to a GlobalObject is that it is invalid to have two Comdats with the same // to a GlobalObject is that it is invalid to have two Comdats with the same
// name but different SelectionKind. This structure makes that unrepresentable. // name but different SelectionKind. This structure makes that unrepresentable.
class Comdat { class Comdat {
public: public:
enum SelectionKind { enum SelectionKind {
Any, ///< The linker may choose any COMDAT. Any, ///< The linker may choose any COMDAT.
ExactMatch, ///< The data referenced by the COMDAT must be the same. ExactMatch, ///< The data referenced by the COMDAT must be the same.
Largest, ///< The linker will choose the largest COMDAT. Largest, ///< The linker will choose the largest COMDAT.
NoDuplicates, ///< No other Module may specify this COMDAT. NoDeduplicate, ///< No deduplication is performed.
SameSize, ///< The data referenced by the COMDAT must be the same size. SameSize, ///< The data referenced by the COMDAT must be the same size.
}; };
Comdat(const Comdat &) = delete; Comdat(const Comdat &) = delete;
Comdat(Comdat &&C); Comdat(Comdat &&C);
SelectionKind getSelectionKind() const { return SK; } SelectionKind getSelectionKind() const { return SK; }
void setSelectionKind(SelectionKind Val) { SK = Val; } void setSelectionKind(SelectionKind Val) { SK = Val; }
StringRef getName() const; StringRef getName() const;
Show All 24 Lines

llvm/lib/AsmParser/LLLexer.cpp

Show First 20 Lines • Show All 711 Lines • ▼ Show 20 Lines#define KEYWORD(STR) \
KEYWORD(opaque); KEYWORD(opaque);
KEYWORD(comdat); KEYWORD(comdat);
// Comdat types // Comdat types
KEYWORD(any); KEYWORD(any);
KEYWORD(exactmatch); KEYWORD(exactmatch);
KEYWORD(largest); KEYWORD(largest);
KEYWORD(noduplicates); KEYWORD(nodeduplicate);
KEYWORD(samesize); KEYWORD(samesize);
KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle); KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge); KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole); KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une); KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax); KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
▲ Show 20 Lines • Show All 451 Lines • Show Last 20 Lines

llvm/lib/AsmParser/LLParser.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 662 Lines • ▼ Show 20 Lines case lltok::kw_any:
SK = Comdat::Any; SK = Comdat::Any;
break; break;
case lltok::kw_exactmatch: case lltok::kw_exactmatch:
SK = Comdat::ExactMatch; SK = Comdat::ExactMatch;
break; break;
case lltok::kw_largest: case lltok::kw_largest:
SK = Comdat::Largest; SK = Comdat::Largest;
break; break;
case lltok::kw_noduplicates: case lltok::kw_nodeduplicate:
SK = Comdat::NoDuplicates; SK = Comdat::NoDeduplicate;
break; break;
case lltok::kw_samesize: case lltok::kw_samesize:
SK = Comdat::SameSize; SK = Comdat::SameSize;
break; break;
} }
Lex.Lex(); Lex.Lex();
// See if the comdat was forward referenced, if so, use the comdat. // See if the comdat was forward referenced, if so, use the comdat.
▲ Show 20 Lines • Show All 8,655 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 1,122 Lines • ▼ Show 20 Linesstatic Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {
default: // Map unknown selection kinds to any. default: // Map unknown selection kinds to any.
case bitc::COMDAT_SELECTION_KIND_ANY: case bitc::COMDAT_SELECTION_KIND_ANY:
return Comdat::Any; return Comdat::Any;
case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH: case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH:
return Comdat::ExactMatch; return Comdat::ExactMatch;
case bitc::COMDAT_SELECTION_KIND_LARGEST: case bitc::COMDAT_SELECTION_KIND_LARGEST:
return Comdat::Largest; return Comdat::Largest;
case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES: case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES:
return Comdat::NoDuplicates; return Comdat::NoDeduplicate;
case bitc::COMDAT_SELECTION_KIND_SAME_SIZE: case bitc::COMDAT_SELECTION_KIND_SAME_SIZE:
return Comdat::SameSize; return Comdat::SameSize;
} }
} }
static FastMathFlags getDecodedFastMathFlags(unsigned Val) { static FastMathFlags getDecodedFastMathFlags(unsigned Val) {
FastMathFlags FMF; FastMathFlags FMF;
if (0 != (Val & bitc::UnsafeAlgebra)) if (0 != (Val & bitc::UnsafeAlgebra))
▲ Show 20 Lines • Show All 5,914 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 1,126 Lines • ▼ Show 20 Lines
static unsigned getEncodedComdatSelectionKind(const Comdat &C) { static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
switch (C.getSelectionKind()) { switch (C.getSelectionKind()) {
case Comdat::Any: case Comdat::Any:
return bitc::COMDAT_SELECTION_KIND_ANY; return bitc::COMDAT_SELECTION_KIND_ANY;
case Comdat::ExactMatch: case Comdat::ExactMatch:
return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH; return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH;
case Comdat::Largest: case Comdat::Largest:
return bitc::COMDAT_SELECTION_KIND_LARGEST; return bitc::COMDAT_SELECTION_KIND_LARGEST;
case Comdat::NoDuplicates: case Comdat::NoDeduplicate:
return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES; return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;
case Comdat::SameSize: case Comdat::SameSize:
return bitc::COMDAT_SELECTION_KIND_SAME_SIZE; return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;
} }
llvm_unreachable("Invalid selection kind"); llvm_unreachable("Invalid selection kind");
} }
static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) { static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) {
▲ Show 20 Lines • Show All 3,837 Lines • Show Last 20 Lines

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

Show First 20 Lines • Show All 526 Lines • ▼ Show 20 Lines
} }
static const Comdat *getELFComdat(const GlobalValue *GV) { static const Comdat *getELFComdat(const GlobalValue *GV) {
const Comdat *C = GV->getComdat(); const Comdat *C = GV->getComdat();
if (!C) if (!C)
return nullptr; return nullptr;
if (C->getSelectionKind() != Comdat::Any && if (C->getSelectionKind() != Comdat::Any &&
C->getSelectionKind() != Comdat::NoDuplicates) C->getSelectionKind() != Comdat::NoDeduplicate)
report_fatal_error("ELF COMDATs only support SelectionKind::Any and " report_fatal_error("ELF COMDATs only support SelectionKind::Any and "
"SelectionKind::NoDuplicates, '" + C->getName() + "SelectionKind::NoDeduplicate, '" +
"' cannot be lowered."); C->getName() + "' cannot be lowered.");
return C; return C;
} }
static const MCSymbolELF *getLinkedToSymbol(const GlobalObject *GO, static const MCSymbolELF *getLinkedToSymbol(const GlobalObject *GO,
const TargetMachine &TM) { const TargetMachine &TM) {
MDNode *MD = GO->getMetadata(LLVMContext::MD_associated); MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
if (!MD) if (!MD)
▲ Show 20 Lines • Show All 1,019 Lines • ▼ Show 20 Lines if (const Comdat *C = GV->getComdat()) {
if (ComdatKey == GV) { if (ComdatKey == GV) {
switch (C->getSelectionKind()) { switch (C->getSelectionKind()) {
case Comdat::Any: case Comdat::Any:
return COFF::IMAGE_COMDAT_SELECT_ANY; return COFF::IMAGE_COMDAT_SELECT_ANY;
case Comdat::ExactMatch: case Comdat::ExactMatch:
return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH; return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
case Comdat::Largest: case Comdat::Largest:
return COFF::IMAGE_COMDAT_SELECT_LARGEST; return COFF::IMAGE_COMDAT_SELECT_LARGEST;
case Comdat::NoDuplicates: case Comdat::NoDeduplicate:
return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES; return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
case Comdat::SameSize: case Comdat::SameSize:
return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE; return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
} }
} else { } else {
return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE; return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
} }
} }
▲ Show 20 Lines • Show All 941 Lines • Show Last 20 Lines

llvm/lib/IR/AsmWriter.cpp

Show First 20 Lines • Show All 4,548 Lines • ▼ Show 20 Lines case Comdat::Any:
ROS << "any"; ROS << "any";
break; break;
case Comdat::ExactMatch: case Comdat::ExactMatch:
ROS << "exactmatch"; ROS << "exactmatch";
break; break;
case Comdat::Largest: case Comdat::Largest:
ROS << "largest"; ROS << "largest";
break; break;
case Comdat::NoDuplicates: case Comdat::NoDeduplicate:
ROS << "noduplicates"; ROS << "nodeduplicate";
break; break;
case Comdat::SameSize: case Comdat::SameSize:
ROS << "samesize"; ROS << "samesize";
break; break;
} }
ROS << '\n'; ROS << '\n';
} }
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

llvm/lib/IR/Comdat.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
LLVMComdatSelectionKind LLVMGetComdatSelectionKind(LLVMComdatRef C) { LLVMComdatSelectionKind LLVMGetComdatSelectionKind(LLVMComdatRef C) {
switch (unwrap(C)->getSelectionKind()) { switch (unwrap(C)->getSelectionKind()) {
case Comdat::Any: case Comdat::Any:
return LLVMAnyComdatSelectionKind; return LLVMAnyComdatSelectionKind;
case Comdat::ExactMatch: case Comdat::ExactMatch:
return LLVMExactMatchComdatSelectionKind; return LLVMExactMatchComdatSelectionKind;
case Comdat::Largest: case Comdat::Largest:
return LLVMLargestComdatSelectionKind; return LLVMLargestComdatSelectionKind;
case Comdat::NoDuplicates: case Comdat::NoDeduplicate:
return LLVMNoDuplicatesComdatSelectionKind; return LLVMNoDeduplicateComdatSelectionKind;
case Comdat::SameSize: case Comdat::SameSize:
return LLVMSameSizeComdatSelectionKind; return LLVMSameSizeComdatSelectionKind;
} }
llvm_unreachable("Invalid Comdat SelectionKind!"); llvm_unreachable("Invalid Comdat SelectionKind!");
} }
void LLVMSetComdatSelectionKind(LLVMComdatRef C, LLVMComdatSelectionKind kind) { void LLVMSetComdatSelectionKind(LLVMComdatRef C, LLVMComdatSelectionKind kind) {
Comdat *Cd = unwrap(C); Comdat *Cd = unwrap(C);
switch (kind) { switch (kind) {
case LLVMAnyComdatSelectionKind: case LLVMAnyComdatSelectionKind:
Cd->setSelectionKind(Comdat::Any); Cd->setSelectionKind(Comdat::Any);
break; break;
case LLVMExactMatchComdatSelectionKind: case LLVMExactMatchComdatSelectionKind:
Cd->setSelectionKind(Comdat::ExactMatch); Cd->setSelectionKind(Comdat::ExactMatch);
break; break;
case LLVMLargestComdatSelectionKind: case LLVMLargestComdatSelectionKind:
Cd->setSelectionKind(Comdat::Largest); Cd->setSelectionKind(Comdat::Largest);
break; break;
case LLVMNoDuplicatesComdatSelectionKind: case LLVMNoDeduplicateComdatSelectionKind:
Cd->setSelectionKind(Comdat::NoDuplicates); Cd->setSelectionKind(Comdat::NoDeduplicate);
break; break;
case LLVMSameSizeComdatSelectionKind: case LLVMSameSizeComdatSelectionKind:
Cd->setSelectionKind(Comdat::SameSize); Cd->setSelectionKind(Comdat::SameSize);
break; break;
} }
} }

llvm/lib/Linker/LinkModules.cpp

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines return emitError("Linking COMDATs named '" + ComdatName +
"': invalid selection kinds!"); "': invalid selection kinds!");
} }
switch (Result) { switch (Result) {
case Comdat::SelectionKind::Any: case Comdat::SelectionKind::Any:
// Go with Dst. // Go with Dst.
LinkFromSrc = false; LinkFromSrc = false;
break; break;
case Comdat::SelectionKind::NoDuplicates: case Comdat::SelectionKind::NoDeduplicate:
return emitError("Linking COMDATs named '" + ComdatName + return emitError("Linking COMDATs named '" + ComdatName +
"': noduplicates has been violated!"); "': nodeduplicate has been violated!");
case Comdat::SelectionKind::ExactMatch: case Comdat::SelectionKind::ExactMatch:
case Comdat::SelectionKind::Largest: case Comdat::SelectionKind::Largest:
case Comdat::SelectionKind::SameSize: { case Comdat::SelectionKind::SameSize: {
const GlobalVariable *DstGV; const GlobalVariable *DstGV;
const GlobalVariable *SrcGV; const GlobalVariable *SrcGV;
if (getComdatLeader(DstM, ComdatName, DstGV) || if (getComdatLeader(DstM, ComdatName, DstGV) ||
getComdatLeader(*SrcM, ComdatName, SrcGV)) getComdatLeader(*SrcM, ComdatName, SrcGV))
return true; return true;
▲ Show 20 Lines • Show All 415 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/Internalize.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines if (Comdat *C = GV.getComdat()) {
// redirected. So ComdatMap may not contain C. // redirected. So ComdatMap may not contain C.
if (ComdatMap.lookup(C).External) if (ComdatMap.lookup(C).External)
return false; return false;
if (auto *GO = dyn_cast<GlobalObject>(&GV)) { if (auto *GO = dyn_cast<GlobalObject>(&GV)) {
// If a comdat with one member is not externally visible, we can drop it. // If a comdat with one member is not externally visible, we can drop it.
// Otherwise, the comdat can be used to establish dependencies among the // Otherwise, the comdat can be used to establish dependencies among the
// group of sections. Thus we have to keep the comdat but switch it to // group of sections. Thus we have to keep the comdat but switch it to
// noduplicates. // nodeduplicate.
// Note: noduplicates is not necessary for COFF. wasm doesn't support // Note: nodeduplicate is not necessary for COFF. wasm doesn't support
// noduplicates. // nodeduplicate.
ComdatInfo &Info = ComdatMap.find(C)->second; ComdatInfo &Info = ComdatMap.find(C)->second;
if (Info.Size == 1) if (Info.Size == 1)
GO->setComdat(nullptr); GO->setComdat(nullptr);
else if (!IsWasm) else if (!IsWasm)
C->setSelectionKind(Comdat::NoDuplicates); C->setSelectionKind(Comdat::NoDeduplicate);
} }
if (GV.hasLocalLinkage()) if (GV.hasLocalLinkage())
return false; return false;
} else { } else {
if (GV.hasLocalLinkage()) if (GV.hasLocalLinkage())
return false; return false;
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

Show First 20 Lines • Show All 1,913 Lines • ▼ Show 20 Linesbool ModuleAddressSanitizer::shouldInstrumentGlobal(GlobalVariable *G) const {
} }
// If a comdat is present, it must have a selection kind that implies ODR // If a comdat is present, it must have a selection kind that implies ODR
// semantics: no duplicates, any, or exact match. // semantics: no duplicates, any, or exact match.
if (Comdat *C = G->getComdat()) { if (Comdat *C = G->getComdat()) {
switch (C->getSelectionKind()) { switch (C->getSelectionKind()) {
case Comdat::Any: case Comdat::Any:
case Comdat::ExactMatch: case Comdat::ExactMatch:
case Comdat::NoDuplicates: case Comdat::NoDeduplicate:
break; break;
case Comdat::Largest: case Comdat::Largest:
case Comdat::SameSize: case Comdat::SameSize:
return false; return false;
} }
} }
if (G->hasSection()) { if (G->hasSection()) {
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines if (!C) {
} else { } else {
C = M.getOrInsertComdat(G->getName()); C = M.getOrInsertComdat(G->getName());
} }
// Make this IMAGE_COMDAT_SELECT_NODUPLICATES on COFF. Also upgrade private // Make this IMAGE_COMDAT_SELECT_NODUPLICATES on COFF. Also upgrade private
// linkage to internal linkage so that a symbol table entry is emitted. This // linkage to internal linkage so that a symbol table entry is emitted. This
// is necessary in order to create the comdat group. // is necessary in order to create the comdat group.
if (TargetTriple.isOSBinFormatCOFF()) { if (TargetTriple.isOSBinFormatCOFF()) {
C->setSelectionKind(Comdat::NoDuplicates); C->setSelectionKind(Comdat::NoDeduplicate);
if (G->hasPrivateLinkage()) if (G->hasPrivateLinkage())
G->setLinkage(GlobalValue::InternalLinkage); G->setLinkage(GlobalValue::InternalLinkage);
} }
G->setComdat(C); G->setComdat(C);
} }
assert(G->hasComdat()); assert(G->hasComdat());
Metadata->setComdat(G->getComdat()); Metadata->setComdat(G->getComdat());
▲ Show 20 Lines • Show All 1,472 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

Show First 20 Lines • Show All 856 Lines • ▼ Show 20 LinesInstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
// sections. // sections.
// //
// If the data variable is referenced by code, counters and data have to be // If the data variable is referenced by code, counters and data have to be
// in different comdats for COFF because the Visual C++ linker will report // in different comdats for COFF because the Visual C++ linker will report
// duplicate symbol errors if there are multiple external symbols with the // duplicate symbol errors if there are multiple external symbols with the
// same name marked IMAGE_COMDAT_SELECT_ASSOCIATIVE. // same name marked IMAGE_COMDAT_SELECT_ASSOCIATIVE.
// //
// For ELF, when not using COMDAT, put counters, data and values into a // For ELF, when not using COMDAT, put counters, data and values into a
// noduplicates COMDAT which is lowered to a zero-flag section group. This // nodeduplicate COMDAT which is lowered to a zero-flag section group. This
// allows -z start-stop-gc to discard the entire group when the function is // allows -z start-stop-gc to discard the entire group when the function is
// discarded. // discarded.
bool DataReferencedByCode = profDataReferencedByCode(*M); bool DataReferencedByCode = profDataReferencedByCode(*M);
bool NeedComdat = needsComdatForCounter(*Fn, *M); bool NeedComdat = needsComdatForCounter(*Fn, *M);
std::string CntsVarName = getVarName(Inc, getInstrProfCountersVarPrefix()); std::string CntsVarName = getVarName(Inc, getInstrProfCountersVarPrefix());
std::string DataVarName = getVarName(Inc, getInstrProfDataVarPrefix()); std::string DataVarName = getVarName(Inc, getInstrProfDataVarPrefix());
auto MaybeSetComdat = [&](GlobalVariable *GV) { auto MaybeSetComdat = [&](GlobalVariable *GV) {
bool UseComdat = (NeedComdat || TT.isOSBinFormatELF()); bool UseComdat = (NeedComdat || TT.isOSBinFormatELF());
if (UseComdat) { if (UseComdat) {
StringRef GroupName = TT.isOSBinFormatCOFF() && DataReferencedByCode StringRef GroupName = TT.isOSBinFormatCOFF() && DataReferencedByCode
? GV->getName() ? GV->getName()
: CntsVarName; : CntsVarName;
Comdat *C = M->getOrInsertComdat(GroupName); Comdat *C = M->getOrInsertComdat(GroupName);
if (!NeedComdat) if (!NeedComdat)
C->setSelectionKind(Comdat::NoDuplicates); C->setSelectionKind(Comdat::NoDeduplicate);
GV->setComdat(C); GV->setComdat(C);
} }
}; };
uint64_t NumCounters = Inc->getNumCounters()->getZExtValue(); uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
LLVMContext &Ctx = M->getContext(); LLVMContext &Ctx = M->getContext();
ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters); ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
▲ Show 20 Lines • Show All 301 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/Instrumentation.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 LinesComdat *llvm::getOrCreateFunctionComdat(Function &F, Triple &T) {
assert(F.hasName()); assert(F.hasName());
Module *M = F.getParent(); Module *M = F.getParent();
// Make a new comdat for the function. Use the "no duplicates" selection kind // Make a new comdat for the function. Use the "no duplicates" selection kind
// if the object file format supports it. For COFF we restrict it to non-weak // if the object file format supports it. For COFF we restrict it to non-weak
// symbols. // symbols.
Comdat *C = M->getOrInsertComdat(F.getName()); Comdat *C = M->getOrInsertComdat(F.getName());
if (T.isOSBinFormatELF() || (T.isOSBinFormatCOFF() && !F.isWeakForLinker())) if (T.isOSBinFormatELF() || (T.isOSBinFormatCOFF() && !F.isWeakForLinker()))
C->setSelectionKind(Comdat::NoDuplicates); C->setSelectionKind(Comdat::NoDeduplicate);
F.setComdat(C); F.setComdat(C);
return C; return C;
} }
/// initializeInstrumentation - Initialize all passes in the TransformUtils /// initializeInstrumentation - Initialize all passes in the TransformUtils
/// library. /// library.
void llvm::initializeInstrumentation(PassRegistry &Registry) { void llvm::initializeInstrumentation(PassRegistry &Registry) {
initializeAddressSanitizerLegacyPassPass(Registry); initializeAddressSanitizerLegacyPassPass(Registry);
Show All 25 Lines

llvm/test/Bitcode/compatibility-3.6.ll

Show All 17 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
; Global Variables -- comdat ; Global Variables -- comdat
@comdat.any = global i32 0, comdat @comdat.any = global i32 0, comdat
; CHECK: @comdat.any = global i32 0, comdat ; CHECK: @comdat.any = global i32 0, comdat
@comdat.exactmatch = global i32 0, comdat @comdat.exactmatch = global i32 0, comdat
; CHECK: @comdat.exactmatch = global i32 0, comdat ; CHECK: @comdat.exactmatch = global i32 0, comdat
▲ Show 20 Lines • Show All 1,174 Lines • Show Last 20 Lines

llvm/test/Bitcode/compatibility-3.7.ll

Show All 17 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
;; Constants ;; Constants
@const.true = constant i1 true @const.true = constant i1 true
; CHECK: @const.true = constant i1 true ; CHECK: @const.true = constant i1 true
@const.false = constant i1 false @const.false = constant i1 false
; CHECK: @const.false = constant i1 false ; CHECK: @const.false = constant i1 false
▲ Show 20 Lines • Show All 1,247 Lines • Show Last 20 Lines

llvm/test/Bitcode/compatibility-3.8.ll

Show All 16 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
;; Constants ;; Constants
@const.true = constant i1 true @const.true = constant i1 true
; CHECK: @const.true = constant i1 true ; CHECK: @const.true = constant i1 true
@const.false = constant i1 false @const.false = constant i1 false
; CHECK: @const.false = constant i1 false ; CHECK: @const.false = constant i1 false
▲ Show 20 Lines • Show All 1,558 Lines • Show Last 20 Lines

llvm/test/Bitcode/compatibility-3.9.ll

Show All 16 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
;; Constants ;; Constants
@const.true = constant i1 true @const.true = constant i1 true
; CHECK: @const.true = constant i1 true ; CHECK: @const.true = constant i1 true
@const.false = constant i1 false @const.false = constant i1 false
; CHECK: @const.false = constant i1 false ; CHECK: @const.false = constant i1 false
▲ Show 20 Lines • Show All 1,632 Lines • Show Last 20 Lines

llvm/test/Bitcode/compatibility-4.0.ll

Show All 16 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
;; Constants ;; Constants
@const.true = constant i1 true @const.true = constant i1 true
; CHECK: @const.true = constant i1 true ; CHECK: @const.true = constant i1 true
@const.false = constant i1 false @const.false = constant i1 false
; CHECK: @const.false = constant i1 false ; CHECK: @const.false = constant i1 false
▲ Show 20 Lines • Show All 1,657 Lines • Show Last 20 Lines

llvm/test/Bitcode/compatibility-5.0.ll

Show All 16 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
;; Constants ;; Constants
@const.true = constant i1 true @const.true = constant i1 true
; CHECK: @const.true = constant i1 true ; CHECK: @const.true = constant i1 true
@const.false = constant i1 false @const.false = constant i1 false
; CHECK: @const.false = constant i1 false ; CHECK: @const.false = constant i1 false
▲ Show 20 Lines • Show All 1,673 Lines • Show Last 20 Lines

llvm/test/Bitcode/compatibility-6.0.ll

Show All 17 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
;; Constants ;; Constants
@const.true = constant i1 true @const.true = constant i1 true
; CHECK: @const.true = constant i1 true ; CHECK: @const.true = constant i1 true
@const.false = constant i1 false @const.false = constant i1 false
; CHECK: @const.false = constant i1 false ; CHECK: @const.false = constant i1 false
▲ Show 20 Lines • Show All 1,683 Lines • Show Last 20 Lines

llvm/test/Bitcode/compatibility.ll

Show All 19 Lines
;; Comdats ;; Comdats
$comdat.any = comdat any $comdat.any = comdat any
; CHECK: $comdat.any = comdat any ; CHECK: $comdat.any = comdat any
$comdat.exactmatch = comdat exactmatch $comdat.exactmatch = comdat exactmatch
; CHECK: $comdat.exactmatch = comdat exactmatch ; CHECK: $comdat.exactmatch = comdat exactmatch
$comdat.largest = comdat largest $comdat.largest = comdat largest
; CHECK: $comdat.largest = comdat largest ; CHECK: $comdat.largest = comdat largest
$comdat.noduplicates = comdat noduplicates $comdat.noduplicates = comdat nodeduplicate
; CHECK: $comdat.noduplicates = comdat noduplicates ; CHECK: $comdat.noduplicates = comdat nodeduplicate
$comdat.samesize = comdat samesize $comdat.samesize = comdat samesize
; CHECK: $comdat.samesize = comdat samesize ; CHECK: $comdat.samesize = comdat samesize
;; Constants ;; Constants
@const.true = constant i1 true @const.true = constant i1 true
; CHECK: @const.true = constant i1 true ; CHECK: @const.true = constant i1 true
@const.false = constant i1 false @const.false = constant i1 false
; CHECK: @const.false = constant i1 false ; CHECK: @const.false = constant i1 false
▲ Show 20 Lines • Show All 1,962 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/coff-comdat.ll

Show All 12 Lines
} }
$f3 = comdat largest $f3 = comdat largest
@v3 = global i32 0, comdat($f3) @v3 = global i32 0, comdat($f3)
define void @f3() comdat($f3) { define void @f3() comdat($f3) {
ret void ret void
} }
$f4 = comdat noduplicates $f4 = comdat nodeduplicate
@v4 = global i32 0, comdat($f4) @v4 = global i32 0, comdat($f4)
define void @f4() comdat($f4) { define void @f4() comdat($f4) {
ret void ret void
} }
$f5 = comdat samesize $f5 = comdat samesize
@v5 = global i32 0, comdat($f5) @v5 = global i32 0, comdat($f5)
define void @f5() comdat($f5) { define void @f5() comdat($f5) {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/elf-group.ll

; Checks that comdat with noduplicates kind is lowered to a zero-flag ELF ; Checks that comdat with nodeduplicate kind is lowered to a zero-flag ELF
; section group. ; section group.
; RUN: llc < %s -mtriple=x86_64-unknown-linux | FileCheck %s ; RUN: llc < %s -mtriple=x86_64-unknown-linux | FileCheck %s
; CHECK: .section .text.f1,"axG",@progbits,f1{{$}} ; CHECK: .section .text.f1,"axG",@progbits,f1{{$}}
; CHECK: .section .text.f2,"axG",@progbits,f1{{$}} ; CHECK: .section .text.f2,"axG",@progbits,f1{{$}}
; CHECK: .section .bss.g1,"aGw",@nobits,f1{{$}} ; CHECK: .section .bss.g1,"aGw",@nobits,f1{{$}}
$f1 = comdat noduplicates $f1 = comdat nodeduplicate
define void @f1() comdat { define void @f1() comdat {
unreachable unreachable
} }
define hidden void @f2() comdat($f1) { define hidden void @f2() comdat($f1) {
unreachable unreachable
} }
@g1 = global i32 0, comdat($f1) @g1 = global i32 0, comdat($f1)

llvm/test/CodeGen/X86/gcc_except_table-multi.ll

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lineslpad:
%0 = landingpad { i8*, i32 } catch i8* bitcast (i8** @_ZTIi to i8*) %0 = landingpad { i8*, i32 } catch i8* bitcast (i8** @_ZTIi to i8*)
br label %eh.resume br label %eh.resume
try.cont: try.cont:
ret i32 0 ret i32 0
eh.resume: eh.resume:
resume { i8*, i32 } %0 resume { i8*, i32 } %0
} }
;; If the function is in a comdat group with noduplicates kind, the generated ;; If the function is in a comdat group with nodeduplicate kind, the generated
;; .gcc_except_table should is lowered to a zero-flag ELF section group. ;; .gcc_except_table should is lowered to a zero-flag ELF section group.
$zero = comdat noduplicates $zero = comdat nodeduplicate
define i32 @zero() uwtable comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define i32 @zero() uwtable comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; CHECK-LABEL: zero: ; CHECK-LABEL: zero:
; CHECK: .cfi_endproc ; CHECK: .cfi_endproc
; NORMAL-NEXT: .section .gcc_except_table.zero,"aG",@progbits,zero{{$}} ; NORMAL-NEXT: .section .gcc_except_table.zero,"aG",@progbits,zero{{$}}
; SEP_BFD-NEXT: .section .gcc_except_table.zero,"aG",@progbits,zero{{$}} ; SEP_BFD-NEXT: .section .gcc_except_table.zero,"aG",@progbits,zero{{$}}
; SEP-NEXT: .section .gcc_except_table.zero,"aGo",@progbits,zero,zero{{$}} ; SEP-NEXT: .section .gcc_except_table.zero,"aGo",@progbits,zero,zero{{$}}
; SEP_NOUNIQUE-NEXT: .section .gcc_except_table,"aG",@progbits,zero{{$}} ; SEP_NOUNIQUE-NEXT: .section .gcc_except_table,"aG",@progbits,zero{{$}}
; NOUNIQUE-NEXT: .section .gcc_except_table,"aG",@progbits,zero{{$}} ; NOUNIQUE-NEXT: .section .gcc_except_table,"aG",@progbits,zero{{$}}
Show All 14 Lines

llvm/test/Instrumentation/AddressSanitizer/global_metadata_windows.ll

; Test that global metadata is placed in a separate section on Windows, and that ; Test that global metadata is placed in a separate section on Windows, and that
; it is in the same comdat group as the instrumented global. This ensures that ; it is in the same comdat group as the instrumented global. This ensures that
; linker dead stripping (/OPT:REF) works as intended. ; linker dead stripping (/OPT:REF) works as intended.
; FIXME: Later we can use this to instrument linkonce odr string literals. ; FIXME: Later we can use this to instrument linkonce odr string literals.
; RUN: opt < %s -asan -asan-module -enable-new-pm=0 -asan-globals-live-support=1 -S | FileCheck %s ; RUN: opt < %s -asan -asan-module -enable-new-pm=0 -asan-globals-live-support=1 -S | FileCheck %s
; RUN: opt < %s -passes='asan-pipeline' -asan-globals-live-support=1 -S | FileCheck %s ; RUN: opt < %s -passes='asan-pipeline' -asan-globals-live-support=1 -S | FileCheck %s
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
$mystr = comdat any $mystr = comdat any
; CHECK: $dead_global = comdat noduplicates ; CHECK: $dead_global = comdat nodeduplicate
; CHECK: $private_str = comdat noduplicates ; CHECK: $private_str = comdat nodeduplicate
; CHECK: @dead_global = global { i32, [28 x i8] } { i32 42, [28 x i8] zeroinitializer }, comdat, align 32 ; CHECK: @dead_global = global { i32, [28 x i8] } { i32 42, [28 x i8] zeroinitializer }, comdat, align 32
; CHECK: @private_str = internal constant { [8 x i8], [24 x i8] } { [8 x i8] c"private\00", [24 x i8] zeroinitializer }, comdat, align 32 ; CHECK: @private_str = internal constant { [8 x i8], [24 x i8] } { [8 x i8] c"private\00", [24 x i8] zeroinitializer }, comdat, align 32
; CHECK: @__asan_global_dead_global = private global { {{.*}} }, section ".ASAN$GL", comdat($dead_global), align 64, !associated ; CHECK: @__asan_global_dead_global = private global { {{.*}} }, section ".ASAN$GL", comdat($dead_global), align 64, !associated
; CHECK: @__asan_global_private_str = private global { {{.*}} }, section ".ASAN$GL", comdat($private_str), align 64, !associated ; CHECK: @__asan_global_private_str = private global { {{.*}} }, section ".ASAN$GL", comdat($private_str), align 64, !associated
; CHECK: @llvm.compiler.used {{.*}} @__asan_global_dead_global {{.*}} @__asan_global_private_str {{.*}} section "llvm.metadata" ; CHECK: @llvm.compiler.used {{.*}} @__asan_global_dead_global {{.*}} @__asan_global_private_str {{.*}} section "llvm.metadata"
Show All 26 Lines

llvm/test/Instrumentation/InstrProfiling/linkage.ll

;; Check that runtime symbols get appropriate linkage. ;; Check that runtime symbols get appropriate linkage.
; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -instrprof -S | FileCheck %s --check-prefixes=MACHO ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -instrprof -S | FileCheck %s --check-prefixes=MACHO
; RUN: opt < %s -mtriple=x86_64-unknown-linux -instrprof -S | FileCheck %s --check-prefixes=ELF ; RUN: opt < %s -mtriple=x86_64-unknown-linux -instrprof -S | FileCheck %s --check-prefixes=ELF
; RUN: opt < %s -mtriple=x86_64-unknown-fuchsia -instrprof -S | FileCheck %s --check-prefixes=ELF ; RUN: opt < %s -mtriple=x86_64-unknown-fuchsia -instrprof -S | FileCheck %s --check-prefixes=ELF
; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -instrprof -S | FileCheck %s --check-prefixes=COFF ; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -instrprof -S | FileCheck %s --check-prefixes=COFF
; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -passes=instrprof -S | FileCheck %s --check-prefixes=MACHO ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.10.0 -passes=instrprof -S | FileCheck %s --check-prefixes=MACHO
; RUN: opt < %s -mtriple=x86_64-unknown-linux -passes=instrprof -S | FileCheck %s --check-prefixes=ELF ; RUN: opt < %s -mtriple=x86_64-unknown-linux -passes=instrprof -S | FileCheck %s --check-prefixes=ELF
; RUN: opt < %s -mtriple=x86_64-unknown-fuchsia -passes=instrprof -S | FileCheck %s --check-prefixes=ELF ; RUN: opt < %s -mtriple=x86_64-unknown-fuchsia -passes=instrprof -S | FileCheck %s --check-prefixes=ELF
; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -passes=instrprof -S | FileCheck %s --check-prefixes=COFF ; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -passes=instrprof -S | FileCheck %s --check-prefixes=COFF
; MACHO: @__llvm_profile_runtime = external global i32 ; MACHO: @__llvm_profile_runtime = external global i32
; ELF-NOT: @__llvm_profile_runtime = external global i32 ; ELF-NOT: @__llvm_profile_runtime = external global i32
; ELF: $__profc_foo = comdat noduplicates ; ELF: $__profc_foo = comdat nodeduplicate
; ELF: $__profc_foo_weak = comdat noduplicates ; ELF: $__profc_foo_weak = comdat nodeduplicate
; ELF: $"__profc_linkage.ll:foo_internal" = comdat noduplicates ; ELF: $"__profc_linkage.ll:foo_internal" = comdat nodeduplicate
; ELF: $__profc_foo_inline = comdat noduplicates ; ELF: $__profc_foo_inline = comdat nodeduplicate
; ELF: $__profc_foo_extern = comdat any ; ELF: $__profc_foo_extern = comdat any
@__profn_foo = private constant [3 x i8] c"foo" @__profn_foo = private constant [3 x i8] c"foo"
@__profn_foo_weak = weak hidden constant [8 x i8] c"foo_weak" @__profn_foo_weak = weak hidden constant [8 x i8] c"foo_weak"
@"__profn_linkage.ll:foo_internal" = private constant [23 x i8] c"linkage.ll:foo_internal" @"__profn_linkage.ll:foo_internal" = private constant [23 x i8] c"linkage.ll:foo_internal"
@__profn_foo_inline = linkonce_odr hidden constant [10 x i8] c"foo_inline" @__profn_foo_inline = linkonce_odr hidden constant [10 x i8] c"foo_inline"
@__profn_foo_extern = linkonce_odr hidden constant [10 x i8] c"foo_extern" @__profn_foo_extern = linkonce_odr hidden constant [10 x i8] c"foo_extern"
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Instrumentation/SanitizerCoverage/coff-comdat.ll

Show All 14 Lines
; int foo(int x) { ; int foo(int x) {
; if (baz(0)) ; if (baz(0))
; x = bar(x); ; x = bar(x);
; return x; ; return x;
; } ; }
; Both new comdats should no duplicates on COFF. ; Both new comdats should no duplicates on COFF.
; CHECK: $foo = comdat noduplicates ; CHECK: $foo = comdat nodeduplicate
; CHECK: $bar = comdat noduplicates ; CHECK: $bar = comdat nodeduplicate
; Tables for 'foo' should be in the 'foo' comdat. ; Tables for 'foo' should be in the 'foo' comdat.
; CHECK: @__sancov_gen_{{.*}} = private global [1 x i8] zeroinitializer, section ".SCOV$CM", comdat($foo), align 1 ; CHECK: @__sancov_gen_{{.*}} = private global [1 x i8] zeroinitializer, section ".SCOV$CM", comdat($foo), align 1
; CHECK: @__sancov_gen_{{.*}} = private constant [2 x i64*] ; CHECK: @__sancov_gen_{{.*}} = private constant [2 x i64*]
; CHECK-SAME: [i64* bitcast (i32 (i32)* @foo to i64*), i64* inttoptr (i64 1 to i64*)], ; CHECK-SAME: [i64* bitcast (i32 (i32)* @foo to i64*), i64* inttoptr (i64 1 to i64*)],
; CHECK-SAME: section ".SCOVP$M", comdat($foo), align 8 ; CHECK-SAME: section ".SCOVP$M", comdat($foo), align 8
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Instrumentation/SanitizerCoverage/inline-bool-flag.ll

; Test -sanitizer-coverage-inline-bool-flag=1 ; Test -sanitizer-coverage-inline-bool-flag=1
; RUN: opt < %s -sancov -sanitizer-coverage-level=1 -sanitizer-coverage-inline-bool-flag=1 -S -enable-new-pm=0 | FileCheck %s ; RUN: opt < %s -sancov -sanitizer-coverage-level=1 -sanitizer-coverage-inline-bool-flag=1 -S -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=1 -sanitizer-coverage-inline-bool-flag=1 -S | FileCheck %s ; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=1 -sanitizer-coverage-inline-bool-flag=1 -S | FileCheck %s
; CHECK: $foo = comdat noduplicates ; CHECK: $foo = comdat nodeduplicate
; CHECK: @__sancov_gen_ = private global [1 x i1] zeroinitializer, section "__sancov_bools", comdat($foo), align 1{{$}} ; CHECK: @__sancov_gen_ = private global [1 x i1] zeroinitializer, section "__sancov_bools", comdat($foo), align 1{{$}}
; CHECK: @__start___sancov_bools = extern_weak hidden global i1 ; CHECK: @__start___sancov_bools = extern_weak hidden global i1
; CHECK-NEXT: @__stop___sancov_bools = extern_weak hidden global i1 ; CHECK-NEXT: @__stop___sancov_bools = extern_weak hidden global i1
; CHECK-NOT: @llvm.used = ; CHECK-NOT: @llvm.used =
; CHECK: @llvm.compiler.used = appending global [1 x i8*] [i8* bitcast ([1 x i1]* @__sancov_gen_ to i8*)], section "llvm.metadata" ; CHECK: @llvm.compiler.used = appending global [1 x i8*] [i8* bitcast ([1 x i1]* @__sancov_gen_ to i8*)], section "llvm.metadata"
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
Show All 18 Lines

llvm/test/Instrumentation/SanitizerCoverage/interposable-symbol.ll

Show All 25 Linesentry:
ret void ret void
} }
define weak_odr void @WeakOdr() { define weak_odr void @WeakOdr() {
entry: entry:
ret void ret void
} }
; CHECK: $Vanilla = comdat noduplicates ; CHECK: $Vanilla = comdat nodeduplicate
; ELF: $LinkOnceOdr = comdat noduplicates ; ELF: $LinkOnceOdr = comdat nodeduplicate
; COFF: $LinkOnceOdr = comdat any ; COFF: $LinkOnceOdr = comdat any
; CHECK: @__sancov_gen_ = private global [1 x i32] zeroinitializer, section {{.*}}, comdat($Vanilla), align 4{{$}} ; CHECK: @__sancov_gen_ = private global [1 x i32] zeroinitializer, section {{.*}}, comdat($Vanilla), align 4{{$}}
; CHECK-NEXT: @__sancov_gen_.1 = private global [1 x i32] zeroinitializer, section {{.*}}, align 4{{$}} ; CHECK-NEXT: @__sancov_gen_.1 = private global [1 x i32] zeroinitializer, section {{.*}}, align 4{{$}}
; CHECK-NEXT: @__sancov_gen_.2 = private global [1 x i32] zeroinitializer, section {{.*}}, align 4{{$}} ; CHECK-NEXT: @__sancov_gen_.2 = private global [1 x i32] zeroinitializer, section {{.*}}, align 4{{$}}
; CHECK-NEXT: @__sancov_gen_.3 = private global [1 x i32] zeroinitializer, section {{.*}}, comdat($LinkOnceOdr), align 4{{$}} ; CHECK-NEXT: @__sancov_gen_.3 = private global [1 x i32] zeroinitializer, section {{.*}}, comdat($LinkOnceOdr), align 4{{$}}
; CHECK-NEXT: @__sancov_gen_.4 = private global [1 x i32] zeroinitializer, section {{.*}}, comdat($WeakOdr), align 4{{$}} ; CHECK-NEXT: @__sancov_gen_.4 = private global [1 x i32] zeroinitializer, section {{.*}}, comdat($WeakOdr), align 4{{$}}
; CHECK: define void @Vanilla() comdat { ; CHECK: define void @Vanilla() comdat {
; ELF: define linkonce void @LinkOnce() comdat { ; ELF: define linkonce void @LinkOnce() comdat {
; ELF: define weak void @Weak() comdat { ; ELF: define weak void @Weak() comdat {
; COFF: define linkonce void @LinkOnce() { ; COFF: define linkonce void @LinkOnce() {
; COFF: define weak void @Weak() { ; COFF: define weak void @Weak() {
; CHECK: declare extern_weak void @ExternWeak() ; CHECK: declare extern_weak void @ExternWeak()
; CHECK: define linkonce_odr void @LinkOnceOdr() comdat { ; CHECK: define linkonce_odr void @LinkOnceOdr() comdat {
; CHECK: define weak_odr void @WeakOdr() comdat { ; CHECK: define weak_odr void @WeakOdr() comdat {

llvm/test/Instrumentation/SanitizerCoverage/trace-pc-guard.ll

; RUN: opt < %s -sancov -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=x86_64 -S -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,COMDAT,ELF ; RUN: opt < %s -sancov -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=x86_64 -S -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,COMDAT,ELF
; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=x86_64 -S | FileCheck %s --check-prefixes=CHECK,COMDAT,ELF ; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=x86_64 -S | FileCheck %s --check-prefixes=CHECK,COMDAT,ELF
; RUN: opt < %s -sancov -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=aarch64-apple-darwin -S -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,MACHO ; RUN: opt < %s -sancov -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=aarch64-apple-darwin -S -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,MACHO
; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=aarch64-apple-darwin -S | FileCheck %s --check-prefixes=CHECK,MACHO ; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=aarch64-apple-darwin -S | FileCheck %s --check-prefixes=CHECK,MACHO
; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=x86_64-windows -S | FileCheck %s --check-prefixes=CHECK,COMDAT,WIN ; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=4 -sanitizer-coverage-trace-pc-guard -mtriple=x86_64-windows -S | FileCheck %s --check-prefixes=CHECK,COMDAT,WIN
; COMDAT: $foo = comdat noduplicates ; COMDAT: $foo = comdat nodeduplicate
; COMDAT: $CallViaVptr = comdat noduplicates ; COMDAT: $CallViaVptr = comdat nodeduplicate
; ELF: @__sancov_gen_ = private global [3 x i32] zeroinitializer, section "__sancov_guards", comdat($foo), align 4{{$}} ; ELF: @__sancov_gen_ = private global [3 x i32] zeroinitializer, section "__sancov_guards", comdat($foo), align 4{{$}}
; ELF-NEXT: @__sancov_gen_.1 = private global [1 x i32] zeroinitializer, section "__sancov_guards", comdat($CallViaVptr), align 4{{$}} ; ELF-NEXT: @__sancov_gen_.1 = private global [1 x i32] zeroinitializer, section "__sancov_guards", comdat($CallViaVptr), align 4{{$}}
; MACHO: @__sancov_gen_ = private global [3 x i32] zeroinitializer, section "__DATA,__sancov_guards", align 4{{$}} ; MACHO: @__sancov_gen_ = private global [3 x i32] zeroinitializer, section "__DATA,__sancov_guards", align 4{{$}}
; MACHO-NEXT: @__sancov_gen_.1 = private global [1 x i32] zeroinitializer, section "__DATA,__sancov_guards", align 4{{$}} ; MACHO-NEXT: @__sancov_gen_.1 = private global [1 x i32] zeroinitializer, section "__DATA,__sancov_guards", align 4{{$}}
; WIN: @__sancov_gen_ = private global [3 x i32] zeroinitializer, section ".SCOV$GM", comdat($foo), align 4{{$}} ; WIN: @__sancov_gen_ = private global [3 x i32] zeroinitializer, section ".SCOV$GM", comdat($foo), align 4{{$}}
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Linker/Inputs/comdat3.ll

$foo = comdat noduplicates $foo = comdat nodeduplicate
@foo = global i64 43, comdat($foo) @foo = global i64 43, comdat($foo)

llvm/test/Linker/comdat4.ll

; RUN: not llvm-link %s %p/Inputs/comdat3.ll -S -o - 2>&1 | FileCheck %s ; RUN: not llvm-link %s %p/Inputs/comdat3.ll -S -o - 2>&1 | FileCheck %s
$foo = comdat noduplicates $foo = comdat nodeduplicate
@foo = global i64 43, comdat($foo) @foo = global i64 43, comdat($foo)
; CHECK: Linking COMDATs named 'foo': noduplicates has been violated! ; CHECK: Linking COMDATs named 'foo': nodeduplicate has been violated!

llvm/test/SymbolRewriter/rewrite.ll

Show All 39 Lines
define dllexport void @source_comdat_function_1() comdat($source_comdat_function_1) { define dllexport void @source_comdat_function_1() comdat($source_comdat_function_1) {
entry: entry:
ret void ret void
} }
$source_comdat_variable = comdat largest $source_comdat_variable = comdat largest
@source_comdat_variable = global i32 32, comdat($source_comdat_variable) @source_comdat_variable = global i32 32, comdat($source_comdat_variable)
$source_comdat_variable_1 = comdat noduplicates $source_comdat_variable_1 = comdat nodeduplicate
@source_comdat_variable_1 = global i32 64, comdat($source_comdat_variable_1) @source_comdat_variable_1 = global i32 64, comdat($source_comdat_variable_1)
; CHECK: $target_comdat_function = comdat any ; CHECK: $target_comdat_function = comdat any
; CHECK: $target_comdat_function_1 = comdat exactmatch ; CHECK: $target_comdat_function_1 = comdat exactmatch
; CHECK: $target_comdat_variable = comdat largest ; CHECK: $target_comdat_variable = comdat largest
; CHECK: $target_comdat_variable_1 = comdat noduplicates ; CHECK: $target_comdat_variable_1 = comdat nodeduplicate
; CHECK: @target_variable = external global i32 ; CHECK: @target_variable = external global i32
; CHECK-NOT: @source_variable = external global i32 ; CHECK-NOT: @source_variable = external global i32
; CHECK: @target_pattern_variable = external global i32 ; CHECK: @target_pattern_variable = external global i32
; CHECK-NOT: @source_pattern_variable = external global i32 ; CHECK-NOT: @source_pattern_variable = external global i32
; CHECK: @target_pattern_multiple_variable_matches = external global i32 ; CHECK: @target_pattern_multiple_variable_matches = external global i32
; CHECK-NOT: @source_pattern_multiple_variable_matches = external global i32 ; CHECK-NOT: @source_pattern_multiple_variable_matches = external global i32
; CHECK: @target_comdat_variable = global i32 32, comdat ; CHECK: @target_comdat_variable = global i32 32, comdat
Show All 32 Lines

llvm/test/Transforms/Internalize/comdat.ll

; RUN: opt < %s -mtriple=x86_64 -internalize -internalize-public-api-list main -internalize-public-api-list c1 -internalize-public-api-list c2 \ ; RUN: opt < %s -mtriple=x86_64 -internalize -internalize-public-api-list main -internalize-public-api-list c1 -internalize-public-api-list c2 \
; RUN: -internalize-public-api-list c3 -internalize-public-api-list c4 -S | FileCheck %s --check-prefixes=CHECK,NODUP ; RUN: -internalize-public-api-list c3 -internalize-public-api-list c4 -S | FileCheck %s --check-prefixes=CHECK,NODUP
; RUN: opt < %s -mtriple=x86_64-windows -internalize -internalize-public-api-list main -internalize-public-api-list c1 -internalize-public-api-list c2 \ ; RUN: opt < %s -mtriple=x86_64-windows -internalize -internalize-public-api-list main -internalize-public-api-list c1 -internalize-public-api-list c2 \
; RUN: -internalize-public-api-list c3 -internalize-public-api-list c4 -S | FileCheck %s --check-prefixes=CHECK,NODUP ; RUN: -internalize-public-api-list c3 -internalize-public-api-list c4 -S | FileCheck %s --check-prefixes=CHECK,NODUP
; RUN: opt < %s -mtriple=wasm32 -internalize -internalize-public-api-list main -internalize-public-api-list c1 -internalize-public-api-list c2 \ ; RUN: opt < %s -mtriple=wasm32 -internalize -internalize-public-api-list main -internalize-public-api-list c1 -internalize-public-api-list c2 \
; RUN: -internalize-public-api-list c3 -internalize-public-api-list c4 -S | FileCheck %s --check-prefixes=CHECK,WASM ; RUN: -internalize-public-api-list c3 -internalize-public-api-list c4 -S | FileCheck %s --check-prefixes=CHECK,WASM
$c1 = comdat any $c1 = comdat any
$c2 = comdat any $c2 = comdat any
$c3 = comdat any $c3 = comdat any
$c4 = comdat any $c4 = comdat any
$c5 = comdat any $c5 = comdat any
; CHECK: $c1 = comdat any ; CHECK: $c1 = comdat any
;; wasm doesn't support noduplicates. ;; wasm doesn't support nodeduplicate.
; NODUP: $c2 = comdat noduplicates ; NODUP: $c2 = comdat nodeduplicate
; WASM: $c2 = comdat any ; WASM: $c2 = comdat any
; CHECK: $c3 = comdat any ; CHECK: $c3 = comdat any
; CHECK: $c4 = comdat any ; CHECK: $c4 = comdat any
; CHECK: @c1_c = global i32 0, comdat($c1) ; CHECK: @c1_c = global i32 0, comdat($c1)
@c1_c = global i32 0, comdat($c1) @c1_c = global i32 0, comdat($c1)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines
  翻译：