IR: Add COMDATs to the IR

[majnemer]

Summary

This new IR facility allows us to represent the object-file semantic of
a COMDAT group.

COMDATs allow us to tie together sections and make the inclusion of one
dependent on another. This is required to implement features like MS
ABI VFTables and optimizing away certain kinds of initialization in C++.

This functionality is only representable in COFF and ELF, Mach-O has no
similar mechanism.

[• rafael]

This patch doesn't update lib/Linker. This means that LTO can miscompiple this, no? In particular, I think it will be wrong given something like

$foo = comdat any
@a = weak global i32, 0, comdat $foo
@b = private global i32 0, comdat $foo

in two files. It will keep only one @a, but will duplicate @b create a comdat with an extra element.

Updating lib/Linker should be fairly simple for 'any'. It should just avoid linking any a symbol if it is in a comdat that is already present in the destination. It is not clear what it should do for other selection kind or mismatched selection kinds (error?)

docs/LangRef.rst

664

The repeated "if the target has the necessary supports" is a bit redundant. Just talk about the target differences in the comdat section.

685

How do alias fit in this design?

We should probably not allow alias to cross comdats, so how about adding something like:

Aliases are placed on the same comdat as the aliassee expression computes to.

Somewhat related: The llvm codegen will currently create comdats on its own. For example, a simple weak global gets output on a comdat. Do you intend to change that? In any case, it is probably a good thing to document.

758

We only have 3 file formats. It is probably OK to say that ELF only supports 'any' :-)

771

An important difference between COFF and ELF is that in COFF only one section can be in a COMDAT. In ELF, multiple sections can be in the same comdat.

I noticed that you left associative out of the above list. Is the intention to write code that look like ELF (multiple sections in on COMDAT) but at codegen we pick one to actually be in that comdat and make others associative with it?

It is probably a good idea to mention this, since the documentation gives the impression that adding COMDAT to a global makes sure that it will be in that COMDAT.

What are we doing about linkage? For COMDATs to work, we have to make sure their contents are not modified. For example, if a COMDAT has two linkonce_odr symbols, dropping only one can cause a llink failure.

One way would be to say that isDiscardableIfUnused symbols are not allowed, but we do want to allow private. Going this way would require spiting the "can be dropped" notion out of linkage. For example, linkonce would become "weak dropable" and a plain private would have to be kept. We do want to allow entire COMDATs to be dropped, so the comdat itself would probably need the dropable bit too.

A simpler but potentially brittle option is to just say that

• A symbol in a comdat cannot be dropped individually
• A comdat can be dropped if every symbol in it can be dropped.

And audit pretty much every call to isDiscardableIfUnused.

include/llvm/IR/Comdat.h

32

Why do you need it to be a Value? This says that a Comdat has a type, which seems wrong.

46

section?

51

What is this needed for?

include/llvm/IR/Module.h

599

Is this need? I looks a bit strange say that comdat is "part of a module". They are really a composite property of the globals.

lib/AsmParser/LLParser.cpp

539

Does clang-format agrees with having the break in the same line?

1161

Don't repeat the name in the comment. Functions start with a lowecase letter.

lib/IR/AsmWriter.cpp

1315

This keeps unused comdats. It is probably better to keep track of which comdats are needed and output only those. This is similar to how an unused type is dropped.

lib/IR/Globals.cpp

115

Why not reject instead? This probably indicates a bug in the calling code, no?

[majnemer]

docs/LangRef.rst

664

OK, will do.

758

Sure.

771

Consider:

$v = comdat any
@v = global i32 0, comdat $v
@m = global i32 0, comdat $v

In the ELF case, @v will be selected as the COMDAT key. The .data.v and .data.m sections will both be in the COMDAT group.

In the COFF case, @v's .data section will be the primary COMDAT section. @m's .data section will be associated with it.

Because we have this behavior, we do not need an explicit associative COMDAT selection kind.

I'll work on fixing the discard problem.

include/llvm/IR/Comdat.h

32

It is a Value so that it can participate in things like use lists.

As an example why this is useful:
If we want to drop a symbol in a COMDAT group, we need to prove we don't need any of the symbols in that group. Iterating over users of the COMDAT is a straightforward way of doing this.

I could recreate this functionality just for COMDATs but it seemed like the right way to go.

51

There are places, like ConvertValIDToValue, where we get a Comdat from a Value.

include/llvm/IR/Module.h

599

A Comdat value has to live in *some* symbol table. Considering the tight relationship between Comdat value names and GlobalValue names, it makes sense for the symbol table to be at Module scope.

lib/AsmParser/LLParser.cpp

539

I matched the style in ParseFnAttributeValuePairs, I can reformat this to be in clang-format style if you wish.

1161

I'll switch to \brief.

With regard to the naming style, I followed the Golden Rule

lib/IR/AsmWriter.cpp

1315

Sure, I can check to see if the Comdat has an empty use list.

lib/IR/Globals.cpp

115

It's annoying to avoid this from the AsmParser. I'll add a verifier check.

[• rafael]

An important difference between COFF and ELF is that in COFF only one section can be in a COMDAT. In ELF, multiple sections can be in the same comdat.

I noticed that you left associative out of the above list. Is the intention to write code that look like ELF (multiple sections in on COMDAT) but at codegen we pick one to actually be in that comdat and make others associative with it?

It is probably a good idea to mention this, since the documentation gives the impression that adding COMDAT to a global makes sure that it will be in that COMDAT.

What are we doing about linkage? For COMDATs to work, we have to make sure their contents are not modified. For example, if a COMDAT has two linkonce_odr symbols, dropping only one can cause a llink failure.

One way would be to say that isDiscardableIfUnused symbols are not allowed, but we do want to allow private. Going this way would require spiting the "can be dropped" notion out of linkage. For example, linkonce would become "weak dropable" and a plain private would have to be kept. We do want to allow entire COMDATs to be dropped, so the comdat itself would probably need the dropable bit too.

A simpler but potentially brittle option is to just say that

• A symbol in a comdat cannot be dropped individually
• A comdat can be dropped if every symbol in it can be dropped.

And audit pretty much every call to isDiscardableIfUnused.

Consider:

$v = comdat any
@v = global i32 0, comdat $v
@m = global i32 0, comdat $v

In the ELF case, @v will be selected as the COMDAT key. The .data.v and .data.m sections will both be in the COMDAT group.

In the COFF case, @v's .data section will be the primary COMDAT section. @m's .data section will be associated with it.

Because we have this behavior, we do not need an explicit associative COMDAT selection kind.

This in nice. It is probably a good idea to document it.

---

Rafael Ávila de Espíndola wrote:

Why do you need it to be a Value? This says that a Comdat has a type, which seems wrong.

It is a Value so that it can participate in things like use lists.

As an example why this is useful:
If we want to drop a symbol in a COMDAT group, we need to prove we don't need any of the symbols in that group. Iterating over users of the COMDAT is a straightforward way of doing this.

I could recreate this functionality just for COMDATs but it seemed like the right way to go.

We had problems in the past with a Class being too generic
(GlobalAlias being the most recent one), so I would suggest making it
specific.All you need to is add a "Use*" to the comdat class, no?

Comment at: include/llvm/IR/Comdat.h:51
@@ +50,3 @@
+ /// Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool classof(const Value *V) {

+ return V->getValueID() == Value::ComdatVal;

Rafael Ávila de Espíndola wrote:

What is this needed for?

There are places, like ConvertValIDToValue, where we get a Comdat from a Value.

Well, that seems like a problem to cover another. It shouldn't be
parsed as a Value :-(

Comment at: include/llvm/IR/Module.h:599
@@ +598,3 @@
+ comdat_iterator comdat_begin() { return ComdatList.begin(); }
+ const_comdat_iterator comdat_begin() const { return ComdatList.begin(); }

+ comdat_iterator comdat_end () { return ComdatList.end(); }

Rafael Ávila de Espíndola wrote:

Is this need? I looks a bit strange say that comdat is "part of a module". They are really a composite property of the globals.

A Comdat value has to live in *some* symbol table. Considering the tight relationship between Comdat value names and GlobalValue names, it makes sense for the symbol table to be at Module scope.

Sure. It just feels a bit more like constants or types. They have to
live somewhere, but it is more of an implementation detail where they
live. Conceptually a module has GlobalValues, triple, datalayout and
information associated with the GlobalValues (metadata, comdat,
types).

Comment at: lib/AsmParser/LLParser.cpp:539
@@ +538,3 @@
+ case lltok::kw_exactmatch: SK = Comdat::ExactMatch; break;
+ case lltok::kw_largest: SK = Comdat::Largest; break;

+ case lltok::kw_newest: SK = Comdat::Newest; break;

Rafael Ávila de Espíndola wrote:

Does clang-format agrees with having the break in the same line?

I matched the style in ParseFnAttributeValuePairs, I can reformat this to be in clang-format style if you wish.

clang-format please :-)

Comment at: lib/AsmParser/LLParser.cpp:1161
@@ +1160,3 @@
+
+/// GetComdatVal - Get a Comdat with the specified name, creating a forward

+/// reference record if needed.

Rafael Ávila de Espíndola wrote:

Don't repeat the name in the comment. Functions start with a lowecase letter.

I'll switch to \brief.

With regard to the naming style, I followed the Golden Rule

The annoying thing is that parts of the code base end up never being
fixed. What about fixing the old code in a preparation commit?

Comment at: lib/IR/Globals.cpp:115
@@ +114,3 @@
+ if (isa<GlobalVariable>(this) || isa<GlobalAlias>(this)) {
+ // Comdats on declarations are semantically meaningless, ignore them.

+ if (isDeclaration())

Rafael Ávila de Espíndola wrote:

Why not reject instead? This probably indicates a bug in the calling code, no?

It's annoying to avoid this from the AsmParser. I'll add a verifier check.

You probably need both. We want the verifier to be sure someone using
the c++ api gets notified of the error. You need a parser check to
make sure llvm-as can provide a better error message.

Cheers,
Rafael

[• rafael]

Rafael Ávila de Espíndola wrote:

Why do you need it to be a Value? This says that a Comdat has a type, which seems wrong.

It is a Value so that it can participate in things like use lists.

As an example why this is useful:
If we want to drop a symbol in a COMDAT group, we need to prove we don't need any of the symbols in that group. Iterating over users of the COMDAT is a straightforward way of doing this.

I could recreate this functionality just for COMDATs but it seemed like the right way to go.

We had problems in the past with a Class being too generic
(GlobalAlias being the most recent one), so I would suggest making it
specific.All you need to is add a "Use*" to the comdat class, no?

Now that I think of it, a comdat having Uses is probably undesirable
in itself. Some of the potential issues that come to mind:

• RAUW should not change what is in a comdat.
• Logic for checking if something has only one use should also not be

affected by comdats.

• Other code walking all uses probably be surprised to find a comdat.

It looks comdats should keep track of what GVs are in them with some
other mechanism. The simple option of just building this information
when needed might be sufficient. I think the only cases where we would
need it is

• Some optimization to drop unused comdats if all their members can be dropped.
• The linker.

Both of these will be looking at the entire module, so they should be
able to build the set of global values in each comdat as needed.

Cheers,
Rafael

[majnemer]

This was superseded by D4178 which landed as rL211920.

docs/LangRef.rst

 A global variable may be declared to reside in a target-specific
 numbered address space. For targets that support them, address spaces
 may affect how optimizations are performed and/or what target
 instructions are used to access the variable. The default address space
 is zero. The address space qualifier must precede any other attributes.
 
 LLVM allows an explicit section to be specified for globals. If the
 target supports it, it will emit globals to the section specified.
+Additionally, the global can placed in a comdat if the target has the necessary
+support.
 
 By default, global initializers are optimized by assuming that global
 variables defined within the module are not modified from their
 initial values before the start of the global initializer.  This is
 true even for variables potentially accessible from outside the
 module, including those with external linkage or appearing in
 ``@llvm.used`` or dllexported variables. This assumption may be suppressed
 by marking the variable with ``externally_initialized``.

 Variables and aliasaes can have a
 :ref:`Thread Local Storage Model <tls_model>`.
 
 Syntax::
 
     [@<GlobalVarName> =] [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
                          [unnamed_addr] [AddrSpace] [ExternallyInitialized]
                          <global | constant> <Type>
-                         [, section "name"] [, align <Alignment>]
+                         [, section "name"] [, comdat $<ComdatName>]
+                         [, align <Alignment>]
 
 For example, the following defines a global in a numbered address space
 with an initializer, section, and alignment:
 
 .. code-block:: llvm
 
     @G = addrspace(5) constant float 1.0, section "foo", align 4
 

 LLVM function definitions consist of the "``define``" keyword, an
 optional :ref:`linkage type <linkage>`, an optional :ref:`visibility
 style <visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`,
 an optional :ref:`calling convention <callingconv>`,
 an optional ``unnamed_addr`` attribute, a return type, an optional
 :ref:`parameter attribute <paramattrs>` for the return type, a function
 name, a (possibly empty) argument list (each with optional :ref:`parameter
 attributes <paramattrs>`), optional :ref:`function attributes <fnattrs>`,
-an optional section, an optional alignment, an optional :ref:`garbage
-collector name <gc>`, an optional :ref:`prefix <prefixdata>`, an opening
+an optional section, an optional alignment,
+an optional :ref:`comdat <langref_comdats>`,
+an optional :ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`, an opening
 curly brace, a list of basic blocks, and a closing curly brace.
 
 LLVM function declarations consist of the "``declare``" keyword, an
 optional :ref:`linkage type <linkage>`, an optional :ref:`visibility
 style <visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`,
 an optional :ref:`calling convention <callingconv>`,
 an optional ``unnamed_addr`` attribute, a return type, an optional
 :ref:`parameter attribute <paramattrs>` for the return type, a function

 The first basic block in a function is special in two ways: it is
 immediately executed on entrance to the function, and it is not allowed
 to have predecessor basic blocks (i.e. there can not be any branches to
 the entry block of a function). Because the block can have no
 predecessors, it also cannot have any :ref:`PHI nodes <i_phi>`.
 
 LLVM allows an explicit section to be specified for functions. If the
 target supports it, it will emit functions to the section specified.
+Additionally, the function can placed in a comdat if the target has the
+necessary support.
 
 An explicit alignment may be specified for a function. If not present,
 or if the alignment is set to zero, the alignment of the function is set
 by the target to whatever it feels convenient. If an explicit alignment
 is specified, the function is forced to have at least that much
 alignment. All alignments must be a power of 2.
 
 If the ``unnamed_addr`` attribute is given, the address is know to not
 be significant and two identical functions can be merged.
 
 Syntax::
 
     define [linkage] [visibility] [DLLStorageClass]
            [cconv] [ret attrs]
            <ResultType> @<FunctionName> ([argument list])
-           [unnamed_addr] [fn Attrs] [section "name"] [align N]
-           [gc] [prefix Constant] { ... }
+           [unnamed_addr] [fn Attrs] [section "name"] [comdat $<ComdatName>]
+           [align N] [gc] [prefix Constant] { ... }
 
 .. _langref_aliases:
 
 Aliases
 -------
 
 Aliases, unlike function or variables, don't create any new data. They
 are just a new symbol and metadata for an existing position.
 
 Aliases have a name and an aliasee that is either a global value or a
 constant expression.
 

 
 * No alias in the expression can be weak as the possibility of the
   intermediate alias being overridden cannot be represented in an
   object file.
 
 * No global value in the expression can be a declaration, since that
   would require a relocation, which is not possible.
 
+.. _langref_comdats:
+
+Comdats
+-------
+
+Comdat IR provides access to COFF and ELF object file COMDAT functionality.
+
+Comdats have a name which represents the COMDAT key.  All global objects which
+specify this key will only end up in the final object file if the linker chooses that key over some other key.
+
+Comdats provide a selection kind to provide input on how the linker should
+choose between keys in two different object files.
+
+Syntax::
+
+    $<Name> = comdat SelectionKind
+
+The selection kind must be one of the following:
+
+``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.
+``newest``
+    The linker will choose the section containing the newest COMDAT key.
+``noduplicates``
+    The linker requires that only section with this COMDAT key exist.
+``samesize``
+    The linker may choose any COMDAT key but the sections must contain the
+    same amount of data.
+
+Note that not all targets support COMDATs and some may only support ``any`` as a
+selection kind.
+
+Here is an example of a COMDAT group where a function will only be selected if
+the COMDAT key's section is the largest:
+
+.. code-block:: llvm
+
+   $foo = comdat largest
+   @foo = global i32 2, comdat $foo
+
+   define void @bar() comdat $foo {
+     ret void
+   }
+
 .. _namedmetadatastructure:
 
 Named Metadata
 --------------
 
 Named metadata is a collection of metadata. :ref:`Metadata
 nodes <metadata>` (but not metadata strings) are the only valid
 operands for a named metadata.

include/llvm-c/Core.h

typedef enum {
   LLVMLabelTypeKind,       /**< Labels */
   LLVMIntegerTypeKind,     /**< Arbitrary bit width integers */
   LLVMFunctionTypeKind,    /**< Functions */
   LLVMStructTypeKind,      /**< Structures */
   LLVMArrayTypeKind,       /**< Arrays */
   LLVMPointerTypeKind,     /**< Pointers */
   LLVMVectorTypeKind,      /**< SIMD 'packed' format, or other vector type */
   LLVMMetadataTypeKind,    /**< Metadata */
-  LLVMX86_MMXTypeKind      /**< X86 MMX */
+  LLVMX86_MMXTypeKind,     /**< X86 MMX */
+  LLVMComdatTypeKind,      /**< COMDATs */
 } LLVMTypeKind;
 
 typedef enum {
   LLVMExternalLinkage,    /**< Externally visible function */
   LLVMAvailableExternallyLinkage,
   LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
   LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
                             equivalent. */

  */
 
 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
 LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
 const char *LLVMGetSection(LLVMValueRef Global);
 void LLVMSetSection(LLVMValueRef Global, const char *Section);
+LLVMValueRef LLVMGetComdat(LLVMValueRef Global);
+void LLVMSetComdat(LLVMValueRef Global, LLVMValueRef ComdatRef);
 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
 LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global);
 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class);
 LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global);
 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr);
 
 /**

include/llvm/Bitcode/LLVMBitCodes.h

enum ModuleCodes {
     MODULE_CODE_FUNCTION    = 8,
 
     // ALIAS: [alias type, aliasee val#, linkage, visibility]
     MODULE_CODE_ALIAS       = 9,
 
     // MODULE_CODE_PURGEVALS: [numvals]
     MODULE_CODE_PURGEVALS   = 10,
 
-    MODULE_CODE_GCNAME      = 11   // GCNAME: [strchr x N]
+    MODULE_CODE_GCNAME      = 11,  // GCNAME: [strchr x N]
+    MODULE_CODE_COMDAT      = 12   // COMDAT: [selection_kind, name]
   };
 
   /// PARAMATTR blocks have code for defining a parameter attribute set.
   enum AttributeCodes {
     // FIXME: Remove `PARAMATTR_CODE_ENTRY_OLD' in 4.0
     PARAMATTR_CODE_ENTRY_OLD  = 1, // ENTRY: [paramidx0, attr0,
                                    //         paramidx1, attr1...]
     PARAMATTR_CODE_ENTRY      = 2, // ENTRY: [paramidx0, attrgrp0,
enum TypeCodes {
     TYPE_CODE_METADATA = 16,    // METADATA
 
     TYPE_CODE_X86_MMX = 17,     // X86 MMX
 
     TYPE_CODE_STRUCT_ANON = 18, // STRUCT_ANON: [ispacked, eltty x N]
     TYPE_CODE_STRUCT_NAME = 19, // STRUCT_NAME: [strchr x N]
     TYPE_CODE_STRUCT_NAMED = 20,// STRUCT_NAMED: [ispacked, eltty x N]
 
-    TYPE_CODE_FUNCTION = 21     // FUNCTION: [vararg, retty, paramty x N]
+    TYPE_CODE_FUNCTION = 21,    // FUNCTION: [vararg, retty, paramty x N]
+    TYPE_CODE_COMDAT = 22,      // COMDAT: [selection_kind, name]
   };
 
   // The type symbol table only has one code (TST_ENTRY_CODE).
   enum TypeSymtabCodes {
     TST_CODE_ENTRY = 1     // TST_ENTRY: [typeid, namechar x N]
   };
 
   // The value symbol table only has one code (VST_ENTRY_CODE).
enum AttributeKindCodes {
     ATTR_KIND_BUILTIN = 35,
     ATTR_KIND_COLD = 36,
     ATTR_KIND_OPTIMIZE_NONE = 37,
     ATTR_KIND_IN_ALLOCA = 38,
     ATTR_KIND_NON_NULL = 39,
     ATTR_KIND_JUMP_TABLE = 40
   };
 
+  enum ComdatSelectionKindCodes {
+    COMDAT_SELECTION_KIND_ANY = 1,
+    COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
+    COMDAT_SELECTION_KIND_LARGEST = 3,
+    COMDAT_SELECTION_KIND_NEWEST = 4,
+    COMDAT_SELECTION_KIND_NO_DUPLICATES = 5,
+    COMDAT_SELECTION_KIND_SAME_SIZE = 6,
+  };
+
 } // End bitc namespace
 } // End llvm namespace
 
 #endif

include/llvm/IR/Comdat.h

+//===-- llvm/IR/Comdat.h - Comdat definitions -------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// @file
+/// This file contains the declaration of the Comdat class, which represents a
+/// single COMDAT in LLVM.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_COMDAT_H
+#define LLVM_IR_COMDAT_H
+
+#include "llvm/ADT/ilist_node.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/ADT/VariadicFunction.h"
+#include "llvm/IR/LeakDetector.h"
+#include "llvm/IR/Value.h"
+
+namespace llvm {
+class LLVMContext;
+class Module;
+template <typename ValueSubClass, typename ItemParentClass>
+class SymbolTableListTraits;
+class Twine;
+
+class Comdat : public Value, public ilist_node<Comdat> {
+public:
+  enum SelectionKind : uint8_t {
+    Any,
+    ExactMatch,
+    Largest,
+    Newest,
+    NoDuplicates,
+    SameSize,
+  };
+
+  /// \brief Destroy Comdat.
+  ~Comdat();
+
+  /// \brief Get the module that holds this section.
+  Module *getParent() { return Parent; }
+  const Module *getParent() const { return Parent; }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const Value *V) {
+    return V->getValueID() == Value::ComdatVal;
+  }
+
+  Comdat(SelectionKind SK, const Twine &Name, Comdat *InsertBefore);
+  Comdat(SelectionKind SK, const Twine &Name, Module *M);
+
+  SelectionKind getSelectionKind() const { return SK; }
+  void setSelectionKind(SelectionKind NewSK) { SK = NewSK; }
+
+private:
+  friend class SymbolTableListTraits<Comdat, Module>;
+  Comdat(const Comdat &) LLVM_DELETED_FUNCTION;
+
+  void setParent(Module *M) {
+    if (getParent())
+      LeakDetector::addGarbageObject(this);
+    Parent = M;
+    if (getParent())
+      LeakDetector::removeGarbageObject(this);
+  }
+
+  // Shadow Value::setValueSubclassData with a private forwarding method so that
+  // subclasses cannot accidentally use it.
+  void setValueSubclassData(unsigned short D) {
+    Value::setValueSubclassData(D);
+  }
+
+  Module *Parent;
+  SelectionKind SK;
+};
+} // end llvm namespace
+
+#endif

include/llvm/IR/Function.h

 #ifndef LLVM_IR_FUNCTION_H
 #define LLVM_IR_FUNCTION_H
 
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallingConv.h"
+#include "llvm/IR/Comdat.h"
 #include "llvm/IR/GlobalObject.h"
+#include "llvm/IR/OperandTraits.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 class FunctionType;
 class LLVMContext;
 
 // Traits for intrusive list of basic blocks...
private:
   /// Function ctor - If the (optional) Module argument is specified, the
   /// function is automatically inserted into the end of the function list for
   /// the module.
   ///
   Function(FunctionType *Ty, LinkageTypes Linkage,
            const Twine &N = "", Module *M = nullptr);
 
 public:
+  // allocate space for one operand
+  void *operator new(size_t s) {
+    return User::operator new(s, 1);
+  }
+
   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
                           const Twine &N = "", Module *M = nullptr) {
-    return new(0) Function(Ty, Linkage, N, M);
+    return new Function(Ty, Linkage, N, M);
   }
 
   ~Function();
 
+  /// Provide fast operand accessors
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Comdat);
+
   Type *getReturnType() const;           // Return the type of the ret val
   FunctionType *getFunctionType() const; // Return the FunctionType for me
 
   /// getContext - Return a pointer to the LLVMContext associated with this
   /// function, or NULL if this function is not bound to a context yet.
   LLVMContext &getContext() const;
 
   /// isVarArg - Return true if this function takes a variable number of
ilist_traits<BasicBlock>::getSymTab(Function *F) {
   return F ? &F->getValueSymbolTable() : nullptr;
 }
 
 inline ValueSymbolTable *
 ilist_traits<Argument>::getSymTab(Function *F) {
   return F ? &F->getValueSymbolTable() : nullptr;
 }
 
+template <>
+struct OperandTraits<Function> : public OptionalOperandTraits<Function> {};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Comdat)
+
 } // End llvm namespace
 
 #endif

include/llvm/IR/GlobalAlias.h

class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
   GlobalAlias(const GlobalAlias &) LLVM_DELETED_FUNCTION;
 
   void setParent(Module *parent);
 
   GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
               const Twine &Name, Constant *Aliasee, Module *Parent);
 
 public:
-  // allocate space for exactly one operand
+  // allocate space for exactly two operands
   void *operator new(size_t s) {
-    return User::operator new(s, 1);
+    return User::operator new(s, 2);
+  }
+
+  ~GlobalAlias() {
+    NumOperands = 2; // FIXME: needed by operator delete
   }
 
   /// If a parent module is specified, the alias is automatically inserted into
   /// the end of the specified module's alias list.
   static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
                              LinkageTypes Linkage, const Twine &Name,
                              Constant *Aliasee, Module *Parent);
 
public:
   // Type, Parent and AddressSpace taken from the Aliasee.
   static GlobalAlias *create(LinkageTypes Linkage, const Twine &Name,
                              GlobalValue *Aliasee);
 
   // Linkage, Type, Parent and AddressSpace taken from the Aliasee.
   static GlobalAlias *create(const Twine &Name, GlobalValue *Aliasee);
 
   /// Provide fast operand accessors
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// removeFromParent - This method unlinks 'this' from the containing module,
   /// but does not delete it.
   ///
   void removeFromParent() override;
 
   /// eraseFromParent - This method unlinks 'this' from the containing module
   /// and deletes it.
   ///
   void eraseFromParent() override;
 
   /// These methods retrive and set alias target.
   void setAliasee(Constant *Aliasee);
   const Constant *getAliasee() const {
     return const_cast<GlobalAlias *>(this)->getAliasee();
   }
   Constant *getAliasee() {
-    return getOperand(0);
+    return cast<Constant>(getOperand(0));
   }
 
   static bool isValidLinkage(LinkageTypes L) {
     return isExternalLinkage(L) || isLocalLinkage(L) ||
       isWeakLinkage(L) || isLinkOnceLinkage(L);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalAliasVal;
   }
 };
 
 template <>
 struct OperandTraits<GlobalAlias> :
-  public FixedNumOperandTraits<GlobalAlias, 1> {
+  public OptionalOperandTraits<GlobalAlias, 2> {
 };
 
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Value)
 
 } // End llvm namespace
 
 #endif

include/llvm/IR/GlobalValue.h

 #ifndef LLVM_IR_GLOBALVALUE_H
 #define LLVM_IR_GLOBALVALUE_H
 
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 
 namespace llvm {
 
+class Comdat;
 class PointerType;
 class Module;
 
 class GlobalValue : public Constant {
   GlobalValue(const GlobalValue &) LLVM_DELETED_FUNCTION;
 public:
   /// @brief An enumeration for the kinds of linkage for global values.
   enum LinkageTypes {
~GlobalValue() {
     removeDeadConstantUsers();   // remove any dead constants using this.
   }
 
   unsigned getAlignment() const;
 
   bool hasUnnamedAddr() const { return UnnamedAddr; }
   void setUnnamedAddr(bool Val) { UnnamedAddr = Val; }
 
+  bool hasComdat() const { return getComdat() != nullptr; }
+  const Comdat *getComdat() const;
+  void setComdat(Comdat *C);
+
   VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
   bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
   bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
   bool hasProtectedVisibility() const {
     return Visibility == ProtectedVisibility;
   }
   void setVisibility(VisibilityTypes V) {
     assert((!hasLocalLinkage() || V == DefaultVisibility) &&

include/llvm/IR/GlobalVariable.h

class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {
 
   bool isConstantGlobal : 1;                   // Is this a global constant?
   bool isExternallyInitializedConstant : 1;    // Is this a global whose value
                                                // can change from its initial
                                                // value before global
                                                // initializers are run?
 
 public:
-  // allocate space for exactly one operand
+  // allocate space for exactly two operands
   void *operator new(size_t s) {
-    return User::operator new(s, 1);
+    return User::operator new(s, 2);
   }
 
   /// GlobalVariable ctor - If a parent module is specified, the global is
   /// automatically inserted into the end of the specified modules global list.
   GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
                  Constant *Initializer = nullptr, const Twine &Name = "",
                  ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
                  bool isExternallyInitialized = false);
   /// GlobalVariable ctor - This creates a global and inserts it before the
   /// specified other global.
   GlobalVariable(Module &M, Type *Ty, bool isConstant,
                  LinkageTypes Linkage, Constant *Initializer,
                  const Twine &Name = "", GlobalVariable *InsertBefore = nullptr,
                  ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
                  bool isExternallyInitialized = false);
 
   ~GlobalVariable() {
-    NumOperands = 1; // FIXME: needed by operator delete
+    NumOperands = 2; // FIXME: needed by operator delete
   }
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Definitions have initializers, declarations don't.
   ///
   inline bool hasInitializer() const { return !isDeclaration(); }
public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalVariableVal;
   }
 };
 
 template <>
 struct OperandTraits<GlobalVariable> :
-  public OptionalOperandTraits<GlobalVariable> {
+  public OptionalOperandTraits<GlobalVariable, 2> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value)
 
 } // End llvm namespace
 
 #endif

include/llvm/IR/Module.h

 /// Module.h This file contains the declarations for the Module class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_MODULE_H
 #define LLVM_IR_MODULE_H
 
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/IR/Comdat.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/system_error.h"
template<> struct ilist_traits<GlobalAlias>
 
   GlobalAlias *provideInitialHead() const { return createSentinel(); }
   GlobalAlias *ensureHead(GlobalAlias*) const { return createSentinel(); }
   static void noteHead(GlobalAlias*, GlobalAlias*) {}
 private:
   mutable ilist_node<GlobalAlias> Sentinel;
 };
 
+template <>
+struct ilist_traits<Comdat> : public SymbolTableListTraits<Comdat, Module> {
+  // createSentinel is used to get hold of a node that marks the end of the
+  // list.
+  Comdat *createSentinel() const { return static_cast<Comdat *>(&Sentinel); }
+  static void destroySentinel(Comdat *) {}
+
+  Comdat *provideInitialHead() const { return createSentinel(); }
+  Comdat *ensureHead(Comdat *) const { return createSentinel(); }
+  static void noteHead(Comdat *, Comdat *) {}
+
+  static ValueSymbolTable *getSymTab(Module *Par);
+
+private:
+  mutable ilist_node<Comdat> Sentinel;
+};
+
 template<> struct ilist_traits<NamedMDNode>
   : public ilist_default_traits<NamedMDNode> {
   // createSentinel is used to get hold of a node that marks the end of
   // the list...
   NamedMDNode *createSentinel() const {
     return static_cast<NamedMDNode*>(&Sentinel);
   }
   static void destroySentinel(NamedMDNode*) {}

 /// @{
 public:
   /// The type for the list of global variables.
   typedef iplist<GlobalVariable> GlobalListType;
   /// The type for the list of functions.
   typedef iplist<Function> FunctionListType;
   /// The type for the list of aliases.
   typedef iplist<GlobalAlias> AliasListType;
+  /// The type for the list of COMDATs.
+  typedef iplist<Comdat> ComdatListType;
   /// The type for the list of named metadata.
   typedef ilist<NamedMDNode> NamedMDListType;
 
   /// The Global Variable iterator.
   typedef GlobalListType::iterator                      global_iterator;
   /// The Global Variable constant iterator.
   typedef GlobalListType::const_iterator          const_global_iterator;
 
   /// The Function iterators.
   typedef FunctionListType::iterator                           iterator;
   /// The Function constant iterator
   typedef FunctionListType::const_iterator               const_iterator;
 
   /// The Global Alias iterators.
   typedef AliasListType::iterator                        alias_iterator;
   /// The Global Alias constant iterator
   typedef AliasListType::const_iterator            const_alias_iterator;
 
+  /// The COMDAT iterators.
+  typedef ComdatListType::iterator                      comdat_iterator;
+  /// The COMDAT constant iterator
+  typedef ComdatListType::const_iterator          const_comdat_iterator;
+
   /// The named metadata iterators.
   typedef NamedMDListType::iterator             named_metadata_iterator;
   /// The named metadata constant interators.
   typedef NamedMDListType::const_iterator const_named_metadata_iterator;
 
   /// This enumeration defines the supported behaviors of module flags.
   enum ModFlagBehavior {
     /// Emits an error if two values disagree, otherwise the resulting value is

 /// @name Member Variables
 /// @{
 private:
   LLVMContext &Context;           ///< The LLVMContext from which types and
                                   ///< constants are allocated.
   GlobalListType GlobalList;      ///< The Global Variables in the module
   FunctionListType FunctionList;  ///< The Functions in the module
   AliasListType AliasList;        ///< The Aliases in the module
+  ComdatListType ComdatList;      ///< The COMDATs in the module
   NamedMDListType NamedMDList;    ///< The named metadata in the module
   std::string GlobalScopeAsm;     ///< Inline Asm at global scope.
   ValueSymbolTable *ValSymTab;    ///< Symbol table for values
+  ValueSymbolTable *ComdatSymTab; ///< Symbol table for COMDATs
   std::unique_ptr<GVMaterializer>
   Materializer;                   ///< Used to materialize GlobalValues
   std::string ModuleID;           ///< Human readable identifier for the module
   std::string TargetTriple;       ///< Platform target triple Module compiled on
   void *NamedMDSymTab;            ///< NamedMDNode names.
 
   // We need to keep the string because the C API expects us to own the string
   // representation.
/// @{
   /// returns a new NamedMDNode if a NamedMDNode with the specified name is not
   /// found.
   NamedMDNode *getOrInsertNamedMetadata(StringRef Name);
 
   /// Remove the given NamedMDNode from this module and delete it.
   void eraseNamedMetadata(NamedMDNode *NMD);
 
 /// @}
+/// @name Comdat Accessors
+/// @{
+
+  /// Return the Comdat in the module with the specified name. This method
+  /// returns a new Comdat if a Comdat with the specified name is not
+  /// found.
+  Comdat *getOrInsertComdat(StringRef Name, Comdat::SelectionKind SK);
+
+/// @}
 /// @name Module Flags Accessors
 /// @{
 
   /// Returns the module flags in the provided vector.
   void getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const;
 
   /// Return the corresponding value if Key appears in module flags, otherwise
   /// return null.
/// @{
   }
   /// Get the Module's list of aliases (constant).
   const AliasListType    &getAliasList() const        { return AliasList; }
   /// Get the Module's list of aliases.
   AliasListType          &getAliasList()              { return AliasList; }
   static iplist<GlobalAlias> Module::*getSublistAccess(GlobalAlias*) {
     return &Module::AliasList;
   }
+  /// Get the Module's list of COMDATs (constant).
+  const ComdatListType    &getComdatList() const      { return ComdatList; }
+  /// Get the Module's list of COMDATs.
+  ComdatListType          &getComdatList()            { return ComdatList; }
+  static iplist<Comdat> Module::*getSublistAccess(Comdat *) {
+    return &Module::ComdatList;
+  }
   /// Get the Module's list of named metadata (constant).
   const NamedMDListType  &getNamedMDList() const      { return NamedMDList; }
   /// Get the Module's list of named metadata.
   NamedMDListType        &getNamedMDList()            { return NamedMDList; }
   static ilist<NamedMDNode> Module::*getSublistAccess(NamedMDNode*) {
     return &Module::NamedMDList;
   }
   /// Get the symbol table of global variable and function identifiers
   const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; }
   /// Get the Module's symbol table of global variable and function identifiers.
   ValueSymbolTable       &getValueSymbolTable()       { return *ValSymTab; }
+  /// Get the Module's symbol table for COMDATs (constant).
+  const ValueSymbolTable &getComdatSymbolTable() const { return *ComdatSymTab; }
+  /// Get the Module's symbol table for COMDATs.
+  ValueSymbolTable       &getComdatSymbolTable()       { return *ComdatSymTab; }
 
 /// @}
 /// @name Global Variable Iteration
 /// @{
 
   global_iterator       global_begin()       { return GlobalList.begin(); }
   const_global_iterator global_begin() const { return GlobalList.begin(); }
   global_iterator       global_end  ()       { return GlobalList.end(); }
/// @{
   iterator_range<alias_iterator> aliases() {
     return iterator_range<alias_iterator>(alias_begin(), alias_end());
   }
   iterator_range<const_alias_iterator> aliases() const {
     return iterator_range<const_alias_iterator>(alias_begin(), alias_end());
   }
 
 /// @}
+/// @name Comdat Iteration
+/// @{
+
+  comdat_iterator       comdat_begin()          { return ComdatList.begin(); }
+  const_comdat_iterator comdat_begin() const    { return ComdatList.begin(); }
+  comdat_iterator       comdat_end  ()          { return ComdatList.end();   }
+  const_comdat_iterator comdat_end  () const    { return ComdatList.end();   }
+  size_t                comdat_size () const    { return ComdatList.size();  }
+  bool                  comdat_empty() const    { return ComdatList.empty(); }
+
+  iterator_range<comdat_iterator> comdats() {
+    return iterator_range<comdat_iterator>(comdat_begin(), comdat_end());
+  }
+  iterator_range<const_comdat_iterator> comdats() const {
+    return iterator_range<const_comdat_iterator>(comdat_begin(), comdat_end());
+  }
+
+/// @}
 /// @name Named Metadata Iteration
 /// @{
 
   named_metadata_iterator named_metadata_begin() { return NamedMDList.begin(); }
   const_named_metadata_iterator named_metadata_begin() const {
     return NamedMDList.begin();
   }
 

include/llvm/IR/Type.h

enum TypeID {
 
     // Derived types... see DerivedTypes.h file.
     // Make sure FirstDerivedTyID stays up to date!
     IntegerTyID,     ///< 10: Arbitrary bit width integers
     FunctionTyID,    ///< 11: Functions
     StructTyID,      ///< 12: Structures
     ArrayTyID,       ///< 13: Arrays
     PointerTyID,     ///< 14: Pointers
-    VectorTyID       ///< 15: SIMD 'packed' format, or other vector type
+    VectorTyID,      ///< 15: SIMD 'packed' format, or other vector type
+    ComdatTyID,      ///< 16: COMDATs
   };
 
 private:
   /// Context - This refers to the LLVMContext in which this type was uniqued.
   LLVMContext &Context;
 
   // Due to Ubuntu GCC bug 910363:
   // https://bugs.launchpad.net/ubuntu/+source/gcc-4.5/+bug/910363
public:
   bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
  
   /// isLabelTy - Return true if this is 'label'.
   bool isLabelTy() const { return getTypeID() == LabelTyID; }
 
   /// isMetadataTy - Return true if this is 'metadata'.
   bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
 
+  /// \brief Return true if this is 'comdat'.
+  bool isComdatTy() const { return getTypeID() == ComdatTyID; }
+
   /// isIntegerTy - True if this is an instance of IntegerType.
   ///
   bool isIntegerTy() const { return getTypeID() == IntegerTyID; } 
 
   /// isIntegerTy - Return true if this is an IntegerType of the given width.
   bool isIntegerTy(unsigned Bitwidth) const;
 
   /// isIntOrIntVectorTy - Return true if this is an integer type or a vector of
public:
   // These are the builtin types that are always available.
   //
   static Type *getVoidTy(LLVMContext &C);
   static Type *getLabelTy(LLVMContext &C);
   static Type *getHalfTy(LLVMContext &C);
   static Type *getFloatTy(LLVMContext &C);
   static Type *getDoubleTy(LLVMContext &C);
   static Type *getMetadataTy(LLVMContext &C);
+  static Type *getComdatTy(LLVMContext &C);
   static Type *getX86_FP80Ty(LLVMContext &C);
   static Type *getFP128Ty(LLVMContext &C);
   static Type *getPPC_FP128Ty(LLVMContext &C);
   static Type *getX86_MMXTy(LLVMContext &C);
   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
   static IntegerType *getInt1Ty(LLVMContext &C);
   static IntegerType *getInt8Ty(LLVMContext &C);
   static IntegerType *getInt16Ty(LLVMContext &C);

include/llvm/IR/Value.h

enum ValueTy {
     ConstantIntVal,           // This is an instance of ConstantInt
     ConstantFPVal,            // This is an instance of ConstantFP
     ConstantArrayVal,         // This is an instance of ConstantArray
     ConstantStructVal,        // This is an instance of ConstantStruct
     ConstantVectorVal,        // This is an instance of ConstantVector
     ConstantPointerNullVal,   // This is an instance of ConstantPointerNull
     MDNodeVal,                // This is an instance of MDNode
     MDStringVal,              // This is an instance of MDString
+    ComdatVal,                // This is an instance of Comdat
     InlineAsmVal,             // This is an instance of InlineAsm
     InstructionVal,           // This is an instance of Instruction
     // Enum values starting at InstructionVal are used for Instructions;
     // don't add new values here!
 
     // Markers:
     ConstantFirstVal = FunctionVal,
     ConstantLastVal  = ConstantPointerNullVal

include/llvm/IR/ValueSymbolTable.h

 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
   template<typename ValueSubClass, typename ItemParentClass>
         class SymbolTableListTraits;
   class BasicBlock;
+  class Comdat;
   class Function;
   class NamedMDNode;
   class Module;
   class StringRef;
 
 /// This class provides a symbol table of name/value pairs. It is essentially
 /// a std::map<std::string,Value*> but has a controlled interface provided by
 /// LLVM as well as ensuring uniqueness of names.
 ///
 class ValueSymbolTable {
   friend class Value;
   friend class SymbolTableListTraits<Argument, Function>;
   friend class SymbolTableListTraits<BasicBlock, Function>;
   friend class SymbolTableListTraits<Instruction, BasicBlock>;
+  friend class SymbolTableListTraits<Comdat, Module>;
   friend class SymbolTableListTraits<Function, Module>;
   friend class SymbolTableListTraits<GlobalVariable, Module>;
   friend class SymbolTableListTraits<GlobalAlias, Module>;
 /// @name Types
 /// @{
 public:
   /// @brief A mapping of names to values.
   typedef StringMap<Value*> ValueMap;

lib/AsmParser/LLLexer.h

private:
     void SkipLineComment();
     lltok::Kind ReadString(lltok::Kind kind);
     bool ReadVarName();
 
     lltok::Kind LexIdentifier();
     lltok::Kind LexDigitOrNegative();
     lltok::Kind LexPositive();
     lltok::Kind LexAt();
+    lltok::Kind LexDollar();
     lltok::Kind LexExclaim();
     lltok::Kind LexPercent();
     lltok::Kind LexQuote();
     lltok::Kind Lex0x();
     lltok::Kind LexHash();
 
     uint64_t atoull(const char *Buffer, const char *End);
     uint64_t HexIntToVal(const char *Buffer, const char *End);
     void HexToIntPair(const char *Buffer, const char *End, uint64_t Pair[2]);
     void FP80HexToIntPair(const char *Buff, const char *End, uint64_t Pair[2]);
   };
 } // end namespace llvm
 
 #endif

lib/AsmParser/LLLexer.cpp

lltok::Kind LLLexer::LexToken() {
   case ' ':
   case '\t':
   case '\n':
   case '\r':
     // Ignore whitespace.
     return LexToken();
   case '+': return LexPositive();
   case '@': return LexAt();
+  case '$': return LexDollar();
   case '%': return LexPercent();
   case '"': return LexQuote();
   case '.':
     if (const char *Ptr = isLabelTail(CurPtr)) {
       CurPtr = Ptr;
       StrVal.assign(TokStart, CurPtr-1);
       return lltok::LabelStr;
     }
     if (CurPtr[0] == '.' && CurPtr[1] == '.') {
       CurPtr += 2;
       return lltok::dotdotdot;
     }
     return lltok::Error;
-  case '$':
-    if (const char *Ptr = isLabelTail(CurPtr)) {
-      CurPtr = Ptr;
-      StrVal.assign(TokStart, CurPtr-1);
-      return lltok::LabelStr;
-    }
-    return lltok::Error;
   case ';':
     SkipLineComment();
     return LexToken();
   case '!': return LexExclaim();
   case '#': return LexHash();
   case '0': case '1': case '2': case '3': case '4':
   case '5': case '6': case '7': case '8': case '9':
   case '-':
if ((unsigned)Val != Val)
       Error("invalid value number (too large)!");
     UIntVal = unsigned(Val);
     return lltok::GlobalID;
   }
 
   return lltok::Error;
 }
 
+lltok::Kind LLLexer::LexDollar() {
+  if (const char *Ptr = isLabelTail(TokStart)) {
+    CurPtr = Ptr;
+    StrVal.assign(TokStart, CurPtr - 1);
+    return lltok::LabelStr;
+  }
+
+  // Handle DollarStringConstant: $\"[^\"]*\"
+  if (CurPtr[0] == '"') {
+    ++CurPtr;
+
+    while (1) {
+      int CurChar = getNextChar();
+
+      if (CurChar == EOF) {
+        Error("end of file in COMDAT variable name");
+        return lltok::Error;
+      }
+      if (CurChar == '"') {
+        StrVal.assign(TokStart + 2, CurPtr - 1);
+        UnEscapeLexed(StrVal);
+        if (StringRef(StrVal).find_first_of(0) != StringRef::npos) {
+          Error("Null bytes are not allowed in names");
+          return lltok::Error;
+        }
+        return lltok::ComdatVar;
+      }
+    }
+  }
+
+  // Handle ComdatVarName: $[-a-zA-Z$._][-a-zA-Z$._0-9]*
+  if (ReadVarName())
+    return lltok::ComdatVar;
+
+  return lltok::Error;
+}
+
 /// ReadString - Read a string until the closing quote.
 lltok::Kind LLLexer::ReadString(lltok::Kind kind) {
   const char *Start = CurPtr;
   while (1) {
     int CurChar = getNextChar();
 
     if (CurChar == EOF) {
       Error("end of file in string constant");
#define KEYWORD(STR)                                                    \
   KEYWORD(sanitize_thread);
   KEYWORD(sanitize_memory);
   KEYWORD(uwtable);
   KEYWORD(zeroext);
 
   KEYWORD(type);
   KEYWORD(opaque);
 
+  KEYWORD(comdat);
+
+  // Comdat types
+  KEYWORD(any);
+  KEYWORD(exactmatch);
+  KEYWORD(largest);
+  KEYWORD(newest);
+  KEYWORD(noduplicates);
+  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);
   KEYWORD(umin);
 

lib/AsmParser/LLParser.h

namespace llvm {
   class Module;
   class OpaqueType;
   class Function;
   class Value;
   class BasicBlock;
   class Instruction;
   class Constant;
   class GlobalValue;
+  class Comdat;
   class MDString;
   class MDNode;
   class StructType;
 
   /// ValID - Represents a reference of a definition of some sort with no type.
   /// There are several cases where we have to parse the value but where the
   /// type can depend on later context.  This may either be a numeric reference
   /// or a symbolic (%var) reference.  This is just a discriminated union.
   struct ValID {
     enum {
       t_LocalID, t_GlobalID,      // ID in UIntVal.
       t_LocalName, t_GlobalName,  // Name in StrVal.
+      t_ComdatName,               // Name in StrVal.
       t_APSInt, t_APFloat,        // Value in APSIntVal/APFloatVal.
       t_Null, t_Undef, t_Zero,    // No value.
       t_EmptyArray,               // No value:  []
       t_Constant,                 // Value in ConstantVal.
       t_InlineAsm,                // Value in StrVal/StrVal2/UIntVal.
       t_MDNode,                   // Value in MDNodeVal.
       t_MDString,                 // Value in MDStringVal.
       t_ConstantStruct,           // Value in ConstantStructElts.
private:
     std::vector<TrackingVH<MDNode> > NumberedMetadata;
     std::map<unsigned, std::pair<TrackingVH<MDNode>, LocTy> > ForwardRefMDNodes;
 
     // Global Value reference information.
     std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
     std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
     std::vector<GlobalValue*> NumberedVals;
 
+    // Comdat reference information.
+    std::map<std::string, std::pair<Comdat *, LocTy>> ForwardRefComdats;
+
     // References to blockaddress.  The key is the function ValID, the value is
     // a list of references to blocks in that function.
     std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >
       ForwardRefBlockAddresses;
 
     // Attribute builder reference information.
     std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
     std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
private:
     }
 
     /// GetGlobalVal - Get a value with the specified name or ID, creating a
     /// forward reference record if needed.  This can return null if the value
     /// exists but does not have the right type.
     GlobalValue *GetGlobalVal(const std::string &N, Type *Ty, LocTy Loc);
     GlobalValue *GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc);
 
+    /// GetComdatVal - Get a Comdat with the specified name, creating a forward
+    /// reference record if needed.
+    Comdat *GetComdat(const std::string &N, LocTy Loc);
+
     // Helper Routines.
     bool ParseToken(lltok::Kind T, const char *ErrMsg);
     bool EatIfPresent(lltok::Kind T) {
       if (Lex.getKind() != T) return false;
       Lex.Lex();
       return true;
     }
 
private:
     bool ParseNamedGlobal();
     bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage,
                      bool HasLinkage, unsigned Visibility,
                      unsigned DLLStorageClass,
                      GlobalVariable::ThreadLocalMode TLM, bool UnnamedAddr);
     bool ParseAlias(const std::string &Name, LocTy Loc, unsigned Visibility,
                     unsigned DLLStorageClass,
                     GlobalVariable::ThreadLocalMode TLM, bool UnnamedAddr);
+    bool ParseComdat();
     bool ParseStandaloneMetadata();
     bool ParseNamedMetadata();
     bool ParseMDString(MDString *&Result);
     bool ParseMDNodeID(MDNode *&Result);
     bool ParseMDNodeID(MDNode *&Result, unsigned &SlotNo);
     bool ParseUnnamedAttrGrp();
     bool ParseFnAttributeValuePairs(AttrBuilder &B,
                                     std::vector<unsigned> &FwdRefAttrGrps,
private:
     bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
                             PerFunctionState &PFS);
 
     // Constant Parsing.
     bool ParseValID(ValID &ID, PerFunctionState *PFS = nullptr);
     bool ParseGlobalValue(Type *Ty, Constant *&V);
     bool ParseGlobalTypeAndValue(Constant *&V);
     bool ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts);
+    bool ParseOptionalComdat(Comdat *&C);
     bool ParseMetadataListValue(ValID &ID, PerFunctionState *PFS);
     bool ParseMetadataValue(ValID &ID, PerFunctionState *PFS);
     bool ParseMDNodeVector(SmallVectorImpl<Value*> &, PerFunctionState *PFS);
     bool ParseInstructionMetadata(Instruction *Inst, PerFunctionState *PFS);
 
     // Function Parsing.
     struct ArgInfo {
       LocTy Loc;

lib/AsmParser/LLParser.cpp

if (NumberedTypes[i].second.isValid())
                    "use of undefined type '%" + Twine(i) + "'");
 
   for (StringMap<std::pair<Type*, LocTy> >::iterator I =
        NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I)
     if (I->second.second.isValid())
       return Error(I->second.second,
                    "use of undefined type named '" + I->getKey() + "'");
 
+  if (!ForwardRefComdats.empty())
+    return Error(ForwardRefComdats.begin()->second.second,
+                 "use of undefined comdat '$" +
+                     ForwardRefComdats.begin()->first + "'");
+
   if (!ForwardRefVals.empty())
     return Error(ForwardRefVals.begin()->second.second,
                  "use of undefined value '@" + ForwardRefVals.begin()->first +
                  "'");
 
   if (!ForwardRefValIDs.empty())
     return Error(ForwardRefValIDs.begin()->second.second,
                  "use of undefined value '@" +
while (1) {
     case lltok::kw_define:  if (ParseDefine()) return true; break;
     case lltok::kw_module:  if (ParseModuleAsm()) return true; break;
     case lltok::kw_target:  if (ParseTargetDefinition()) return true; break;
     case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
     case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
     case lltok::LocalVar:   if (ParseNamedType()) return true; break;
     case lltok::GlobalID:   if (ParseUnnamedGlobal()) return true; break;
     case lltok::GlobalVar:  if (ParseNamedGlobal()) return true; break;
+    case lltok::ComdatVar:  if (ParseComdat()) return true; break;
     case lltok::exclaim:    if (ParseStandaloneMetadata()) return true; break;
     case lltok::MetadataVar:if (ParseNamedMetadata()) return true; break;
 
     // The Global variable production with no name can have many different
     // optional leading prefixes, the production is:
     // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
     //               OptionalThreadLocal OptionalAddrSpace OptionalUnNammedAddr
     //               ('constant'|'global') ...
bool LLParser::ParseNamedGlobal() {
 
   if (HasLinkage || Lex.getKind() != lltok::kw_alias)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
                        DLLStorageClass, TLM, UnnamedAddr);
   return ParseAlias(Name, NameLoc, Visibility, DLLStorageClass, TLM,
                     UnnamedAddr);
 }
 
+bool LLParser::ParseComdat() {
+  assert(Lex.getKind() == lltok::ComdatVar);
+  std::string Name = Lex.getStrVal();
+  LocTy NameLoc = Lex.getLoc();
+  Lex.Lex();
+
+  if (ParseToken(lltok::equal, "expected '=' here"))
+    return true;
+
+  if (ParseToken(lltok::kw_comdat, "expected comdat keyword"))
+    return TokError("expected comdat type");
+
+  Comdat::SelectionKind SK;
+  switch (Lex.getKind()) {
+  default: return TokError("unknown selection kind");
+  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_newest:       SK = Comdat::Newest;       break;
+  case lltok::kw_noduplicates: SK = Comdat::NoDuplicates; break;
+  case lltok::kw_samesize:     SK = Comdat::SameSize;     break;
+  }
+  Lex.Lex();
+
+  // See if the comdat was forward referenced, if so, use the comdat.
+  Comdat *C = cast_or_null<Comdat>(M->getComdatSymbolTable().lookup(Name));
+  if (C && !ForwardRefComdats.erase(Name))
+    return Error(NameLoc, "redefinition of comdat '$" + Name + "'");
+
+  if (!C) {
+    C = new Comdat(SK, Name, M);
+  } else {
+    C->setSelectionKind(SK);
+    // Move the forward-reference to the correct spot in the module.
+    M->getComdatList().splice(M->comdat_end(), M->getComdatList(), C);
+  }
+
+  return false;
+}
+
 // MDString:
 //   ::= '!' STRINGCONSTANT
 bool LLParser::ParseMDString(MDString *&Result) {
   std::string Str;
   if (ParseStringConstant(Str)) return true;
   Result = MDString::get(Context, Str);
   return false;
 }
if (Lex.getKind() != lltok::kw_bitcast &&
     // The bitcast dest type is not present, it is implied by the dest type.
     ValID ID;
     if (ParseValID(ID))
       return true;
     if (ID.Kind != ValID::t_Constant)
       return Error(AliaseeLoc, "invalid aliasee");
     Aliasee = ID.ConstantVal;
   }
+  Comdat *C = nullptr;
+  if (EatIfPresent(lltok::comma)) {
+    if (ParseOptionalComdat(C))
+      return true;
+    else if (!C)
+      return TokError("unknown global variable property!");
+  }
 
   Type *AliaseeType = Aliasee->getType();
   auto *PTy = dyn_cast<PointerType>(AliaseeType);
   if (!PTy)
     return Error(AliaseeLoc, "An alias must have pointer type");
   Type *Ty = PTy->getElementType();
   unsigned AddrSpace = PTy->getAddressSpace();
 
   // Okay, create the alias but do not insert it into the module yet.
   std::unique_ptr<GlobalAlias> GA(
       GlobalAlias::create(Ty, AddrSpace, (GlobalValue::LinkageTypes)Linkage,
                           Name, Aliasee, /*Parent*/ nullptr));
   GA->setThreadLocalMode(TLM);
   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GA->setUnnamedAddr(UnnamedAddr);
+  GA->setComdat(C);
 
   // See if this value already exists in the symbol table.  If so, it is either
   // a redefinition or a definition of a forward reference.
   if (GlobalValue *Val = M->getNamedValue(Name)) {
     // See if this was a redefinition.  If so, there is no entry in
     // ForwardRefVals.
     std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
       I = ForwardRefVals.find(Name);
if (Lex.getKind() == lltok::kw_section) {
       GV->setSection(Lex.getStrVal());
       if (ParseToken(lltok::StringConstant, "expected global section string"))
         return true;
     } else if (Lex.getKind() == lltok::kw_align) {
       unsigned Alignment;
       if (ParseOptionalAlignment(Alignment)) return true;
       GV->setAlignment(Alignment);
     } else {
-      TokError("unknown global variable property!");
+      Comdat *C;
+      if (ParseOptionalComdat(C)) return true;
+      if (C)
+        GV->setComdat(C);
+      else
+        return TokError("unknown global variable property!");
     }
   }
 
   return false;
 }
 
 /// ParseUnnamedAttrGrp
 ///   ::= 'attributes' AttrGrpID '=' '{' AttrValPair+ '}'
FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
                                 GlobalValue::ExternalWeakLinkage, nullptr, "");
 
   ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
   return FwdVal;
 }
 
 
 //===----------------------------------------------------------------------===//
+// Comdat Reference/Resolution Routines.
+//===----------------------------------------------------------------------===//
+
+/// GetComdatVal - Get a Comdat with the specified name, creating a forward
+/// reference record if needed.
+Comdat *LLParser::GetComdat(const std::string &Name, LocTy Loc) {
+  // Look this name up in the normal function symbol table.
+  Comdat *C = cast_or_null<Comdat>(M->getComdatSymbolTable().lookup(Name));
+
+  // If this is a forward reference for the value, see if we already created a
+  // forward ref record.
+  if (!C) {
+    std::map<std::string, std::pair<Comdat *, LocTy>>::iterator I =
+        ForwardRefComdats.find(Name);
+    if (I != ForwardRefComdats.end())
+      C = I->second.first;
+  }
+
+  // If we have the value in the symbol table or fwd-ref table, return it.
+  if (C)
+    return C;
+
+  // Otherwise, create a new forward reference for this value and remember it.
+  Comdat *FwdVal = new Comdat(Comdat::Any, Name, M);
+
+  ForwardRefComdats[Name] = std::make_pair(FwdVal, Loc);
+  return FwdVal;
+}
+
+
+//===----------------------------------------------------------------------===//
 // Helper Routines.
 //===----------------------------------------------------------------------===//
 
 /// ParseToken - If the current token has the specified kind, eat it and return
 /// success.  Otherwise, emit the specified error and return failure.
 bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
   if (Lex.getKind() != T)
     return TokError(ErrMsg);
bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
   case lltok::GlobalID:  // @42
     ID.UIntVal = Lex.getUIntVal();
     ID.Kind = ValID::t_GlobalID;
     break;
   case lltok::GlobalVar:  // @foo
     ID.StrVal = Lex.getStrVal();
     ID.Kind = ValID::t_GlobalName;
     break;
+  case lltok::ComdatVar:  // $foo
+    ID.StrVal = Lex.getStrVal();
+    ID.Kind = ValID::t_ComdatName;
+    break;
   case lltok::LocalVarID:  // %42
     ID.UIntVal = Lex.getUIntVal();
     ID.Kind = ValID::t_LocalID;
     break;
   case lltok::LocalVar:  // %foo
     ID.StrVal = Lex.getStrVal();
     ID.Kind = ValID::t_LocalName;
     break;

 }
 
 bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
   Type *Ty = nullptr;
   return ParseType(Ty) ||
          ParseGlobalValue(Ty, V);
 }
 
+bool LLParser::ParseOptionalComdat(Comdat *&C) {
+  C = nullptr;
+  if (!EatIfPresent(lltok::kw_comdat))
+    return false;
+  if (Lex.getKind() != lltok::ComdatVar)
+    return TokError("expected comdat variable");
+
+  ValID ID;
+  Value *V = nullptr;
+  bool Parsed = ParseValID(ID) ||
+                ConvertValIDToValue(Type::getComdatTy(Context), ID, V, nullptr);
+  if (V && !(C = dyn_cast<Comdat>(V)))
+    return Error(ID.Loc, "expected comdat");
+  return Parsed;
+}
+
 /// ParseGlobalValueVector
 ///   ::= /*empty*/
 ///   ::= TypeAndValue (',' TypeAndValue)*
 bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) {
   // Empty list.
   if (Lex.getKind() == lltok::rbrace ||
       Lex.getKind() == lltok::rsquare ||
       Lex.getKind() == lltok::greater ||
if (!Ty->isMetadataTy())
       return Error(ID.Loc, "metadata value must have metadata type");
     V = ID.MDNodeVal;
     return false;
   case ValID::t_MDString:
     if (!Ty->isMetadataTy())
       return Error(ID.Loc, "metadata value must have metadata type");
     V = ID.MDStringVal;
     return false;
+  case ValID::t_ComdatName:
+    if (!Ty->isComdatTy())
+      return Error(ID.Loc, "comdat value must have comdat type");
+    V = GetComdat(ID.StrVal, ID.Loc);
+    return V == nullptr;
   case ValID::t_GlobalName:
     V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
     return V == nullptr;
   case ValID::t_GlobalID:
     V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
     return V == nullptr;
   case ValID::t_APSInt:
     if (!Ty->isIntegerTy())
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   std::vector<unsigned> FwdRefAttrGrps;
   LocTy BuiltinLoc;
   std::string Section;
   unsigned Alignment;
   std::string GC;
   bool UnnamedAddr;
   LocTy UnnamedAddrLoc;
   Constant *Prefix = nullptr;
+  Comdat *C;
 
   if (ParseArgumentList(ArgList, isVarArg) ||
       ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr,
                          &UnnamedAddrLoc) ||
       ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
                                  BuiltinLoc) ||
       (EatIfPresent(lltok::kw_section) &&
        ParseStringConstant(Section)) ||
+      ParseOptionalComdat(C) ||
       ParseOptionalAlignment(Alignment) ||
       (EatIfPresent(lltok::kw_gc) &&
        ParseStringConstant(GC)) ||
       (EatIfPresent(lltok::kw_prefix) &&
        ParseGlobalTypeAndValue(Prefix)))
     return true;
 
   if (FuncAttrs.contains(Attribute::Builtin))
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
   Fn->setAlignment(Alignment);
   Fn->setSection(Section);
+  Fn->setComdat(C);
   if (!GC.empty()) Fn->setGC(GC.c_str());
   Fn->setPrefixData(Prefix);
   ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
 
   // Add all of the arguments we parsed to the function.
   Function::arg_iterator ArgIt = Fn->arg_begin();
   for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
     // If the argument has a name, insert it into the argument symbol table.

lib/AsmParser/LLToken.h

enum Kind {
     kw_sanitize_thread,
     kw_sanitize_memory,
     kw_uwtable,
     kw_zeroext,
 
     kw_type,
     kw_opaque,
 
+    kw_comdat,
+
+    // Comdat types
+    kw_any,
+    kw_exactmatch,
+    kw_largest,
+    kw_newest,
+    kw_noduplicates,
+    kw_samesize,
+
     kw_eq, kw_ne, kw_slt, kw_sgt, kw_sle, kw_sge, kw_ult, kw_ugt, kw_ule,
     kw_uge, kw_oeq, kw_one, kw_olt, kw_ogt, kw_ole, kw_oge, kw_ord, kw_uno,
     kw_ueq, kw_une,
 
     // atomicrmw operations that aren't also instruction keywords.
     kw_xchg, kw_nand, kw_max, kw_min, kw_umax, kw_umin,
 
     // Instruction Opcodes (Opcode in UIntVal).
enum Kind {
     // Unsigned Valued tokens (UIntVal).
     GlobalID,          // @42
     LocalVarID,        // %42
     AttrGrpID,         // #42
 
     // String valued tokens (StrVal).
     LabelStr,          // foo:
     GlobalVar,         // @foo @"foo"
+    ComdatVar,         // $foo
     LocalVar,          // %foo %"foo"
     MetadataVar,       // !foo
     StringConstant,    // "foo"
 
     // Type valued tokens (TyVal).
     Type,
 
     APFloat,  // APFloatVal
     APSInt // APSInt
   };
 } // end namespace lltok
 } // end namespace llvm
 
 #endif

lib/Bitcode/Reader/BitcodeReader.h

 #include "llvm/IR/GVMaterializer.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/system_error.h"
 #include <vector>
 
 namespace llvm {
+  class Comdat;
   class MemoryBuffer;
   class LLVMContext;
 
 //===----------------------------------------------------------------------===//
 //                          BitcodeReaderValueList Class
 //===----------------------------------------------------------------------===//
 
 class BitcodeReaderValueList {
class BitcodeReader : public GVMaterializer {
   BitstreamCursor Stream;
   DataStreamer *LazyStreamer;
   uint64_t NextUnreadBit;
   bool SeenValueSymbolTable;
 
   std::vector<Type*> TypeList;
   BitcodeReaderValueList ValueList;
   BitcodeReaderMDValueList MDValueList;
+  std::vector<Comdat *> ComdatList;
   SmallVector<Instruction *, 64> InstructionList;
   SmallVector<SmallVector<uint64_t, 64>, 64> UseListRecords;
 
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
   std::vector<std::pair<Function*, unsigned> > FunctionPrefixes;
+  std::vector<std::pair<GlobalValue *, unsigned>> Comdats;
 
   SmallVector<Instruction*, 64> InstsWithTBAATag;
 
   /// MAttributes - The set of attributes by index.  Index zero in the
   /// file is for null, and is thus not represented here.  As such all indices
   /// are off by one.
   std::vector<AttributeSet> MAttributes;
 
private:
   error_code ParseTypeTable();
   error_code ParseTypeTableBody();
 
   error_code ParseValueSymbolTable();
   error_code ParseConstants();
   error_code RememberAndSkipFunctionBody();
   error_code ParseFunctionBody(Function *F);
   error_code GlobalCleanup();
+  error_code ResolveComdats();
   error_code ResolveGlobalAndAliasInits();
   error_code ParseMetadata();
   error_code ParseMetadataAttachment();
   error_code ParseModuleTriple(std::string &Triple);
   error_code ParseUseLists();
   error_code InitStream();
   error_code InitStreamFromBuffer();
   error_code InitLazyStream();
   error_code FindFunctionInStream(Function *F,
          DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator);
 };
 
 } // End llvm namespace
 
 #endif

lib/Bitcode/Reader/BitcodeReader.cpp

 
 void BitcodeReader::FreeState() {
   if (BufferOwned)
     delete Buffer;
   Buffer = nullptr;
   std::vector<Type*>().swap(TypeList);
   ValueList.clear();
   MDValueList.clear();
+  std::vector<Comdat *>().swap(ComdatList);
 
   std::vector<AttributeSet>().swap(MAttributes);
   std::vector<BasicBlock*>().swap(FunctionBBs);
   std::vector<Function*>().swap(FunctionsWithBodies);
   DeferredFunctionInfo.clear();
   MDKindMap.clear();
 
   assert(BlockAddrFwdRefs.empty() && "Unresolved blockaddress fwd references");

 static SynchronizationScope GetDecodedSynchScope(unsigned Val) {
   switch (Val) {
   case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread;
   default: // Map unknown scopes to cross-thread.
   case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread;
   }
 }
 
+static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {
+  switch (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_NEWEST:        return Comdat::Newest;
+  case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES: return Comdat::NoDuplicates;
+  case bitc::COMDAT_SELECTION_KIND_SAME_SIZE:     return Comdat::SameSize;
+
+  }
+}
+
 static void UpgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val) {
   switch (Val) {
   case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break;
   case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break;
   }
 }
 
 namespace llvm {
uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) {
   if ((V & 1) == 0)
     return V >> 1;
   if (V != 1)
     return -(V >> 1);
   // There is no such thing as -0 with integers.  "-0" really means MININT.
   return 1ULL << 63;
 }
 
+error_code BitcodeReader::ResolveComdats() {
+  std::vector<std::pair<GlobalValue *, unsigned>> ComdatWorklist;
+  ComdatWorklist.swap(Comdats);
+
+  while (!ComdatWorklist.empty()) {
+    unsigned ComdatID = ComdatWorklist.back().second;
+    if (ComdatID >= ComdatList.size()) {
+      Comdats.push_back(ComdatWorklist.back());
+    } else {
+      if (Comdat *C = ComdatList[ComdatID])
+        ComdatWorklist.back().first->setComdat(C);
+      else
+        return Error(InvalidValue);
+    }
+    ComdatWorklist.pop_back();
+  }
+
+  return error_code();
+}
+
 /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
 /// values and aliases that we can.
 error_code BitcodeReader::ResolveGlobalAndAliasInits() {
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
   std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist;
 
   GlobalInitWorklist.swap(GlobalInits);
if (ValID >= ValueList.size()) {
       if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
         FunctionPrefixWorklist.back().first->setPrefixData(C);
       else
         return Error(ExpectedConstant);
     }
     FunctionPrefixWorklist.pop_back();
   }
 
+  if (error_code EC = ResolveComdats())
+    return EC;
+
   return error_code();
 }
 
 static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
   SmallVector<uint64_t, 8> Words(Vals.size());
   std::transform(Vals.begin(), Vals.end(), Words.begin(),
                  BitcodeReader::decodeSignRotatedValue);
 
while (1) {
     }
     case bitc::MODULE_CODE_GCNAME: {  // SECTIONNAME: [strchr x N]
       std::string S;
       if (ConvertToString(Record, 0, S))
         return Error(InvalidRecord);
       GCTable.push_back(S);
       break;
     }
+    case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name]
+      if (Record.size() < 2)
+        return Error(InvalidRecord);
+      Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]);
+      std::string ComdatName;
+      if (ConvertToString(Record, 1, ComdatName))
+        return Error(InvalidRecord);
+      Comdat *C = new Comdat(SK, ComdatName, TheModule);
+      ComdatList.push_back(C);
+      break;
+    }
     // GLOBALVAR: [pointer type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, dllstorageclass]
     case bitc::MODULE_CODE_GLOBALVAR: {
       if (Record.size() < 6)
         return Error(InvalidRecord);
       Type *Ty = getTypeByID(Record[0]);
       if (!Ty)
case bitc::MODULE_CODE_GLOBALVAR: {
       else
         UpgradeDLLImportExportLinkage(NewGV, Record[3]);
 
       ValueList.push_back(NewGV);
 
       // Remember which value to use for the global initializer.
       if (unsigned InitID = Record[2])
         GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
+
+      // Remember which value to use for the comdat.
+      if (Record.size() > 11)
+        if (unsigned ComdatID = Record[11])
+          Comdats.push_back(std::make_pair(NewGV, ComdatID - 1));
       break;
     }
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattr,
     //             alignment, section, visibility, gc, unnamed_addr,
     //             dllstorageclass]
     case bitc::MODULE_CODE_FUNCTION: {
       if (Record.size() < 8)
         return Error(InvalidRecord);
case bitc::MODULE_CODE_FUNCTION: {
       if (Record.size() > 10 && Record[10] != 0)
         FunctionPrefixes.push_back(std::make_pair(Func, Record[10]-1));
 
       if (Record.size() > 11)
         Func->setDLLStorageClass(GetDecodedDLLStorageClass(Record[11]));
       else
         UpgradeDLLImportExportLinkage(Func, Record[3]);
 
+      if (Record.size() > 12)
+        if (unsigned ComdatID = Record[12])
+          Func->setComdat(ComdatList[ComdatID - 1]);
+
       ValueList.push_back(Func);
 
       // If this is a function with a body, remember the prototype we are
       // creating now, so that we can match up the body with them later.
       if (!isProto) {
         FunctionsWithBodies.push_back(Func);
         if (LazyStreamer) DeferredFunctionInfo[Func] = 0;
       }
case bitc::MODULE_CODE_ALIAS: {
       else
         UpgradeDLLImportExportLinkage(NewGA, Record[2]);
       if (Record.size() > 5)
   NewGA->setThreadLocalMode(GetDecodedThreadLocalMode(Record[5]));
       if (Record.size() > 6)
   NewGA->setUnnamedAddr(Record[6]);
       ValueList.push_back(NewGA);
       AliasInits.push_back(std::make_pair(NewGA, Record[1]));
+      // Remember which value to use for the comdat.
+      if (Record.size() > 7)
+        if (unsigned ComdatID = Record[7])
+          Comdats.push_back(std::make_pair(NewGA, ComdatID - 1));
       break;
     }
     /// MODULE_CODE_PURGEVALS: [numvals]
     case bitc::MODULE_CODE_PURGEVALS:
       // Trim down the value list to the specified size.
       if (Record.size() < 1 || Record[0] > ValueList.size())
         return Error(InvalidRecord);
       ValueList.shrinkTo(Record[0]);

lib/Bitcode/Writer/BitcodeWriter.cpp

for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
     case Type::FloatTyID:     Code = bitc::TYPE_CODE_FLOAT;     break;
     case Type::DoubleTyID:    Code = bitc::TYPE_CODE_DOUBLE;    break;
     case Type::X86_FP80TyID:  Code = bitc::TYPE_CODE_X86_FP80;  break;
     case Type::FP128TyID:     Code = bitc::TYPE_CODE_FP128;     break;
     case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
     case Type::LabelTyID:     Code = bitc::TYPE_CODE_LABEL;     break;
     case Type::MetadataTyID:  Code = bitc::TYPE_CODE_METADATA;  break;
     case Type::X86_MMXTyID:   Code = bitc::TYPE_CODE_X86_MMX;   break;
+    case Type::ComdatTyID:    Code = bitc::TYPE_CODE_COMDAT;    break;
     case Type::IntegerTyID:
       // INTEGER: [width]
       Code = bitc::TYPE_CODE_INTEGER;
       TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
       break;
     case Type::PointerTyID: {
       PointerType *PTy = cast<PointerType>(T);
       // POINTER: [pointee type, address space]
switch (GV.getThreadLocalMode()) {
     case GlobalVariable::GeneralDynamicTLSModel: return 1;
     case GlobalVariable::LocalDynamicTLSModel:   return 2;
     case GlobalVariable::InitialExecTLSModel:    return 3;
     case GlobalVariable::LocalExecTLSModel:      return 4;
   }
   llvm_unreachable("Invalid TLS model");
 }
 
+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::Newest:       return bitc::COMDAT_SELECTION_KIND_NEWEST;
+  case Comdat::NoDuplicates: return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;
+  case Comdat::SameSize:     return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;
+  }
+  llvm_unreachable("Invalid selection kind");
+}
+
 // Emit top-level description of module, including target triple, inline asm,
 // descriptors for global variables, and function prototype info.
 static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
                             BitstreamWriter &Stream) {
   // Emit various pieces of data attached to a module.
   if (!M->getTargetTriple().empty())
     WriteStringRecord(bitc::MODULE_CODE_TRIPLE, M->getTargetTriple(),
                       0/*TODO*/, Stream);
if (SectionMap.empty())                                    // Section.
       Abbv->Add(BitCodeAbbrevOp(0));
     else
       Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
                                Log2_32_Ceil(SectionMap.size()+1)));
     // Don't bother emitting vis + thread local.
     SimpleGVarAbbrev = Stream.EmitAbbrev(Abbv);
   }
 
-  // Emit the global variable information.
+  // Emit the comdat information.
   SmallVector<unsigned, 64> Vals;
+  for (const Comdat &C : M->comdats()) {
+    // COMDAT: [selection_kind, name]
+    unsigned AbbrevToUse = 0;
+    Vals.push_back(getEncodedComdatSelectionKind(C));
+    for (char C : C.getName())
+      Vals.push_back((unsigned char)C);
+    Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, AbbrevToUse);
+    Vals.clear();
+  }
+
+  // Emit the global variable information.
   for (const GlobalVariable &GV : M->globals()) {
     unsigned AbbrevToUse = 0;
 
     // GLOBALVAR: [type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass]
     Vals.push_back(VE.getTypeID(GV.getType()));
     Vals.push_back(GV.isConstant());
     Vals.push_back(GV.isDeclaration() ? 0 :
                    (VE.getValueID(GV.getInitializer()) + 1));
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(Log2_32(GV.getAlignment())+1);
     Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0);
     if (GV.isThreadLocal() ||
         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.hasUnnamedAddr() || GV.isExternallyInitialized() ||
-        GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass) {
+        GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
+        GV.hasComdat()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(GV.hasUnnamedAddr());
       Vals.push_back(GV.isExternallyInitialized());
       Vals.push_back(getEncodedDLLStorageClass(GV));
+      Vals.push_back(GV.hasComdat() ? (VE.getValueID(GV.getComdat()) + 1) : 0);
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 
for (const Function &F : *M) {
     Vals.push_back(Log2_32(F.getAlignment())+1);
     Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
     Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
     Vals.push_back(F.hasUnnamedAddr());
     Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
                                       : 0);
     Vals.push_back(getEncodedDLLStorageClass(F));
+    Vals.push_back(F.hasComdat() ? (VE.getValueID(F.getComdat()) + 1) : 0);
 
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the alias information.
   for (const GlobalAlias &A : M->aliases()) {
     // ALIAS: [alias type, aliasee val#, linkage, visibility]
     Vals.push_back(VE.getTypeID(A.getType()));
     Vals.push_back(VE.getValueID(A.getAliasee()));
     Vals.push_back(getEncodedLinkage(A));
     Vals.push_back(getEncodedVisibility(A));
     Vals.push_back(getEncodedDLLStorageClass(A));
     Vals.push_back(getEncodedThreadLocalMode(A));
     Vals.push_back(A.hasUnnamedAddr());
+    Vals.push_back(A.hasComdat() ? (VE.getValueID(A.getComdat()) + 1) : 0);
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
     Vals.clear();
   }
 }
 
 static uint64_t GetOptimizationFlags(const Value *V) {
   uint64_t Flags = 0;

lib/Bitcode/Writer/ValueEnumerator.h

 #include <vector>
 
 namespace llvm {
 
 class Type;
 class Value;
 class Instruction;
 class BasicBlock;
+class Comdat;
 class Function;
 class Module;
 class MDNode;
 class NamedMDNode;
 class AttributeSet;
 class ValueSymbolTable;
 class MDSymbolTable;
 class raw_ostream;
 
 class ValueEnumerator {
 public:
   typedef std::vector<Type*> TypeList;
 
   // For each value, we remember its Value* and occurrence frequency.
   typedef std::vector<std::pair<const Value*, unsigned> > ValueList;
 private:
   typedef DenseMap<Type*, unsigned> TypeMapType;
   TypeMapType TypeMap;
   TypeList Types;
 
   typedef DenseMap<const Value*, unsigned> ValueMapType;
   ValueMapType ValueMap;
   ValueList Values;
+  ValueMapType ComdatMap;
+  ValueList Comdats;
   ValueList MDValues;
   SmallVector<const MDNode *, 8> FunctionLocalMDs;
   ValueMapType MDValueMap;
 
   typedef DenseMap<AttributeSet, unsigned> AttributeGroupMapType;
   AttributeGroupMapType AttributeGroupMap;
   std::vector<AttributeSet> AttributeGroups;
 

 private:
   void OptimizeConstants(unsigned CstStart, unsigned CstEnd);
 
   void EnumerateMDNodeOperands(const MDNode *N);
   void EnumerateMetadata(const Value *MD);
   void EnumerateFunctionLocalMetadata(const MDNode *N);
   void EnumerateNamedMDNode(const NamedMDNode *NMD);
   void EnumerateValue(const Value *V);
+  void EnumerateComdat(const Comdat *C);
   void EnumerateType(Type *T);
   void EnumerateOperandType(const Value *V);
   void EnumerateAttributes(AttributeSet PAL);
 
   void EnumerateValueSymbolTable(const ValueSymbolTable &ST);
+  void EnumerateComdats(const Module *M);
   void EnumerateNamedMetadata(const Module *M);
 };
 
 } // End llvm namespace
 
 #endif

lib/Bitcode/Writer/ValueEnumerator.cpp

ValueEnumerator::ValueEnumerator(const Module *M) {
   // Enumerate the prefix data constants.
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
     if (I->hasPrefixData())
       EnumerateValue(I->getPrefixData());
 
   // Insert constants and metadata that are named at module level into the slot
   // pool so that the module symbol table can refer to them...
   EnumerateValueSymbolTable(M->getValueSymbolTable());
+  EnumerateComdats(M);
   EnumerateNamedMetadata(M);
 
   SmallVector<std::pair<unsigned, MDNode*>, 8> MDs;
 
   // Enumerate types used by function bodies and argument lists.
   for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
 
     for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();

 }
 
 unsigned ValueEnumerator::getValueID(const Value *V) const {
   if (isa<MDNode>(V) || isa<MDString>(V)) {
     ValueMapType::const_iterator I = MDValueMap.find(V);
     assert(I != MDValueMap.end() && "Value not in slotcalculator!");
     return I->second-1;
   }
+  if (isa<Comdat>(V)) {
+    ValueMapType::const_iterator I = ComdatMap.find(V);
+    assert(I != ComdatMap.end() && "Value not in slotcalculator!");
+    return I->second - 1;
+  }
 
   ValueMapType::const_iterator I = ValueMap.find(V);
   assert(I != ValueMap.end() && "Value not in slotcalculator!");
   return I->second-1;
 }
 
 void ValueEnumerator::dump() const {
   print(dbgs(), ValueMap, "Default");
   dbgs() << '\n';
+  print(dbgs(), ComdatMap, "Comdat");
+  dbgs() << '\n';
   print(dbgs(), MDValueMap, "MetaData");
   dbgs() << '\n';
 }
 
 void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
                             const char *Name) const {
 
   OS << "Map Name: " << Name << "\n";

 /// EnumerateValueSymbolTable - Insert all of the values in the specified symbol
 /// table into the values table.
 void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
   for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end();
        VI != VE; ++VI)
     EnumerateValue(VI->getValue());
 }
 
+/// EnumerateComdats - Insert all of the values in the specified symbol
+/// table into the values table.
+void ValueEnumerator::EnumerateComdats(const Module *M) {
+  for (const Comdat &C : M->comdats())
+    EnumerateComdat(&C);
+}
+
 /// EnumerateNamedMetadata - Insert all of the values referenced by
 /// named metadata in the specified module.
 void ValueEnumerator::EnumerateNamedMetadata(const Module *M) {
   for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
        E = M->named_metadata_end(); I != E; ++I)
     EnumerateNamedMDNode(I);
 }
 
if (const Constant *C = dyn_cast<Constant>(V)) {
     }
   }
 
   // Add the value.
   Values.push_back(std::make_pair(V, 1U));
   ValueID = Values.size();
 }
 
+void ValueEnumerator::EnumerateComdat(const Comdat *C) {
+  // Check to see if it's already in!
+  unsigned &ComdatID = ComdatMap[C];
+  if (ComdatID) {
+    // Increment use count.
+    Comdats[ComdatID - 1].second++;
+    return;
+  }
+  Comdats.push_back(std::make_pair(C, 1U));
+  ComdatID = Comdats.size();
+}
 
 void ValueEnumerator::EnumerateType(Type *Ty) {
   unsigned *TypeID = &TypeMap[Ty];
 
   // We've already seen this type.
   if (*TypeID)
     return;
 

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 const MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
     const TargetMachine &TM) const {
   StringRef SectionName = GV->getSection();
 
   // Infer section flags from the section name if we can.
   Kind = getELFKindForNamedSection(SectionName, Kind);
 
+  StringRef Group = "";
+  unsigned Flags = getELFSectionFlags(Kind);
+  if (const Comdat *C = GV->getComdat()) {
+    if (C->getSelectionKind() != Comdat::Any)
+      report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
+                         C->getName() + "' cannot be lowered.");
+    Group = C->getName();
+    Flags |= ELF::SHF_GROUP;
+  }
   return getContext().getELFSection(SectionName,
-                                    getELFSectionType(SectionName, Kind),
-                                    getELFSectionFlags(Kind), Kind);
+                                    getELFSectionType(SectionName, Kind), Flags,
+                                    Kind, /*EntrySize=*/0, Group);
 }
 
 /// getSectionPrefixForGlobal - Return the section prefix name used by options
 /// FunctionsSections and DataSections.
-static const char *getSectionPrefixForGlobal(SectionKind Kind) {
+static StringRef getSectionPrefixForGlobal(SectionKind Kind) {
   if (Kind.isText())                 return ".text.";
   if (Kind.isReadOnly())             return ".rodata.";
   if (Kind.isBSS())                  return ".bss.";
 
   if (Kind.isThreadData())           return ".tdata.";
   if (Kind.isThreadBSS())            return ".tbss.";
 
   if (Kind.isDataNoRel())            return ".data.";
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
   bool EmitUniquedSection;
   if (Kind.isText())
     EmitUniquedSection = TM.getFunctionSections();
   else
     EmitUniquedSection = TM.getDataSections();
 
   // If this global is linkonce/weak and the target handles this by emitting it
   // into a 'uniqued' section name, create and return the section now.
-  if ((GV->isWeakForLinker() || EmitUniquedSection) &&
+  if ((GV->isWeakForLinker() || EmitUniquedSection || GV->hasComdat()) &&
       !Kind.isCommon()) {
-    const char *Prefix;
-    Prefix = getSectionPrefixForGlobal(Kind);
+    StringRef Prefix = getSectionPrefixForGlobal(Kind);
 
-    SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
+    SmallString<128> Name(Prefix);
     TM.getNameWithPrefix(Name, GV, Mang, true);
 
     StringRef Group = "";
     unsigned Flags = getELFSectionFlags(Kind);
-    if (GV->isWeakForLinker()) {
-      Group = Name.substr(strlen(Prefix));
+    if (GV->isWeakForLinker() || GV->hasComdat()) {
+      if (const Comdat *C = GV->getComdat()) {
+        if (C->getSelectionKind() != Comdat::Any)
+          report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
+                             C->getName() + "' cannot be lowered.");
+        Group = C->getName();
+      } else {
+        Group = Name.substr(Prefix.size());
+      }
       Flags |= ELF::SHF_GROUP;
     }
 
     return getContext().getELFSection(Name.str(),
                                       getELFSectionType(Name.str(), Kind),
                                       Flags, Kind, 0, Group);
   }
 

 
 const MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
     const TargetMachine &TM) const {
   // Parse the section specifier and create it if valid.
   StringRef Segment, Section;
   unsigned TAA = 0, StubSize = 0;
   bool TAAParsed;
+
+  if (const Comdat *C = GV->getComdat())
+    report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
+                       "' cannot be lowered.");
   std::string ErrorCode =
     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
                                           TAA, TAAParsed, StubSize);
   if (!ErrorCode.empty()) {
     // If invalid, report the error with report_fatal_error.
     report_fatal_error("Global variable '" + GV->getName() +
                        "' has an invalid section specifier '" +
                        GV->getSection() + "': " + ErrorCode + ".");
case MachO::S_INTERPOSING:
       return false;
     }
 }
 
 const MCSection *TargetLoweringObjectFileMachO::
 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
                        Mangler &Mang, const TargetMachine &TM) const {
 
+  if (const Comdat *C = GV->getComdat())
+    report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
+                       "' cannot be lowered.");
+
   // Handle thread local data.
   if (Kind.isThreadBSS()) return TLSBSSSection;
   if (Kind.isThreadData()) return TLSDataSection;
 
   if (Kind.isText())
     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
 
   // If this is weak/linkonce, put this in a coalescable section, either in text
else if (K.isWriteable())
     Flags |=
       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
       COFF::IMAGE_SCN_MEM_READ |
       COFF::IMAGE_SCN_MEM_WRITE;
 
   return Flags;
 }
 
+static int getSelectionForCOFF(const GlobalValue *GV) {
+  if (const Comdat *C = GV->getComdat()) {
+    if (C->getName() == GV->getName()) {
+      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::Newest:
+        return COFF::IMAGE_COMDAT_SELECT_NEWEST;
+      case Comdat::NoDuplicates:
+        return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
+      case Comdat::SameSize:
+        return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
+      }
+    } else {
+      return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
+    }
+  } else if (GV->isWeakForLinker()) {
+    return COFF::IMAGE_COMDAT_SELECT_ANY;
+  }
+  return 0;
+}
+
 const MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
     const TargetMachine &TM) const {
   int Selection = 0;
   unsigned Characteristics = getCOFFSectionFlags(Kind);
   StringRef Name = GV->getSection();
   StringRef COMDATSymName = "";
-  if (GV->isWeakForLinker()) {
-    Selection = COFF::IMAGE_COMDAT_SELECT_ANY;
-    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
-    MCSymbol *Sym = TM.getSymbol(GV, Mang);
+  if ((GV->isWeakForLinker() || GV->hasComdat()) && !Kind.isCommon()) {
+    Selection = getSelectionForCOFF(GV);
+    if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE ||
+        !GV->hasPrivateLinkage()) {
+      const GlobalValue *ComdatGV;
+      if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
+        StringRef ComdatGVName = GV->getComdat()->getName();
+        ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
+        if (!ComdatGV)
+          report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
+                             "' does not exist.");
+      } else {
+        ComdatGV = GV;
+      }
+      MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
       COMDATSymName = Sym->getName();
+      Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
+    } else {
+      Selection = 0;
+    }
   }
   return getContext().getCOFFSection(Name,
                                      Characteristics,
                                      Kind,
                                      COMDATSymName,
                                      Selection);
 }
 
if (Kind.isText())
     EmitUniquedSection = TM.getFunctionSections();
   else
     EmitUniquedSection = TM.getDataSections();
 
   // If this global is linkonce/weak and the target handles this by emitting it
   // into a 'uniqued' section name, create and return the section now.
   // Section names depend on the name of the symbol which is not feasible if the
   // symbol has private linkage.
-  if ((GV->isWeakForLinker() || EmitUniquedSection) &&
-      !GV->hasPrivateLinkage() && !Kind.isCommon()) {
+  if ((GV->isWeakForLinker() || EmitUniquedSection || GV->hasComdat()) &&
+      !Kind.isCommon()) {
     const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
     unsigned Characteristics = getCOFFSectionFlags(Kind);
 
     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
-    MCSymbol *Sym = TM.getSymbol(GV, Mang);
-    return getContext().getCOFFSection(
-        Name, Characteristics, Kind, Sym->getName(),
-        GV->isWeakForLinker() ? COFF::IMAGE_COMDAT_SELECT_ANY
-                              : COFF::IMAGE_COMDAT_SELECT_NODUPLICATES);
+    int Selection = getSelectionForCOFF(GV);
+    if (!Selection)
+      Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
+    if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE ||
+        !GV->hasPrivateLinkage()) {
+      const GlobalValue *ComdatGV;
+      if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
+        StringRef ComdatGVName = GV->getComdat()->getName();
+        ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
+        if (!ComdatGV)
+          report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
+                             "' does not exist.");
+      } else {
+        ComdatGV = GV;
+      }
+      MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
+      StringRef COMDATSymName = Sym->getName();
+      return getContext().getCOFFSection(Name, Characteristics, Kind,
+                                         COMDATSymName, Selection);
+    }
   }
 
   if (Kind.isText())
     return TextSection;
 
   if (Kind.isThreadLocal())
     return TLSDataSection;
 

lib/IR/AsmWriter.h

 #include "llvm/IR/TypeFinder.h"
 #include "llvm/Support/FormattedStream.h"
 
 namespace llvm {
 
 class BasicBlock;
 class Function;
 class GlobalValue;
+class Comdat;
 class Module;
 class NamedMDNode;
 class Value;
 class SlotTracker;
 
 /// Create a new SlotTracker for a Module 
 SlotTracker *createSlotTracker(const Module *M);
 
public:
 
   void writeAllMDNodes();
   void writeMDNode(unsigned Slot, const MDNode *Node);
   void writeAllAttributeGroups();
 
   void printTypeIdentities();
   void printGlobal(const GlobalVariable *GV);
   void printAlias(const GlobalAlias *GV);
+  void printComdat(const Comdat *C);
   void printFunction(const Function *F);
   void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx);
   void printBasicBlock(const BasicBlock *BB);
   void printInstructionLine(const Instruction &I);
   void printInstruction(const Instruction &I);
 
 private:
   void init();

lib/IR/AsmWriter.cpp

if (isprint(C) && C != '\\' && C != '"')
       Out << C;
     else
       Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
   }
 }
 
 enum PrefixType {
   GlobalPrefix,
+  ComdatPrefix,
   LabelPrefix,
   LocalPrefix,
   NoPrefix
 };
 
 /// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
 /// prefixed with % (if the string only contains simple characters) or is
 /// surrounded with ""'s (if it has special chars in it).  Print it out.
 static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
   assert(!Name.empty() && "Cannot get empty name!");
   switch (Prefix) {
   case NoPrefix: break;
   case GlobalPrefix: OS << '@'; break;
+  case ComdatPrefix: OS << '$'; break;
   case LabelPrefix:  break;
   case LocalPrefix:  OS << '%'; break;
   }
 
   // Scan the name to see if it needs quotes first.
   bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
   if (!NeedsQuotes) {
     for (unsigned i = 0, e = Name.size(); i != e; ++i) {
void TypePrinting::print(Type *Ty, raw_ostream &OS) {
   case Type::HalfTyID:      OS << "half"; return;
   case Type::FloatTyID:     OS << "float"; return;
   case Type::DoubleTyID:    OS << "double"; return;
   case Type::X86_FP80TyID:  OS << "x86_fp80"; return;
   case Type::FP128TyID:     OS << "fp128"; return;
   case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
   case Type::LabelTyID:     OS << "label"; return;
   case Type::MetadataTyID:  OS << "metadata"; return;
+  case Type::ComdatTyID:    OS << "comdat"; return;
+
   case Type::X86_MMXTyID:   OS << "x86_mmx"; return;
   case Type::IntegerTyID:
     OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
     return;
 
   case Type::FunctionTyID: {
     FunctionType *FTy = cast<FunctionType>(Ty);
     print(FTy->getReturnType(), OS);
if (!rest.empty()) {
       Out << "module asm \"";
       PrintEscapedString(rest, Out);
       Out << "\"\n";
     }
   }
 
   printTypeIdentities();
 
+  // Output all comdats.
+  if (!M->comdat_empty()) Out << '\n';
+  for (const Comdat &S : M->comdats()) {
+    printComdat(&S); Out << '\n';
+  }
+
   // Output all globals.
   if (!M->global_empty()) Out << '\n';
   for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
        I != E; ++I) {
     printGlobal(I); Out << '\n';
   }
 
   // Output all aliases.
if (GV->hasInitializer()) {
     writeOperand(GV->getInitializer(), false);
   }
 
   if (GV->hasSection()) {
     Out << ", section \"";
     PrintEscapedString(GV->getSection(), Out);
     Out << '"';
   }
+  if (GV->hasComdat()) {
+    Out << ", comdat ";
+    PrintLLVMName(Out, GV->getComdat()->getName(), ComdatPrefix);
+  }
   if (GV->getAlignment())
     Out << ", align " << GV->getAlignment();
 
   printInfoComment(*GV);
 }
 
 void AssemblyWriter::printAlias(const GlobalAlias *GA) {
   if (GA->isMaterializable())
void AssemblyWriter::printAlias(const GlobalAlias *GA) {
 
   if (!Aliasee) {
     TypePrinter.print(GA->getType(), Out);
     Out << " <<NULL ALIASEE>>";
   } else {
     writeOperand(Aliasee, !isa<ConstantExpr>(Aliasee));
   }
 
+  if (GA->hasComdat()) {
+    Out << ", comdat ";
+    PrintLLVMName(Out, GA->getComdat()->getName(), ComdatPrefix);
+  }
+
   printInfoComment(*GA);
   Out << '\n';
 }
 
+void AssemblyWriter::printComdat(const Comdat *C) {
+  PrintLLVMName(Out, C->getName(), ComdatPrefix);
+  Out << " = comdat ";
+
+  switch (C->getSelectionKind()) {
+  case Comdat::Any:          Out << "any";          break;
+  case Comdat::ExactMatch:   Out << "exactmatch";   break;
+  case Comdat::Largest:      Out << "largest";      break;
+  case Comdat::Newest:       Out << "newest";       break;
+  case Comdat::NoDuplicates: Out << "noduplicates"; break;
+  case Comdat::SameSize:     Out << "samesize";     break;
+  }
+
+  printInfoComment(*C);
+  Out << '\n';
+}
+
 void AssemblyWriter::printTypeIdentities() {
   if (TypePrinter.NumberedTypes.empty() &&
       TypePrinter.NamedTypes.empty())
     return;
 
   Out << '\n';
 
   // We know all the numbers that each type is used and we know that it is a
if (F->hasUnnamedAddr())
     Out << " unnamed_addr";
   if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
     Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
   if (F->hasSection()) {
     Out << " section \"";
     PrintEscapedString(F->getSection(), Out);
     Out << '"';
   }
+  if (F->hasComdat()) {
+    Out << " comdat ";
+    PrintLLVMName(Out, F->getComdat()->getName(), ComdatPrefix);
+  }
   if (F->getAlignment())
     Out << " align " << F->getAlignment();
   if (F->hasGC())
     Out << " gc \"" << F->getGC() << '"';
   if (F->hasPrefixData()) {
     Out << " prefix ";
     writeOperand(F->getPrefixData(), true);
   }
if (const Instruction *I = dyn_cast<Instruction>(this)) {
     SlotTracker SlotTable(GV->getParent());
     AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr);
     if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
       W.printGlobal(V);
     else if (const Function *F = dyn_cast<Function>(GV))
       W.printFunction(F);
     else
       W.printAlias(cast<GlobalAlias>(GV));
+  } else if (const auto *C = dyn_cast<Comdat>(this)) {
+    SlotTracker SlotTable(C->getParent());
+    AssemblyWriter W(OS, SlotTable, C->getParent(), nullptr);
+    W.printComdat(C);
   } else if (const MDNode *N = dyn_cast<MDNode>(this)) {
     const Function *F = N->getFunction();
     SlotTracker SlotTable(F);
     AssemblyWriter W(OS, SlotTable, F ? F->getParent() : nullptr, nullptr);
     W.printMDNodeBody(N);
   } else if (const Constant *C = dyn_cast<Constant>(this)) {
     TypePrinting TypePrinter;
     TypePrinter.print(C->getType(), OS);

lib/IR/CMakeLists.txt

 add_llvm_library(LLVMCore
   AsmWriter.cpp
   Attributes.cpp
   AutoUpgrade.cpp
   BasicBlock.cpp
+  Comdat.cpp
   ConstantFold.cpp
   ConstantRange.cpp
   Constants.cpp
   Core.cpp
   DIBuilder.cpp
   DataLayout.cpp
   DebugInfo.cpp
   DebugLoc.cpp

lib/IR/Comdat.cpp

+//===-- Comdat.cpp - Implement Metadata classes --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the Comdat class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/Comdat.h"
+#include "SymbolTableListTraitsImpl.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
+using namespace llvm;
+
+// Explicit instantiations of SymbolTableListTraits since some of the methods
+// are not in the public header file.
+template class llvm::SymbolTableListTraits<Comdat, Module>;
+
+Comdat::Comdat(SelectionKind SK, const Twine &Name, Module *M)
+    : Value(Type::getComdatTy(M->getContext()), Value::ComdatVal),
+      Parent(nullptr), SK(SK) {
+  setName(Name);
+  M->getComdatList().push_back(this);
+}
+
+Comdat::Comdat(SelectionKind SK, const Twine &Name, Comdat *InsertBefore)
+    : Value(Type::getComdatTy(InsertBefore->getParent()->getContext()),
+            Value::ComdatVal),
+      Parent(nullptr), SK(SK) {
+  setName(Name);
+  InsertBefore->getParent()->getComdatList().insert(InsertBefore, this);
+}
+
+Comdat::~Comdat() {}

lib/IR/Core.cpp

LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
   case Type::ArrayTyID:
     return LLVMArrayTypeKind;
   case Type::PointerTyID:
     return LLVMPointerTypeKind;
   case Type::VectorTyID:
     return LLVMVectorTypeKind;
   case Type::X86_MMXTyID:
     return LLVMX86_MMXTypeKind;
+  case Type::ComdatTyID:
+    return LLVMComdatTypeKind;
   }
   llvm_unreachable("Unhandled TypeID.");
 }
 
 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
 {
     return unwrap(Ty)->isSized();
 }

lib/IR/Function.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Function Implementation
 //===----------------------------------------------------------------------===//
 
 Function::Function(FunctionType *Ty, LinkageTypes Linkage,
                    const Twine &name, Module *ParentModule)
-  : GlobalObject(PointerType::getUnqual(Ty),
-                Value::FunctionVal, nullptr, 0, Linkage, name) {
+    : GlobalObject(PointerType::getUnqual(Ty), Value::FunctionVal,
+                   OperandTraits<Function>::op_begin(this), 0, Linkage, name) {
   assert(FunctionType::isValidReturnType(getReturnType()) &&
          "invalid return type");
   SymTab = new ValueSymbolTable();
 
   // If the function has arguments, mark them as lazily built.
   if (Ty->getNumParams())
     setValueSubclassData(1);   // Set the "has lazy arguments" bit.
 
Function::~Function() {
   delete SymTab;
 
   // Remove the function from the on-the-side GC table.
   clearGC();
 
   // Remove the intrinsicID from the Cache.
   if (getValueName() && isIntrinsic())
     getContext().pImpl->IntrinsicIDCache.erase(this);
+
+  NumOperands = 1; // FIXME: needed by operator delete
 }
 
 void Function::BuildLazyArguments() const {
   // Create the arguments vector, all arguments start out unnamed.
   FunctionType *FT = getFunctionType();
   for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
     assert(!FT->getParamType(i)->isVoidTy() &&
            "Cannot have void typed arguments!");

lib/IR/Globals.cpp

if (const GlobalObject *GO = getBaseObject(*GA->getAliasee()))
       return GO->getSection();
     return "";
   }
   return cast<GlobalObject>(this)->getSection();
 }
 
 void GlobalObject::setSection(StringRef S) { Section = S; }
 
+const Comdat *GlobalValue::getComdat() const {
+  if (isa<GlobalVariable>(this) || isa<GlobalAlias>(this))
+    return NumOperands > 1 ? cast<Comdat>(getOperand(1)) : nullptr;
+  return NumOperands > 0 ? cast<Function>(this)->getOperand(0) : nullptr;
+}
+void GlobalValue::setComdat(Comdat *C) {
+  if (isa<GlobalVariable>(this) || isa<GlobalAlias>(this)) {
+    // Comdats on declarations are semantically meaningless, ignore them.
+    if (isDeclaration())
+      return;
+    if (C) {
+      NumOperands = 2;
+      setOperand(1, C);
+    } else {
+      NumOperands = 1;
+    }
+  } else {
+    if (C) {
+      NumOperands = 1;
+      cast<Function>(this)->setOperand(0, C);
+    } else {
+      NumOperands = 0;
+    }
+  }
+}
+
 bool GlobalValue::isDeclaration() const {
   // Globals are definitions if they have an initializer.
   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
     return GV->getNumOperands() == 0;
 
   // Functions are definitions if they have a body.
   if (const Function *F = dyn_cast<Function>(this))
     return F->empty();
assert(isa<Constant>(To) &&
          "Attempt to replace GVar initializer with non-constant");
 
   // Okay, preconditions out of the way, replace the constant initializer.
   this->setOperand(0, cast<Constant>(To));
 }
 
 void GlobalVariable::setInitializer(Constant *InitVal) {
   if (!InitVal) {
+    if (hasComdat())
+      Op<1>().set(nullptr);
     if (hasInitializer()) {
       Op<0>().set(nullptr);
       NumOperands = 0;
     }
   } else {
     assert(InitVal->getType() == getType()->getElementType() &&
            "Initializer type must match GlobalVariable type");
     if (!hasInitializer())
-      NumOperands = 1;
+      NumOperands = hasComdat() ? 2 : 1;
     Op<0>().set(InitVal);
   }
 }
 
 /// copyAttributesFrom - copy all additional attributes (those not needed to
 /// create a GlobalVariable) from the GlobalVariable Src to this one.
 void GlobalVariable::copyAttributesFrom(const GlobalValue *Src) {
   assert(isa<GlobalVariable>(Src) && "Expected a GlobalVariable!");
   GlobalObject::copyAttributesFrom(Src);
   const GlobalVariable *SrcVar = cast<GlobalVariable>(Src);
   setThreadLocalMode(SrcVar->getThreadLocalMode());
 }
 
 
 //===----------------------------------------------------------------------===//
 // GlobalAlias Implementation
 //===----------------------------------------------------------------------===//
 
 GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
                          const Twine &Name, Constant *Aliasee,
                          Module *ParentModule)
     : GlobalValue(PointerType::get(Ty, AddressSpace), Value::GlobalAliasVal,
-                  &Op<0>(), 1, Link, Name) {
+                  OperandTraits<GlobalAlias>::op_begin(this), 1, Link, Name) {
   LeakDetector::addGarbageObject(this);
   Op<0>() = Aliasee;
 
   if (ParentModule)
     ParentModule->getAliasList().push_back(this);
 }
 
 GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,

lib/IR/LLVMContextImpl.h

ConstantUniqueMap<InlineAsmKeyType, const InlineAsmKeyType&, PointerType,
                     InlineAsm> InlineAsms;
   
   ConstantInt *TheTrueVal;
   ConstantInt *TheFalseVal;
   
   LeakDetectorImpl<Value> LLVMObjects;
   
   // Basic type instances.
-  Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy;
+  Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, ComdatTy;
   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty;
 
   
   /// TypeAllocator - All dynamically allocated types are allocated from this.
   /// They live forever until the context is torn down.
   BumpPtrAllocator TypeAllocator;
   

lib/IR/LLVMContextImpl.cpp

 LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
   : TheTrueVal(nullptr), TheFalseVal(nullptr),
     VoidTy(C, Type::VoidTyID),
     LabelTy(C, Type::LabelTyID),
     HalfTy(C, Type::HalfTyID),
     FloatTy(C, Type::FloatTyID),
     DoubleTy(C, Type::DoubleTyID),
     MetadataTy(C, Type::MetadataTyID),
+    ComdatTy(C, Type::ComdatTyID),
     X86_FP80Ty(C, Type::X86_FP80TyID),
     FP128Ty(C, Type::FP128TyID),
     PPC_FP128Ty(C, Type::PPC_FP128TyID),
     X86_MMXTy(C, Type::X86_MMXTyID),
     Int1Ty(C, 1),
     Int8Ty(C, 8),
     Int16Ty(C, 16),
     Int32Ty(C, 32),

lib/IR/Module.cpp

 
 //===----------------------------------------------------------------------===//
 // Primitive Module methods.
 //
 
 Module::Module(StringRef MID, LLVMContext &C)
     : Context(C), Materializer(), ModuleID(MID), DL("") {
   ValSymTab = new ValueSymbolTable();
+  ComdatSymTab = new ValueSymbolTable();
   NamedMDSymTab = new StringMap<NamedMDNode *>();
   Context.addModule(this);
 }
 
 Module::~Module() {
   Context.removeModule(this);
   dropAllReferences();
   GlobalList.clear();
   FunctionList.clear();
   AliasList.clear();
+  ComdatList.clear();
   NamedMDList.clear();
   delete ValSymTab;
+  delete ComdatSymTab;
   delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
 }
 
 /// getNamedValue - Return the first global value in the module with
 /// the specified name, of arbitrary type.  This method returns null
 /// if a global with the specified name is not found.
 GlobalValue *Module::getNamedValue(StringRef Name) const {
   return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));

 }
 
 unsigned Module::getDwarfVersion() const {
   Value *Val = getModuleFlag("Dwarf Version");
   if (!Val)
     return dwarf::DWARF_VERSION;
   return cast<ConstantInt>(Val)->getZExtValue();
 }
+
+ValueSymbolTable *ilist_traits<Comdat>::getSymTab(Module *M) {
+  return M ? &M->getComdatSymbolTable() : nullptr;
+}

lib/IR/Type.cpp

Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) {
   case HalfTyID      : return getHalfTy(C);
   case FloatTyID     : return getFloatTy(C);
   case DoubleTyID    : return getDoubleTy(C);
   case X86_FP80TyID  : return getX86_FP80Ty(C);
   case FP128TyID     : return getFP128Ty(C);
   case PPC_FP128TyID : return getPPC_FP128Ty(C);
   case LabelTyID     : return getLabelTy(C);
   case MetadataTyID  : return getMetadataTy(C);
+  case ComdatTyID    : return getComdatTy(C);
   case X86_MMXTyID   : return getX86_MMXTy(C);
   default:
     return nullptr;
   }
 }
 
 /// getScalarType - If this is a vector type, return the element type,
 /// otherwise return this.

 //===----------------------------------------------------------------------===//
 
 Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
 Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
 Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
 Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
+Type *Type::getComdatTy(LLVMContext &C) { return &C.pImpl->ComdatTy; }
 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
 Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
 
 IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
 IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
 IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }

 FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
   return get(Result, None, isVarArg);
 }
 
 /// isValidReturnType - Return true if the specified type is valid as a return
 /// type.
 bool FunctionType::isValidReturnType(Type *RetTy) {
   return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
-  !RetTy->isMetadataTy();
+         !RetTy->isMetadataTy() && !RetTy->isComdatTy();
 }
 
 /// isValidArgumentType - Return true if the specified type is valid as an
 /// argument type.
 bool FunctionType::isValidArgumentType(Type *ArgTy) {
   return ArgTy->isFirstClassType();
 }
 
while (type) {
     StructFields.push_back(type);
     type = va_arg(ap, llvm::Type*);
   }
   setBody(StructFields);
 }
 
 bool StructType::isValidElementType(Type *ElemTy) {
   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
-         !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy();
+         !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
+         !ElemTy->isComdatTy();
 }
 
 /// isLayoutIdentical - Return true if this is layout identical to the
 /// specified struct.
 bool StructType::isLayoutIdentical(StructType *Other) const {
   if (this == Other) return true;
   
   if (isPacked() != Other->isPacked() ||
ArrayType *ArrayType::get(Type *elementType, uint64_t NumElements) {
 
   if (!Entry)
     Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements);
   return Entry;
 }
 
 bool ArrayType::isValidElementType(Type *ElemTy) {
   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
-         !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy();
+         !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
+         !ElemTy->isComdatTy();
 }
 
 //===----------------------------------------------------------------------===//
 //                          VectorType Implementation
 //===----------------------------------------------------------------------===//
 
 VectorType::VectorType(Type *ElType, unsigned NumEl)
   : SequentialType(VectorTyID, ElType) {

lib/IR/Value.cpp

if (Instruction *I = dyn_cast<Instruction>(V)) {
     if (Function *P = BB->getParent())
       ST = &P->getValueSymbolTable();
   } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
     if (Module *P = GV->getParent())
       ST = &P->getValueSymbolTable();
   } else if (Argument *A = dyn_cast<Argument>(V)) {
     if (Function *P = A->getParent())
       ST = &P->getValueSymbolTable();
+  } else if (Comdat *C = dyn_cast<Comdat>(V)) {
+    if (Module *P = C->getParent())
+      ST = &P->getComdatSymbolTable();
   } else if (isa<MDString>(V))
     return true;
   else {
     assert(isa<Constant>(V) && "Unknown value type!");
     return true;  // no name is setable for this.
   }
   return false;
 }

test/Feature/comdat.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+$f = comdat any
+; CHECK: $f = comdat any
+
+@v = global i32 0, comdat $f
+; CHECK: @v = global i32 0, comdat $f
+@a = alias i32* @v, comdat $f
+; CHECK: @a = alias i32* @v, comdat $f
+
+define void @f() comdat $f {
+  ret void
+}
+; CHECK: define void @f() comdat $f

test/Instrumentation/AddressSanitizer/do-not-instrument-llvm-metadata.ll

 ; This test checks that we are not instrumenting globals in llvm.metadata.
 ; RUN: opt < %s -asan -asan-module -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @.str_noinst = private unnamed_addr constant [4 x i8] c"aaa\00", section "llvm.metadata"
-@.str_inst = private unnamed_addr constant [4 x i8] c"aaa\00",
+@.str_inst = private unnamed_addr constant [4 x i8] c"aaa\00"
 
 ; CHECK-NOT: {{asan_gen.*str_noinst}}
 ; CHECK: {{asan_gen.*str_inst}}
 ; CHECK: @asan.module_ctor

test/MC/COFF/comdat.ll

+; RUN: llc -mtriple i386-pc-win32 < %s | FileCheck %s
+
+$f1 = comdat any
+@v1 = global i32 0, comdat $f1
+define void @f1() comdat $f1 {
+  ret void
+}
+
+$f2 = comdat exactmatch
+@v2 = global i32 0, comdat $f2
+define void @f2() comdat $f2 {
+  ret void
+}
+
+$f3 = comdat largest
+@v3 = global i32 0, comdat $f3
+define void @f3() comdat $f3 {
+  ret void
+}
+
+$f4 = comdat newest
+@v4 = global i32 0, comdat $f4
+define void @f4() comdat $f4 {
+  ret void
+}
+
+$f5 = comdat noduplicates
+@v5 = global i32 0, comdat $f5
+define void @f5() comdat $f5 {
+  ret void
+}
+
+$f6 = comdat samesize
+@v6 = global i32 0, comdat $f6
+define void @f6() comdat $f6 {
+  ret void
+}
+
+; CHECK: .section        .text,"xr",discard,_f1
+; CHECK: .globl  _f1
+; CHECK: .section        .text,"xr",same_contents,_f2
+; CHECK: .globl  _f2
+; CHECK: .section        .text,"xr",largest,_f3
+; CHECK: .globl  _f3
+; CHECK: .section        .text,"xr",newest,_f4
+; CHECK: .globl  _f4
+; CHECK: .section        .text,"xr",one_only,_f5
+; CHECK: .globl  _f5
+; CHECK: .section        .text,"xr",same_size,_f6
+; CHECK: .globl  _f6
+; CHECK: .section        .bss,"bw",associative,_f1
+; CHECK: .globl  _v1
+; CHECK: .section        .bss,"bw",associative,_f2
+; CHECK: .globl  _v2
+; CHECK: .section        .bss,"bw",associative,_f3
+; CHECK: .globl  _v3
+; CHECK: .section        .bss,"bw",associative,_f4
+; CHECK: .globl  _v4
+; CHECK: .section        .bss,"bw",associative,_f5
+; CHECK: .globl  _v5
+; CHECK: .section        .bss,"bw",associative,_f6
+; CHECK: .globl  _v6

test/MC/ELF/comdat.ll

+; RUN: llc -mtriple x86_64-pc-linux-gnu < %s | FileCheck %s
+
+$f = comdat any
+@v = global i32 0, comdat $f
+define void @f() comdat $f {
+  ret void
+}
+; CHECK: .section        .text.f,"axG",@progbits,f,comdat
+; CHECK: .globl  f
+; CHECK: .section        .bss.v,"aGw",@nobits,f,comdat
+; CHECK: .globl  v

test/MC/MachO/comdat.ll

+; RUN: not llc -mtriple x86_64-apple-darwin < %s 2> %t
+; RUN: FileCheck < %t %s
+
+$f = comdat any
+@v = global i32 0, comdat $f
+; CHECK: LLVM ERROR: MachO doesn't support COMDATs, 'f' cannot be lowered.