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

[MaskRay]

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.

[rnk]

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.

[MaskRay]

update comments

[MaskRay]

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

[MaskRay]

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

llvm/bindings/go/llvm/ir.go

 //-------------------------------------------------------------------------
 // llvm.ComdatSelectionKind
 //-------------------------------------------------------------------------
 
 const (
   AnyComdatSelectionKind          ComdatSelectionKind = C.LLVMAnyComdatSelectionKind
   ExactMatchComdatSelectionKind   ComdatSelectionKind = C.LLVMExactMatchComdatSelectionKind
   LargestComdatSelectionKind      ComdatSelectionKind = C.LLVMLargestComdatSelectionKind
-  NoDuplicatesComdatSelectionKind ComdatSelectionKind = C.LLVMNoDuplicatesComdatSelectionKind
+  NoDeduplicateComdatSelectionKind ComdatSelectionKind = C.LLVMNoDeduplicateComdatSelectionKind
   SameSizeComdatSelectionKind     ComdatSelectionKind = C.LLVMSameSizeComdatSelectionKind
 )
 
 //-------------------------------------------------------------------------
 // llvm.IntPredicate
 //-------------------------------------------------------------------------
 
 const (

llvm/docs/BitCodeFormat.rst

 * code 4: ``inlinehint``
 * code 5: ``inreg``
 * code 6: ``minsize``
 * code 7: ``naked``
 * code 8: ``nest``
 * code 9: ``noalias``
 * code 10: ``nobuiltin``
 * code 11: ``nocapture``
-* code 12: ``noduplicates``
+* code 12: ``nodeduplicate``
 * code 13: ``noimplicitfloat``
 * code 14: ``noinline``
 * code 15: ``nonlazybind``
 * code 16: ``noredzone``
 * code 17: ``noreturn``
 * code 18: ``nounwind``
 * code 19: ``optsize``
 * code 20: ``readnone``

llvm/docs/LangRef.rst

 
 ``any``
     The linker may choose any COMDAT key, the choice is arbitrary.
 ``exactmatch``
     The linker may choose any COMDAT key but the sections must contain the
     same data.
 ``largest``
     The linker will choose the section containing the largest COMDAT key.
-``noduplicates``
-    The linker requires that only section with this COMDAT key exist.
+``nodeduplicate``
+    No deduplication is performed.
 ``samesize``
     The linker may choose any COMDAT key but the sections must contain the
     same amount of data.
 
 Note that XCOFF and the Mach-O platform don't support COMDATs, and ELF and
 WebAssembly only support ``any`` as a selection kind.
 
 Here is an example of a COMDAT group where a function will only be selected if

llvm/include/llvm-c/Comdat.h

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

llvm/include/llvm/AsmParser/LLToken.h

enum Kind {
   kw_opaque,
 
   kw_comdat,
 
   // Comdat types
   kw_any,
   kw_exactmatch,
   kw_largest,
-  kw_noduplicates,
+  kw_nodeduplicate,
   kw_samesize,
 
   kw_eq,
   kw_ne,
   kw_slt,
   kw_sgt,
   kw_sle,
   kw_sge,

llvm/include/llvm/IR/Comdat.h

 
 // 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
 // to a GlobalObject is that it is invalid to have two Comdats with the same
 // name but different SelectionKind. This structure makes that unrepresentable.
 class Comdat {
 public:
   enum SelectionKind {
-    Any,          ///< The linker may choose any COMDAT.
-    ExactMatch,   ///< The data referenced by the COMDAT must be the same.
-    Largest,      ///< The linker will choose the largest COMDAT.
-    NoDuplicates, ///< No other Module may specify this COMDAT.
-    SameSize,     ///< The data referenced by the COMDAT must be the same size.
+    Any,           ///< The linker may choose any COMDAT.
+    ExactMatch,    ///< The data referenced by the COMDAT must be the same.
+    Largest,       ///< The linker will choose the largest COMDAT.
+    NoDeduplicate, ///< No deduplication is performed.
+    SameSize,      ///< The data referenced by the COMDAT must be the same size.
   };
 
   Comdat(const Comdat &) = delete;
   Comdat(Comdat &&C);
 
   SelectionKind getSelectionKind() const { return SK; }
   void setSelectionKind(SelectionKind Val) { SK = Val; }
   StringRef getName() const;

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(opaque);
 
   KEYWORD(comdat);
 
   // Comdat types
   KEYWORD(any);
   KEYWORD(exactmatch);
   KEYWORD(largest);
-  KEYWORD(noduplicates);
+  KEYWORD(nodeduplicate);
   KEYWORD(samesize);
 
   KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
   KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
   KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
   KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
 
   KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);

llvm/lib/AsmParser/LLParser.cpp

case lltok::kw_any:
     SK = Comdat::Any;
     break;
   case lltok::kw_exactmatch:
     SK = Comdat::ExactMatch;
     break;
   case lltok::kw_largest:
     SK = Comdat::Largest;
     break;
-  case lltok::kw_noduplicates:
-    SK = Comdat::NoDuplicates;
+  case lltok::kw_nodeduplicate:
+    SK = Comdat::NoDeduplicate;
     break;
   case lltok::kw_samesize:
     SK = Comdat::SameSize;
     break;
   }
   Lex.Lex();
 
   // See if the comdat was forward referenced, if so, use the comdat.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {
   default: // Map unknown selection kinds to any.
   case bitc::COMDAT_SELECTION_KIND_ANY:
     return Comdat::Any;
   case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH:
     return Comdat::ExactMatch;
   case bitc::COMDAT_SELECTION_KIND_LARGEST:
     return Comdat::Largest;
   case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES:
-    return Comdat::NoDuplicates;
+    return Comdat::NoDeduplicate;
   case bitc::COMDAT_SELECTION_KIND_SAME_SIZE:
     return Comdat::SameSize;
   }
 }
 
 static FastMathFlags getDecodedFastMathFlags(unsigned Val) {
   FastMathFlags FMF;
   if (0 != (Val & bitc::UnsafeAlgebra))

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
   switch (C.getSelectionKind()) {
   case Comdat::Any:
     return bitc::COMDAT_SELECTION_KIND_ANY;
   case Comdat::ExactMatch:
     return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH;
   case Comdat::Largest:
     return bitc::COMDAT_SELECTION_KIND_LARGEST;
-  case Comdat::NoDuplicates:
+  case Comdat::NoDeduplicate:
     return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;
   case Comdat::SameSize:
     return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;
   }
   llvm_unreachable("Invalid selection kind");
 }
 
 static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) {

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

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

llvm/lib/IR/AsmWriter.cpp

case Comdat::Any:
     ROS << "any";
     break;
   case Comdat::ExactMatch:
     ROS << "exactmatch";
     break;
   case Comdat::Largest:
     ROS << "largest";
     break;
-  case Comdat::NoDuplicates:
-    ROS << "noduplicates";
+  case Comdat::NoDeduplicate:
+    ROS << "nodeduplicate";
     break;
   case Comdat::SameSize:
     ROS << "samesize";
     break;
   }
 
   ROS << '\n';
 }

llvm/lib/IR/Comdat.cpp

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

llvm/lib/Linker/LinkModules.cpp

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

llvm/lib/Transforms/IPO/Internalize.cpp

if (Comdat *C = GV.getComdat()) {
     // redirected. So ComdatMap may not contain C.
     if (ComdatMap.lookup(C).External)
       return false;
 
     if (auto *GO = dyn_cast<GlobalObject>(&GV)) {
       // 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
       // group of sections. Thus we have to keep the comdat but switch it to
-      // noduplicates.
-      // Note: noduplicates is not necessary for COFF. wasm doesn't support
-      // noduplicates.
+      // nodeduplicate.
+      // Note: nodeduplicate is not necessary for COFF. wasm doesn't support
+      // nodeduplicate.
       ComdatInfo &Info = ComdatMap.find(C)->second;
       if (Info.Size == 1)
         GO->setComdat(nullptr);
       else if (!IsWasm)
-        C->setSelectionKind(Comdat::NoDuplicates);
+        C->setSelectionKind(Comdat::NoDeduplicate);
     }
 
     if (GV.hasLocalLinkage())
       return false;
   } else {
     if (GV.hasLocalLinkage())
       return false;
 

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

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

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
   // sections.
   //
   // 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
   // duplicate symbol errors if there are multiple external symbols with the
   // same name marked IMAGE_COMDAT_SELECT_ASSOCIATIVE.
   //
   // 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
   // discarded.
   bool DataReferencedByCode = profDataReferencedByCode(*M);
   bool NeedComdat = needsComdatForCounter(*Fn, *M);
   std::string CntsVarName = getVarName(Inc, getInstrProfCountersVarPrefix());
   std::string DataVarName = getVarName(Inc, getInstrProfDataVarPrefix());
   auto MaybeSetComdat = [&](GlobalVariable *GV) {
     bool UseComdat = (NeedComdat || TT.isOSBinFormatELF());
     if (UseComdat) {
       StringRef GroupName = TT.isOSBinFormatCOFF() && DataReferencedByCode
                                 ? GV->getName()
                                 : CntsVarName;
       Comdat *C = M->getOrInsertComdat(GroupName);
       if (!NeedComdat)
-        C->setSelectionKind(Comdat::NoDuplicates);
+        C->setSelectionKind(Comdat::NoDeduplicate);
       GV->setComdat(C);
     }
   };
 
   uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
   LLVMContext &Ctx = M->getContext();
   ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
 

llvm/lib/Transforms/Instrumentation/Instrumentation.cpp

Comdat *llvm::getOrCreateFunctionComdat(Function &F, Triple &T) {
   assert(F.hasName());
   Module *M = F.getParent();
 
   // 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
   // symbols.
   Comdat *C = M->getOrInsertComdat(F.getName());
   if (T.isOSBinFormatELF() || (T.isOSBinFormatCOFF() && !F.isWeakForLinker()))
-    C->setSelectionKind(Comdat::NoDuplicates);
+    C->setSelectionKind(Comdat::NoDeduplicate);
   F.setComdat(C);
   return C;
 }
 
 /// initializeInstrumentation - Initialize all passes in the TransformUtils
 /// library.
 void llvm::initializeInstrumentation(PassRegistry &Registry) {
   initializeAddressSanitizerLegacyPassPass(Registry);

llvm/test/Bitcode/compatibility-3.6.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ; Global Variables -- comdat
 @comdat.any = global i32 0, comdat
 ; CHECK: @comdat.any = global i32 0, comdat
 @comdat.exactmatch = global i32 0, comdat
 ; CHECK: @comdat.exactmatch = global i32 0, comdat

llvm/test/Bitcode/compatibility-3.7.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ;; Constants
 @const.true = constant i1 true
 ; CHECK: @const.true = constant i1 true
 @const.false = constant i1 false
 ; CHECK: @const.false = constant i1 false

llvm/test/Bitcode/compatibility-3.8.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ;; Constants
 @const.true = constant i1 true
 ; CHECK: @const.true = constant i1 true
 @const.false = constant i1 false
 ; CHECK: @const.false = constant i1 false

llvm/test/Bitcode/compatibility-3.9.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ;; Constants
 @const.true = constant i1 true
 ; CHECK: @const.true = constant i1 true
 @const.false = constant i1 false
 ; CHECK: @const.false = constant i1 false

llvm/test/Bitcode/compatibility-4.0.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ;; Constants
 @const.true = constant i1 true
 ; CHECK: @const.true = constant i1 true
 @const.false = constant i1 false
 ; CHECK: @const.false = constant i1 false

llvm/test/Bitcode/compatibility-5.0.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ;; Constants
 @const.true = constant i1 true
 ; CHECK: @const.true = constant i1 true
 @const.false = constant i1 false
 ; CHECK: @const.false = constant i1 false

llvm/test/Bitcode/compatibility-6.0.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ;; Constants
 @const.true = constant i1 true
 ; CHECK: @const.true = constant i1 true
 @const.false = constant i1 false
 ; CHECK: @const.false = constant i1 false

llvm/test/Bitcode/compatibility.ll

 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch
 ; CHECK: $comdat.exactmatch = comdat exactmatch
 $comdat.largest = comdat largest
 ; CHECK: $comdat.largest = comdat largest
-$comdat.noduplicates = comdat noduplicates
-; CHECK: $comdat.noduplicates = comdat noduplicates
+$comdat.noduplicates = comdat nodeduplicate
+; CHECK: $comdat.noduplicates = comdat nodeduplicate
 $comdat.samesize = comdat samesize
 ; CHECK: $comdat.samesize = comdat samesize
 
 ;; Constants
 @const.true = constant i1 true
 ; CHECK: @const.true = constant i1 true
 @const.false = constant i1 false
 ; CHECK: @const.false = constant i1 false

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

 }
 
 $f3 = comdat largest
 @v3 = global i32 0, comdat($f3)
 define void @f3() comdat($f3) {
   ret void
 }
 
-$f4 = comdat noduplicates
+$f4 = comdat nodeduplicate
 @v4 = global i32 0, comdat($f4)
 define void @f4() comdat($f4) {
   ret void
 }
 
 $f5 = comdat samesize
 @v5 = global i32 0, comdat($f5)
 define void @f5() comdat($f5) {

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.
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux | FileCheck %s
 
 ; CHECK: .section .text.f1,"axG",@progbits,f1{{$}}
 ; CHECK: .section .text.f2,"axG",@progbits,f1{{$}}
 ; CHECK: .section .bss.g1,"aGw",@nobits,f1{{$}}
 
-$f1 = comdat noduplicates
+$f1 = comdat nodeduplicate
 
 define void @f1() comdat {
   unreachable
 }
 
 define hidden void @f2() comdat($f1) {
   unreachable
 }
 
 @g1 = global i32 0, comdat($f1)

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

lpad:
   %0 = landingpad { i8*, i32 } catch i8* bitcast (i8** @_ZTIi to i8*)
   br label %eh.resume
 try.cont:
   ret i32 0
 eh.resume:
   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.
-$zero = comdat noduplicates
+$zero = comdat nodeduplicate
 define i32 @zero() uwtable comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL:       zero:
 ; CHECK:             .cfi_endproc
 ; NORMAL-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_NOUNIQUE-NEXT: .section .gcc_except_table,"aG",@progbits,zero{{$}}
 ; NOUNIQUE-NEXT:     .section .gcc_except_table,"aG",@progbits,zero{{$}}

llvm/test/Instrumentation/AddressSanitizer/global_metadata_windows.ll

 ; 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
 ; linker dead stripping (/OPT:REF) works as intended.
 
 ; 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 -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 triple = "x86_64-pc-windows-msvc19.0.24215"
 
 $mystr = comdat any
 
-; CHECK: $dead_global = comdat noduplicates
-; CHECK: $private_str = comdat noduplicates
+; CHECK: $dead_global = comdat nodeduplicate
+; CHECK: $private_str = comdat nodeduplicate
 
 ; 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: @__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: @llvm.compiler.used {{.*}} @__asan_global_dead_global {{.*}} @__asan_global_private_str {{.*}} section "llvm.metadata"

llvm/test/Instrumentation/InstrProfiling/linkage.ll

 ;; 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-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-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-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-pc-win32-coff -passes=instrprof -S | FileCheck %s --check-prefixes=COFF
 
 ; MACHO: @__llvm_profile_runtime = external global i32
 ; ELF-NOT: @__llvm_profile_runtime = external global i32
 
-; ELF: $__profc_foo = comdat noduplicates
-; ELF: $__profc_foo_weak = comdat noduplicates
-; ELF: $"__profc_linkage.ll:foo_internal" = comdat noduplicates
-; ELF: $__profc_foo_inline = comdat noduplicates
+; ELF: $__profc_foo = comdat nodeduplicate
+; ELF: $__profc_foo_weak = comdat nodeduplicate
+; ELF: $"__profc_linkage.ll:foo_internal" = comdat nodeduplicate
+; ELF: $__profc_foo_inline = comdat nodeduplicate
 ; ELF: $__profc_foo_extern = comdat any
 
 @__profn_foo = private constant [3 x i8] c"foo"
 @__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_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"
 

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

 ; int foo(int x) {
 ;   if (baz(0))
 ;     x = bar(x);
 ;   return x;
 ; }
 
 ; Both new comdats should no duplicates on COFF.
 
-; CHECK: $foo = comdat noduplicates
-; CHECK: $bar = comdat noduplicates
+; CHECK: $foo = comdat nodeduplicate
+; CHECK: $bar = comdat nodeduplicate
 
 ; 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 constant [2 x 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

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

 ; 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 -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:      @__start___sancov_bools = extern_weak hidden global i1
 ; CHECK-NEXT: @__stop___sancov_bools = extern_weak hidden global i1
 ; 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"
 
 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"

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

entry:
   ret void
 }
 
 define weak_odr void @WeakOdr() {
 entry:
   ret void
 }
 
-; CHECK:      $Vanilla = comdat noduplicates
-; ELF:        $LinkOnceOdr = comdat noduplicates
+; CHECK:      $Vanilla = comdat nodeduplicate
+; ELF:        $LinkOnceOdr = comdat nodeduplicate
 ; COFF:       $LinkOnceOdr = comdat any
 ; 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_.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_.4 = private global [1 x i32] zeroinitializer, section {{.*}}, comdat($WeakOdr), align 4{{$}}
 
 ; CHECK: define void @Vanilla() comdat {
 ; ELF:   define linkonce void @LinkOnce() comdat {
 ; ELF:   define weak void @Weak() comdat {
 ; COFF:  define linkonce void @LinkOnce() {
 ; COFF:  define weak void @Weak() {
 ; CHECK: declare extern_weak void @ExternWeak()
 ; CHECK: define linkonce_odr void @LinkOnceOdr() 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 -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 -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
 
-; COMDAT:     $foo = comdat noduplicates
-; COMDAT:     $CallViaVptr = comdat noduplicates
+; COMDAT:     $foo = comdat nodeduplicate
+; COMDAT:     $CallViaVptr = comdat nodeduplicate
 
 ; 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{{$}}
 
 ; 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{{$}}
 
 ; WIN:        @__sancov_gen_ = private global [3 x i32] zeroinitializer, section ".SCOV$GM", comdat($foo), align 4{{$}}

llvm/test/Linker/Inputs/comdat3.ll

-$foo = comdat noduplicates
+$foo = comdat nodeduplicate
 @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
 
-$foo = comdat noduplicates
+$foo = comdat nodeduplicate
 @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

 define dllexport void @source_comdat_function_1() comdat($source_comdat_function_1) {
 entry:
   ret void
 }
 
 $source_comdat_variable = comdat largest
 @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)
 
 ; CHECK: $target_comdat_function = comdat any
 ; CHECK: $target_comdat_function_1 = comdat exactmatch
 ; 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-NOT: @source_variable = external global i32
 ; CHECK: @target_pattern_variable = external global i32
 ; CHECK-NOT: @source_pattern_variable = external global i32
 ; CHECK: @target_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

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:   -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:   -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:   -internalize-public-api-list c3 -internalize-public-api-list c4 -S | FileCheck %s --check-prefixes=CHECK,WASM
 
 $c1 = comdat any
 $c2 = comdat any
 $c3 = comdat any
 $c4 = comdat any
 $c5 = comdat any
 
 ; CHECK: $c1 = comdat any
 
-;; wasm doesn't support noduplicates.
-; NODUP: $c2 = comdat noduplicates
+;; wasm doesn't support nodeduplicate.
+; NODUP: $c2 = comdat nodeduplicate
 ; WASM:  $c2 = comdat any
 
 ; CHECK: $c3 = comdat any
 ; CHECK: $c4 = comdat any
 
 ; CHECK: @c1_c = global i32 0, comdat($c1)
 @c1_c = global i32 0, comdat($c1)