[llvm] API for encoding/decoding DWARF discriminators.

[mtrofin]

Summary

Added a pair of APIs for encoding/decoding the 3 components of a DWARF discriminator described in http://lists.llvm.org/pipermail/llvm-dev/2016-October/106532.html: the base discriminator, the duplication factor (useful in profile-guided optimization) and the copy index (used to identify copies of code in cases like loop unrolling)

The encoding packs 3 unsigned values in 32 bits. This CL addresses 2 issues:

• communicates overflow back to the user
• supports encoding all 3 components together. Current APIs assume a sequencing of events. For example, creating a new discriminator based on an existing one by changing the base discriminator was not supported.

[mtrofin]

• Remove unrelated changes (clang-format)

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

1607

Could you please move all the implementations to DebugInfoMetadata.cpp ?

[mtrofin]

• Moved implementation of new APIs to DebugInfoMetadata.cpp.

[mtrofin]

include/llvm/IR/DebugInfoMetadata.h

1607

Thanks - I assume you were referring to the new encode/decode pair.

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

35

Is this still needed?

[mtrofin]

• Adjust includes

[mtrofin]

Gentle reminder - thanks!

[wmi]

LGTM from my limited knowledge on discriminator. I added dblaikie to help on the review.

lib/IR/DebugInfoMetadata.cpp

140–141 ↗

(On Diff #178294)

Maybe make the comment more explicitly that encode may fail due to overflow of certain component. Currently the overflow failure is detected by checking the equivalence of all the components before encoding and after decoding.

[mtrofin]

• Improved comments.

[dblaikie]

Might be worth having a summary of the goals here (rather than only by reference to the design discussion thread) for review and later as commit history, etc.

include/llvm/IR/DebugInfoMetadata.h

1656–1657

Would Expected<unsigned> or Optional<unsigned> be more suitable here rather than using a bool as an out parameter to report errors?

[mtrofin]

• Returning Optional<unsigned>

[mtrofin]

include/llvm/IR/DebugInfoMetadata.h

1656–1657

Done - also adjusted current APIs for consistency.

[mtrofin]

ptal - thanks!

[dblaikie]

Not sure I'm following this all in detail & at least for me (someone not super familiar with the details here) it might've been a bit easier to review in smaller pieces (breaking up the refactoring to generalize the components of the discriminator into smaller bits, etc) but all good. Thanks!

include/llvm/IR/DebugInfoMetadata.h

2093–2094

You could roll the variable declaration into the condition:

if (Optional<unsigned> D = ...)

2095

If you like, you can use *D instead of D.getValue()

lib/IR/DebugInfoMetadata.cpp

152–155 ↗

(On Diff #179015)

Perhaps these should call getBaseDiscriminatorFromDiscriminator, getDuplicationFactorFromDiscriminator, getCopyIdentifierFromDiscriminator?

(though it looks like getDuplicationFactorFromdiscriminator has some extra logic that isn't in the initialization for DF here in decodeDiscriminator - is that a bug that these two cases are handled differently?)

lib/Target/X86/X86DiscriminateMemOps.cpp

140

I'd probably drop the top level 'const' here (since it's a value rather than a reference - LLVM doesn't usually use top level const like this)

[mtrofin]

• Remove unrelated changes (clang-format)
• Moved implementation of new APIs to DebugInfoMetadata.cpp.
• Adjust includes
• Improved comments.
• Returning Optional<unsigned>
• Feedback

[mtrofin]

lib/IR/DebugInfoMetadata.cpp

152–155 ↗

(On Diff #179015)

Yes, the current APIs are a bit special-casing. I decided to leave them as-is, and just offer decodeDiscriminator as access to the raw data.

lib/Target/X86/X86DiscriminateMemOps.cpp

140

I wanted to make sure no mutation happens through the iterator. I'll remove it for consistency though.

include/llvm/IR/DebugInfoMetadata.h

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
+#include <numeric>
 #include <type_traits>
 #include <vector>
 
 // Helper macros for defining get() overrides.
 #define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
 #define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
 #define DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)              \
   static CLASS *getDistinct(LLVMContext &Context,                              \
class DILocation : public MDNode {
   /// new_bit_6 is 0 if higher bits (7~13) are all 0
   static unsigned getPrefixEncodingFromUnsigned(unsigned U) {
     U &= 0xfff;
     return U > 0x1f ? (((U & 0xfe0) << 1) | (U & 0x1f) | 0x20) : U;
   }
 
   /// Reverse transformation as getPrefixEncodingFromUnsigned.
   static unsigned getUnsignedFromPrefixEncoding(unsigned U) {
+    if (U & 1)
+      return 0;
+    U >>= 1;
     return (U & 0x20) ? (((U >> 1) & 0xfe0) | (U & 0x1f)) : (U & 0x1f);
   }
 
   /// Returns the next component stored in discriminator.
   static unsigned getNextComponentInDiscriminator(unsigned D) {
     if ((D & 1) == 0)
       return D >> ((D & 0x40) ? 14 : 7);
     else
       return D >> 1;
   }
 
   TempDILocation cloneImpl() const {
     // Get the raw scope/inlinedAt since it is possible to invoke this on
     // a DILocation containing temporary metadata.
     return getTemporary(getContext(), getLine(), getColumn(), getRawScope(),
                         getRawInlinedAt(), isImplicitCode());
   }
 
+  static unsigned encodeComponent(unsigned C) {
+    return (C == 0) ? 1U : (getPrefixEncodingFromUnsigned(C) << 1);
+  }
+
+  static unsigned encodingBits(unsigned C) {
+    return (C == 0) ? 1 : (C > 0x1f ? 14 : 7);
+  }
+
 public:
   // Disallow replacing operands.
   void replaceOperandWith(unsigned I, Metadata *New) = delete;
 
   DEFINE_MDNODE_GET(DILocation,
                     (unsigned Line, unsigned Column, Metadata *Scope,
                      Metadata *InlinedAt = nullptr, bool ImplicitCode = false),
                     (Line, Column, Scope, InlinedAt, ImplicitCode))
public:
   ///                  Each copy of the IR will be assigned an identifier.
   ///
   /// Encoding:
   ///
   /// The above 3 components are encoded into a 32bit unsigned integer in
   /// order. If the lowest bit is 1, the current component is empty, and the
   /// next component will start in the next bit. Otherwise, the current
   /// component is non-empty, and its content starts in the next bit. The
-  /// length of each components is either 5 bit or 12 bit: if the 7th bit
+  /// value of each components is either 5 bit or 12 bit: if the 7th bit
   /// is 0, the bit 2~6 (5 bits) are used to represent the component; if the
   /// 7th bit is 1, the bit 2~6 (5 bits) and 8~14 (7 bits) are combined to
-  /// represent the component.
+  /// represent the component. Thus, the number of bits used for a component
+  /// is either 0 (if it and all the next components are empty); 1 - if it is
+  /// empty; 7 - if its value is up to and including 0x1f (lsb and msb are both
+  /// 0); or 14, if its value is up to and including 0x1ff. Note that the last
+  /// component is also capped at 0x1ff, even in the case when both first
+  /// components are 0, and we'd technically have 29 bits available.
+  ///
+  /// For precise control over the data being encoded in the discriminator,
+  /// use encodeDiscriminator/decodeDiscriminator.
+  ///
+  /// Use {get|set}BaseDiscriminator and cloneWithDuplicationFactor after reading
+  /// their documentation, as their behavior has side-effects.
 
   inline unsigned getDiscriminator() const;
 
   /// Returns a new DILocation with updated \p Discriminator.
   inline const DILocation *cloneWithDiscriminator(unsigned Discriminator) const;
 
-  /// Returns a new DILocation with updated base discriminator \p BD.
+  /// Returns a new DILocation with updated base discriminator \p BD. Only the
+  /// base discriminator is set in the new DILocation, the other encoded values
+  /// are elided.
+  /// Inability to encode a new discriminator is ignored.
   inline const DILocation *setBaseDiscriminator(unsigned BD) const;
 
-  /// Returns the duplication factor stored in the discriminator.
+  /// Returns the duplication factor stored in the discriminator, or 1 if no
+  /// duplication factor (or 0) is encoded.
   inline unsigned getDuplicationFactor() const;
 
   /// Returns the copy identifier stored in the discriminator.
   inline unsigned getCopyIdentifier() const;
 
   /// Returns the base discriminator stored in the discriminator.
   inline unsigned getBaseDiscriminator() const;
 
-  /// Returns a new DILocation with duplication factor \p DF encoded in the
-  /// discriminator.
+  /// Returns a new DILocation with duplication factor \p DF * current
+  /// duplication factor encoded in the discriminator. The current duplication
+  /// factor is as defined by getDuplicationFactor().
+  /// Inability to encode a new discriminator is ignored.
   inline const DILocation *cloneWithDuplicationFactor(unsigned DF) const;
 
   /// When two instructions are combined into a single instruction we also
   /// need to combine the original locations into a single location.
   ///
   /// When the locations are the same we can use either location. When they
   /// differ, we need a third location which is distinct from either. If they
   /// have the same file/line but have a different discriminator we could
   /// create a location with a new discriminator. If they are from different
   /// files/lines the location is ambiguous and can't be represented in a line
   /// entry. In this case, if \p GenerateLocation is true, we will set the
   /// merged debug location as line 0 of the nearest common scope where the two
   /// locations are inlined from.
   ///
   /// \p GenerateLocation: Whether the merged location can be generated when
   /// \p LocA and \p LocB differ.
   static const DILocation *getMergedLocation(const DILocation *LocA,
                                              const DILocation *LocB);
 
   /// Returns the base discriminator for a given encoded discriminator \p D.
   static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
-    if ((D & 1) == 0)
-      return getUnsignedFromPrefixEncoding(D >> 1);
-    else
-      return 0;
+    return getUnsignedFromPrefixEncoding(D);
+  }
+
+  /// Raw encoding of the discriminator. APIs such as setBaseDiscriminator or
+  /// cloneWithDuplicationFactor have certain side-effects. This API, in
+  /// conjunction with cloneWithDiscriminator, may be used to encode precisely
+  /// the values provided. \p BD: base discriminator \p DF: duplication factor
+  /// \p CI: copy index
+  /// \p Success is false if the values cannot be encoded in 32 bits - for
+  /// example, values for BD or DF larger than 12 bits. Returns the encoded
+  /// value.
+  static unsigned encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI,
+                                      bool &Success) {
+    SmallVector<unsigned, 3> Components = {BD, DF, CI};
+    uint64_t RemainingWork = 0U;
+    // We use RemainingWork to figure out if we have no remaining components to
+    // encode. For example: if BD != 0 but DF == 0 && CI == 0, we don't need to
+    // encode anything for the latter 2.
+    // Since any of the input components is at most 32 bits, their sum will be
+    // less than 34 bits, and thus RemainingWork won't overflow.
+    RemainingWork = std::accumulate(Components.begin(), Components.end(), RemainingWork);
+
+    int I = 0;
+    unsigned Ret = 0;
+    unsigned NextBitInsertionIndex = 0;
+    while (RemainingWork > 0) {
+      unsigned C = Components[I++];
+      RemainingWork -= C;
+      unsigned EC = encodeComponent(C);
+      Ret |= (EC << NextBitInsertionIndex);
+      NextBitInsertionIndex += encodingBits(C);
+    }
+
+    // Alternatively, we could determine Success during encoding, but the alternative
+    // here is simpler to understand.
+    unsigned TBD, TDF, TCI = 0;
+    decodeDiscriminator(Ret, TBD, TDF, TCI);
+    Success = TBD == BD && TDF == DF && TCI == CI;
+    return Ret;
+  }
+
+  /// Raw decoder for values in an encoded discriminator D.
+  static void decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF,
+                                  unsigned &CI) {
+    BD = getUnsignedFromPrefixEncoding(D);
+    DF = getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(D));
+    CI = getUnsignedFromPrefixEncoding(
+        getNextComponentInDiscriminator(getNextComponentInDiscriminator(D)));
   }
 
-  /// Returns the duplication factor for a given encoded discriminator \p D.
+  /// Returns the duplication factor for a given encoded discriminator \p D, or
+  /// 1 if no value or 0 is encoded.
   static unsigned getDuplicationFactorFromDiscriminator(unsigned D) {
     D = getNextComponentInDiscriminator(D);
-    if (D == 0 || (D & 1))
+    unsigned Ret = getUnsignedFromPrefixEncoding(D);
+    if (Ret == 0)
       return 1;
-    else
-      return getUnsignedFromPrefixEncoding(D >> 1);
+    return Ret;
   }
 
   /// Returns the copy identifier for a given encoded discriminator \p D.
   static unsigned getCopyIdentifierFromDiscriminator(unsigned D) {
     return getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(
         getNextComponentInDiscriminator(D)));
   }
 
 
   Metadata *getRawScope() const { return getOperand(0); }
   Metadata *getRawInlinedAt() const {
     if (getNumOperands() == 2)
       return getOperand(1);

 unsigned DILocation::getCopyIdentifier() const {
   return getCopyIdentifierFromDiscriminator(getDiscriminator());
 }
 
 const DILocation *DILocation::setBaseDiscriminator(unsigned D) const {
   if (D == 0)
     return this;
   else
-    return cloneWithDiscriminator(getPrefixEncodingFromUnsigned(D) << 1);
+    return cloneWithDiscriminator(encodeComponent(D));
 }
 
 const DILocation *DILocation::cloneWithDuplicationFactor(unsigned DF) const {
   DF *= getDuplicationFactor();
   if (DF <= 1)
     return this;
 
   unsigned BD = getBaseDiscriminator();
-  unsigned CI = getCopyIdentifier() << (DF > 0x1f ? 14 : 7);
-  unsigned D = CI | (getPrefixEncodingFromUnsigned(DF) << 1);
-
-  if (BD == 0)
-    D = (D << 1) | 1;
-  else
-    D = (D << (BD > 0x1f ? 14 : 7)) | (getPrefixEncodingFromUnsigned(BD) << 1);
-
+  unsigned CI = getCopyIdentifier();
+  bool Success;
+  unsigned D = encodeDiscriminator(BD, DF, CI, Success);
   return cloneWithDiscriminator(D);
 }
 
 class DINamespace : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned ExportSymbols : 1;
 
   DINamespace(LLVMContext &Context, StorageType Storage, bool ExportSymbols,
               ArrayRef<Metadata *> Ops)
       : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace,

lib/Target/X86/X86DiscriminateMemOps.cpp

 #include "X86InstrBuilder.h"
 #include "X86InstrInfo.h"
 #include "X86MachineFunctionInfo.h"
 #include "X86Subtarget.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/ProfileData/SampleProfReader.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Transforms/IPO/SampleProfile.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "x86-discriminate-memops"
 
 namespace {
 
 using Location = std::pair<StringRef, unsigned>;
bool X86DiscriminateMemOps::runOnMachineFunction(MachineFunction &MF) {
   for (auto &MBB : MF) {
     for (auto &MI : MBB) {
       if (X86II::getMemoryOperandNo(MI.getDesc().TSFlags) < 0)
         continue;
       const DILocation *DI = MI.getDebugLoc();
       if (!DI) {
         DI = ReferenceDI;
       }
-      DenseSet<unsigned> &Set = Seen[diToLocation(DI)];
+      Location L = diToLocation(DI);
+      DenseSet<unsigned> &Set = Seen[L];
       const std::pair<DenseSet<unsigned>::iterator, bool> TryInsert =
           Set.insert(DI->getBaseDiscriminator());
       if (!TryInsert.second) {
-        DI = DI->setBaseDiscriminator(++MemOpDiscriminators[diToLocation(DI)]);
-        updateDebugInfo(&MI, DI);
-        Changed = true;
-        const std::pair<DenseSet<unsigned>::iterator, bool> MustInsert =
-            Set.insert(DI->getBaseDiscriminator());
-        // FIXME (mtrofin): check if the to-be inserted base discriminator can
-        // be added. This requires a new API on DILocation.
-        // The assumption is that this scenario is infrequent/OK not to support.
-        // If evidence points otherwise, we can explore synthesize unique DIs by
-        // adding fake line numbers.
-        if (!MustInsert.second) {
-          LLVM_DEBUG(dbgs()
-                     << "Unable to create a unique discriminator in "
+        bool EncodingSucceeded = false;
+        unsigned BF, DF, CI = 0;
+        DILocation::decodeDiscriminator(DI->getDiscriminator(), BF, DF, CI);
+        unsigned EncodedDiscriminator = DILocation::encodeDiscriminator(
+            MemOpDiscriminators[L] + 1, DF, CI,
+            EncodingSucceeded);
+
+        if (!EncodingSucceeded) {
+          // FIXME(mtrofin): The assumption is that this scenario is infrequent/OK
+          // not to support. If evidence points otherwise, we can explore synthesizeing
+          // unique DIs by adding fake line numbers, or by constructing 64 bit
+          // discriminators.
+          LLVM_DEBUG(dbgs() << "Unable to create a unique discriminator "
+                     "for instruction with memory operand in: "
                      << DI->getFilename() << " Line: " << DI->getLine()
                      << " Column: " << DI->getColumn()
-                     << ". This is likely due to a large macro expansion.\n");
+                     << ". This is likely due to a large macro expansion. \n");
+          continue;
         }
+        // Since we were able to encode, bump the MemOpDiscriminators.
+        ++MemOpDiscriminators[L];
+        DI = DI->cloneWithDiscriminator(EncodedDiscriminator);
+        updateDebugInfo(&MI, DI);
+        Changed = true;
+        const std::pair<DenseSet<unsigned>::iterator, bool> MustInsert =
+            Set.insert(DI->getBaseDiscriminator());
+        assert(MustInsert.second && "New discriminator shouldn't be present in set");
       }
 
       // Bump the reference DI to avoid cramming discriminators on line 0.
       // FIXME(mtrofin): pin ReferenceDI on blocks or first instruction with DI
       // in a block. It's more consistent than just relying on the last memop
       // instruction we happened to see.
       ReferenceDI = DI;
     }
   }
   return Changed;
 }
 
 FunctionPass *llvm::createX86DiscriminateMemOpsPass() {
   return new X86DiscriminateMemOps();
 }

unittests/IR/MetadataTest.cpp

 TEST_F(DILocationTest, cloneTemporary) {
   MDNode *N = MDNode::get(Context, None);
   auto L = DILocation::getTemporary(Context, 2, 7, N);
   EXPECT_TRUE(L->isTemporary());
   auto L2 = L->clone();
   EXPECT_TRUE(L2->isTemporary());
 }
 
+TEST_F(DILocationTest, discriminatorEncoding) {
+  bool Success = false;
+  EXPECT_EQ(0U, DILocation::encodeDiscriminator(0, 0, 0, Success));
+  EXPECT_TRUE(Success);
+
+  // Encode base discriminator as a component: lsb is 0, then the value.
+  // The other components are all absent, so we leave all the other bits 0.
+  EXPECT_EQ(2U, DILocation::encodeDiscriminator(1, 0, 0, Success));
+  EXPECT_TRUE(Success);
+
+  // Base discriminator component is empty, so lsb is 1. Next component is not
+  // empty, so its lsb is 0, then its value (1). Next component is empty.
+  // So the bit pattern is 101.
+  EXPECT_EQ(5U, DILocation::encodeDiscriminator(0, 1, 0, Success));
+  EXPECT_TRUE(Success);
+
+  // First 2 components are empty, so the bit pattern is 11. Then the
+  // next component - ending up with 1011.
+  EXPECT_EQ(0xbU, DILocation::encodeDiscriminator(0, 0, 1, Success));
+  EXPECT_TRUE(Success);
+
+  // The bit pattern for the first 2 components is 11. The next bit is 0,
+  // because the last component is not empty. We have 29 bits usable for
+  // encoding, but we cap it at 12 bits uniformously for all components. We
+  // encode the last component over 14 bits.
+  EXPECT_EQ(0xfffbU, DILocation::encodeDiscriminator(0, 0, 0xfff, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0x102U, DILocation::encodeDiscriminator(1, 1, 0, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0x13eU, DILocation::encodeDiscriminator(0x1f, 1, 0, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0x87feU, DILocation::encodeDiscriminator(0x1ff, 1, 0, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0x1f3eU, DILocation::encodeDiscriminator(0x1f, 0x1f, 0, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0x3ff3eU, DILocation::encodeDiscriminator(0x1f, 0x1ff, 0, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0x1ff87feU,
+            DILocation::encodeDiscriminator(0x1ff, 0x1ff, 0, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0xfff9f3eU,
+            DILocation::encodeDiscriminator(0x1f, 0x1f, 0xfff, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0xffc3ff3eU,
+            DILocation::encodeDiscriminator(0x1f, 0x1ff, 0x1ff, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0xffcf87feU,
+            DILocation::encodeDiscriminator(0x1ff, 0x1f, 0x1ff, Success));
+  EXPECT_TRUE(Success);
+
+  EXPECT_EQ(0xe1ff87feU,
+            DILocation::encodeDiscriminator(0x1ff, 0x1ff, 7, Success));
+  EXPECT_TRUE(Success);
+}
+
+TEST_F(DILocationTest, discriminatorEncodingNegativeTests) {
+  bool Success = false;
+  DILocation::encodeDiscriminator(0, 0, 0x1000, Success);
+  EXPECT_FALSE(Success);
+
+  DILocation::encodeDiscriminator(0x1000, 0, 0, Success);
+  EXPECT_FALSE(Success);
+
+  DILocation::encodeDiscriminator(0, 0x1000, 0, Success);
+  EXPECT_FALSE(Success);
+
+  DILocation::encodeDiscriminator(0, 0, 0x1000, Success);
+  EXPECT_FALSE(Success);
+
+  DILocation::encodeDiscriminator(0x1ff, 0x1ff, 8, Success);
+  EXPECT_FALSE(Success);
+
+  DILocation::encodeDiscriminator(std::numeric_limits<uint32_t>::max(),
+                                  std::numeric_limits<uint32_t>::max(),
+                                  0, Success);
+  EXPECT_FALSE(Success);
+}
+
+TEST_F(DILocationTest, discriminatorSpecialCases) {
+  // We don't test getCopyIdentifier here because the only way
+  // to set it is by constructing an encoded discriminator using
+  // encodeDiscriminator, which is already tested.
+  auto L1 = DILocation::get(Context, 1, 2, getSubprogram());
+  EXPECT_EQ(0U, L1->getBaseDiscriminator());
+  EXPECT_EQ(1U, L1->getDuplicationFactor());
+
+  auto L2 = L1->setBaseDiscriminator(1);
+  EXPECT_EQ(0U, L1->getBaseDiscriminator());
+  EXPECT_EQ(1U, L1->getDuplicationFactor());
+
+  EXPECT_EQ(1U, L2->getBaseDiscriminator());
+  EXPECT_EQ(1U, L2->getDuplicationFactor());
+
+  auto L3 = L2->cloneWithDuplicationFactor(2);
+  EXPECT_EQ(1U, L3->getBaseDiscriminator());
+  EXPECT_EQ(2U, L3->getDuplicationFactor());
+
+  auto L4 = L3->cloneWithDuplicationFactor(4);
+  EXPECT_EQ(1U, L4->getBaseDiscriminator());
+  EXPECT_EQ(8U, L4->getDuplicationFactor());
+
+  auto L5 = L4->setBaseDiscriminator(2);
+  EXPECT_EQ(2U, L5->getBaseDiscriminator());
+  EXPECT_EQ(1U, L5->getDuplicationFactor());
+}
+
+
 typedef MetadataTest GenericDINodeTest;
 
 TEST_F(GenericDINodeTest, get) {
   StringRef Header = "header";
   auto *Empty = MDNode::get(Context, None);
   Metadata *Ops1[] = {Empty};
   auto *N = GenericDINode::get(Context, 15, Header, Ops1);
   EXPECT_EQ(15u, N->getTag());