Add support for multiple prof metadata on instructions.

[hjyamauchi]

Summary

An instruction can currently have up to one prof metadata type associated with
it. It's useful to be able to have more than one prof metadata associated with
an instruction, going forward.

This patch introduces an optional two-level structure in addition to the current
single-level one. For example,

br i1 %cond, label %then, label %else, !prof !0

!0 = !{!"branch_weights", i32 64, i32 4} ; Single-level

br i1 %cond, label %then, label %else, !prof !1

!1 = !{!1, !2, !3, !4} ; Two-level
!2 = !{!"branch_weights", i32 64, i32 4}
!3 = !{!"foo"}
!4 = !{!"bar"}

[hjyamauchi]

A bit of cleanup and added an assert.

[davidxl]

This does not look like backward compatible IR change. For the purpose of annotating irreducible loop headers, it might be better to introduce a new type of metadata.

[hjyamauchi]

In D38474#890672, @davidxl wrote:

This does not look like backward compatible IR change. For the purpose of annotating irreducible loop headers, it might be better to introduce a new type of metadata.

The current single-level format is still used when there's only one prof metadata per instruction. The two-level format is used only when there are multiple items.

So, it should be backward compatible in that sense at least.

[hjyamauchi]

To give more context, the motivating issue for us is the block frequency propagation of irreducible loops under PGO.

We think that if we can annotate irreducible loop headers with (relative) frequency weights (based on PGO profiles), that could work.

That would need a new annotation type in the form of, either

(1) a new (sub)type of prof metadata,

OR

(2) a new metadata type (a new MD_xxx).

We aren't sure which would be better.

A rationale for (1) is that it can be considered as a type of "prof" annotation as it's based on profile data.

This patch assumes (1) because our current idea is to put the annotation on the terminator of a header block where there is likely a branch_weight prof metadata on it (hence the support for multiple prof metadata.)

Alternatively (2) would not need this patch.

include/llvm/Analysis/CFGPrinter.h

struct DOTGraphTraits<const Function*> : public DefaultDOTGraphTraits {
 
   /// Display the raw branch weights from PGO.
   std::string getEdgeAttributes(const BasicBlock *Node, succ_const_iterator I,
                                 const Function *F) {
     const TerminatorInst *TI = Node->getTerminator();
     if (TI->getNumSuccessors() == 1)
       return "";
 
-    MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
+    MDNode *WeightsNode = TI->getProfMetadata(
+        LLVMContext::MD_PROF_branch_weights);
     if (!WeightsNode)
       return "";
 
-    MDString *MDName = cast<MDString>(WeightsNode->getOperand(0));
-    if (MDName->getString() != "branch_weights")
-      return "";
-
     unsigned OpNo = I.getSuccessorIndex() + 1;
     if (OpNo >= WeightsNode->getNumOperands())
       return "";
     ConstantInt *Weight =
         mdconst::dyn_extract<ConstantInt>(WeightsNode->getOperand(OpNo));
     if (!Weight)
       return "";
 

include/llvm/IR/IRBuilder.h

public:
   // Instruction creation methods: Terminators
   //===--------------------------------------------------------------------===//
 
 private:
   /// \brief Helper to add branch weight and unpredictable metadata onto an
   /// instruction.
   /// \returns The annotated instruction.
   template <typename InstTy>
-  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
-    if (Weights)
-      I->setMetadata(LLVMContext::MD_prof, Weights);
+  InstTy *addProfMetadata(InstTy *I, MDNode *Prof, MDNode *Unpredictable) {
+    if (Prof)
+      I->setMetadata(LLVMContext::MD_prof, Prof);
     if (Unpredictable)
       I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
     return I;
   }
 
 public:
   /// \brief Create a 'ret void' instruction.
   ReturnInst *CreateRetVoid() {
public:
   /// \brief Create an unconditional 'br label X' instruction.
   BranchInst *CreateBr(BasicBlock *Dest) {
     return Insert(BranchInst::Create(Dest));
   }
 
   /// \brief Create a conditional 'br Cond, TrueDest, FalseDest'
   /// instruction.
   BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
-                           MDNode *BranchWeights = nullptr,
+                           MDNode *Prof = nullptr,
                            MDNode *Unpredictable = nullptr) {
-    return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
-                                    BranchWeights, Unpredictable));
+    return Insert(addProfMetadata(BranchInst::Create(True, False, Cond),
+                                  Prof, Unpredictable));
   }
 
   /// \brief Create a conditional 'br Cond, TrueDest, FalseDest'
   /// instruction. Copy branch meta data if available.
   BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
                            Instruction *MDSrc) {
     BranchInst *Br = BranchInst::Create(True, False, Cond);
     if (MDSrc) {
       unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
                         LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
       Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
     }
     return Insert(Br);
   }
 
   /// \brief Create a switch instruction with the specified value, default dest,
   /// and with a hint for the number of cases that will be added (for efficient
   /// allocation).
   SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
-                           MDNode *BranchWeights = nullptr,
+                           MDNode *Prof = nullptr,
                            MDNode *Unpredictable = nullptr) {
-    return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
-                                    BranchWeights, Unpredictable));
+    return Insert(addProfMetadata(SwitchInst::Create(V, Dest, NumCases),
+                                  Prof, Unpredictable));
   }
 
   /// \brief Create an indirect branch instruction with the specified address
   /// operand, with an optional hint for the number of destinations that will be
   /// added (for efficient allocation).
   IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
     return Insert(IndirectBrInst::Create(Addr, NumDests));
   }
if (Constant *CC = dyn_cast<Constant>(C))
       if (Constant *TC = dyn_cast<Constant>(True))
         if (Constant *FC = dyn_cast<Constant>(False))
           return Insert(Folder.CreateSelect(CC, TC, FC), Name);
 
     SelectInst *Sel = SelectInst::Create(C, True, False);
     if (MDFrom) {
       MDNode *Prof = MDFrom->getMetadata(LLVMContext::MD_prof);
       MDNode *Unpred = MDFrom->getMetadata(LLVMContext::MD_unpredictable);
-      Sel = addBranchMetadata(Sel, Prof, Unpred);
+      Sel = addProfMetadata(Sel, Prof, Unpred);
     }
     return Insert(Sel, Name);
   }
 
   VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
     return Insert(new VAArgInst(List, Ty), Name);
   }
 

include/llvm/IR/Instruction.h

public:
   void copyMetadata(const Instruction &SrcInst,
                     ArrayRef<unsigned> WL = ArrayRef<unsigned>());
 
   /// If the instruction has "branch_weights" MD_prof metadata and the MDNode
   /// has three operands (including name string), swap the order of the
   /// metadata.
   void swapProfMetadata();
 
+  /// Get a MD_prof metadata.
+  MDNode *getProfMetadata(unsigned MDProfKindId) const;
+  /// Set a MD_prof metadata.
+  void setProfMetadata(unsigned MDProfKindId, MDNode *NewNode);
+
   /// Drop all unknown metadata except for debug locations.
   /// @{
   /// Passes are required to drop metadata they don't understand. This is a
   /// convenience method for passes to do so.
   void dropUnknownNonDebugMetadata(ArrayRef<unsigned> KnownIDs);
   void dropUnknownNonDebugMetadata() {
     return dropUnknownNonDebugMetadata(None);
   }

include/llvm/IR/LLVMContext.h

enum {
     MD_align = 17,                    // "align"
     MD_loop = 18,                     // "llvm.loop"
     MD_type = 19,                     // "type"
     MD_section_prefix = 20,           // "section_prefix"
     MD_absolute_symbol = 21,          // "absolute_symbol"
     MD_associated = 22,               // "associated"
   };
 
+  // The types of the MD_prof metadata.
+  enum {
+    MD_PROF_branch_weights = 0,          // "branch_weights"
+    MD_PROF_function_entry_count = 1,    // "function_entry_count"
+    MD_PROF_VP = 2,                      // "VP"
+  };
+
   /// Known operand bundle tag IDs, which always have the same value.  All
   /// operand bundle tags that LLVM has special knowledge of are listed here.
   /// Additionally, this scheme allows LLVM to efficiently check for specific
   /// operand bundle tags without comparing strings.
   enum {
     OB_deopt = 0,         // "deopt"
     OB_funclet = 1,       // "funclet"
     OB_gc_transition = 2, // "gc-transition"
   };
 
   /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
   /// This ID is uniqued across modules in the current LLVMContext.
   unsigned getMDKindID(StringRef Name) const;
 
   /// getMDKindNames - Populate client supplied SmallVector with the name for
   /// custom metadata IDs registered in this LLVMContext.
   void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;
 
+  static const char* getMDProfKindName(unsigned MDProfKindId) {
+    assert(MDProfKindId < sizeof(MDProfKindNames) && "out of range");
+    return MDProfKindNames[MDProfKindId];
+  }
+
   /// getOperandBundleTags - Populate client supplied SmallVector with the
   /// bundle tags registered in this LLVMContext.  The bundle tags are ordered
   /// by increasing bundle IDs.
   /// \see LLVMContext::getOperandBundleTagID
   void getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const;
 
   /// getOperandBundleTagID - Maps a bundle tag to an integer ID.  Every bundle
   /// tag registered with an LLVMContext has an unique ID.
public:
 
   /// \brief Access the object which manages optimization bisection for failure
   /// analysis.
   OptBisect &getOptBisect();
 private:
   // Module needs access to the add/removeModule methods.
   friend class Module;
 
+  // The strings holding the names of the MD_Prof metadata types.
+  static const char *MDProfKindNames[3];
+
   /// addModule - Register a module as being instantiated in this context.  If
   /// the context is deleted, the module will be deleted as well.
   void addModule(Module*);
 
   /// removeModule - Unregister a module from this context.
   void removeModule(Module*);
 };
 

include/llvm/IR/MDBuilder.h

public:
   //===------------------------------------------------------------------===//
 
   /// \brief Return metadata containing two branch weights.
   MDNode *createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight);
 
   /// \brief Return metadata containing a number of branch weights.
   MDNode *createBranchWeights(ArrayRef<uint32_t> Weights);
 
+  /// \brief Return metadata containing two weights.
+  template<typename WeightIntType>
+  MDNode *createProfWeights(unsigned MDProfKindId,
+                            WeightIntType TrueWeight, WeightIntType FalseWeight);
+
+  /// \brief Return metadata containing a number of weights.
+  template<typename WeightIntType>
+  MDNode *createProfWeights(unsigned MDProfKindId,
+                            ArrayRef<WeightIntType> Weights);
+
   /// Return metadata specifying that a branch or switch is unpredictable.
   MDNode *createUnpredictable();
 
   /// Return metadata containing the entry \p Count for a function, and the
   /// GUIDs stored in \p Imports that need to be imported for sample PGO, to
   /// enable the same inlines as the profiled optimized binary
   MDNode *createFunctionEntryCount(uint64_t Count,
                                    const DenseSet<GlobalValue::GUID> *Imports);

include/llvm/Transforms/PGOInstrumentation.h

 
 /// The profile size based optimization pass for memory intrinsics.
 class PGOMemOPSizeOpt : public PassInfoMixin<PGOMemOPSizeOpt> {
 public:
   PGOMemOPSizeOpt() {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-void setProfMetadata(Module *M, Instruction *TI, ArrayRef<uint64_t> EdgeCounts,
-                     uint64_t MaxCount);
+void setBranchWeightsMetadata(Module *M, Instruction *TI,
+                              ArrayRef<uint64_t> EdgeCounts, uint64_t MaxCount);
 
 } // End llvm namespace
 #endif

lib/Analysis/BranchProbabilityInfo.cpp

 // heuristic. The probability of the edge coming to unreachable block is
 // set to min of metadata and unreachable heuristic.
 bool BranchProbabilityInfo::calcMetadataWeights(const BasicBlock *BB) {
   const TerminatorInst *TI = BB->getTerminator();
   assert(TI->getNumSuccessors() > 1 && "expected more than one successor!");
   if (!(isa<BranchInst>(TI) || isa<SwitchInst>(TI) || isa<IndirectBrInst>(TI)))
     return false;
 
-  MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
+  MDNode *WeightsNode = TI->getProfMetadata(
+      LLVMContext::MD_PROF_branch_weights);
   if (!WeightsNode)
     return false;
 
   // Check that the number of successors is manageable.
   assert(TI->getNumSuccessors() < UINT32_MAX && "Too many successors");
 
   // Ensure there are weights for all of the successors. Note that the first
   // operand to the metadata node is a name, not a weight.

lib/CodeGen/CodeGenPrepare.cpp

if (Opc == Instruction::Or) {
       //   TrueProb for BB1 == FalseProb for BB1 * TrueProb for TmpBB.
       // Another choice is to assume TrueProb for BB1 equals to TrueProb for
       // TmpBB, but the math is more complicated.
       uint64_t TrueWeight, FalseWeight;
       if (Br1->extractProfMetadata(TrueWeight, FalseWeight)) {
         uint64_t NewTrueWeight = TrueWeight;
         uint64_t NewFalseWeight = TrueWeight + 2 * FalseWeight;
         scaleWeights(NewTrueWeight, NewFalseWeight);
-        Br1->setMetadata(LLVMContext::MD_prof, MDBuilder(Br1->getContext())
+        Br1->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                             MDBuilder(Br1->getContext())
                              .createBranchWeights(TrueWeight, FalseWeight));
 
         NewTrueWeight = TrueWeight;
         NewFalseWeight = 2 * FalseWeight;
         scaleWeights(NewTrueWeight, NewFalseWeight);
-        Br2->setMetadata(LLVMContext::MD_prof, MDBuilder(Br2->getContext())
+        Br2->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                             MDBuilder(Br2->getContext())
                              .createBranchWeights(TrueWeight, FalseWeight));
       }
     } else {
       // Codegen X & Y as:
       // BB1:
       //   jmp_if_X TmpBB
       //   jmp FBB
       // TmpBB:
       //   jmp_if_Y TBB
if (Opc == Instruction::Or) {
       // weights to 2A+B and B, and set TmpBB's weights to 2A and B. This choice
       // assumes that
       //   FalseProb for BB1 == TrueProb for BB1 * FalseProb for TmpBB.
       uint64_t TrueWeight, FalseWeight;
       if (Br1->extractProfMetadata(TrueWeight, FalseWeight)) {
         uint64_t NewTrueWeight = 2 * TrueWeight + FalseWeight;
         uint64_t NewFalseWeight = FalseWeight;
         scaleWeights(NewTrueWeight, NewFalseWeight);
-        Br1->setMetadata(LLVMContext::MD_prof, MDBuilder(Br1->getContext())
+        Br1->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                             MDBuilder(Br1->getContext())
                              .createBranchWeights(TrueWeight, FalseWeight));
 
         NewTrueWeight = 2 * TrueWeight;
         NewFalseWeight = FalseWeight;
         scaleWeights(NewTrueWeight, NewFalseWeight);
-        Br2->setMetadata(LLVMContext::MD_prof, MDBuilder(Br2->getContext())
+        Br2->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                             MDBuilder(Br2->getContext())
                              .createBranchWeights(TrueWeight, FalseWeight));
       }
     }
 
     // Note: No point in getting fancy here, since the DT info is never
     // available to CodeGenPrepare.
     ModifiedDT = true;
 
     MadeChange = true;
 
     DEBUG(dbgs() << "After branch condition splitting\n"; BB.dump();
           TmpBB->dump());
   }
   return MadeChange;
 }

lib/IR/Instruction.cpp

bool Instruction::isAssociative() const {
   }
 }
 
 Instruction *Instruction::cloneImpl() const {
   llvm_unreachable("Subclass of Instruction failed to implement cloneImpl");
 }
 
 void Instruction::swapProfMetadata() {
-  MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
-  if (!ProfileData || ProfileData->getNumOperands() != 3 ||
-      !isa<MDString>(ProfileData->getOperand(0)))
-    return;
-
-  MDString *MDName = cast<MDString>(ProfileData->getOperand(0));
-  if (MDName->getString() != "branch_weights")
-    return;
-
+  MDNode *BranchWeights = getProfMetadata(LLVMContext::MD_PROF_branch_weights);
+  if (BranchWeights && BranchWeights->getNumOperands() == 3) {
     // The first operand is the name. Fetch them backwards and build a new one.
-  Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
-                     ProfileData->getOperand(1)};
-  setMetadata(LLVMContext::MD_prof,
-              MDNode::get(ProfileData->getContext(), Ops));
+    Metadata *Ops[] = {BranchWeights->getOperand(0), BranchWeights->getOperand(2),
+                       BranchWeights->getOperand(1)};
+    setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                    MDNode::get(BranchWeights->getContext(), Ops));
+  }
 }
 
 void Instruction::copyMetadata(const Instruction &SrcInst,
                                ArrayRef<unsigned> WL) {
   if (!SrcInst.hasMetadata())
     return;
 
   DenseSet<unsigned> WLS;
#undef HANDLE_INST
   }
 
   New->SubclassOptionalData = SubclassOptionalData;
   New->copyMetadata(*this);
   return New;
 }
 
 void Instruction::updateProfWeight(uint64_t S, uint64_t T) {
-  auto *ProfileData = getMetadata(LLVMContext::MD_prof);
+  auto *BranchWeights = getProfMetadata(LLVMContext::MD_PROF_branch_weights);
+  auto *VP = getProfMetadata(LLVMContext::MD_PROF_VP);
+  assert(((BranchWeights && !VP) || (!BranchWeights && VP) ||
+          (!BranchWeights && !VP)) &&
+         "Only one of BranchWeights and VP should be there");
+  auto *ProfileData = BranchWeights ? BranchWeights : VP;
   if (ProfileData == nullptr)
     return;
 
-  auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0));
-  if (!ProfDataName || (!ProfDataName->getString().equals("branch_weights") &&
-                        !ProfDataName->getString().equals("VP")))
-    return;
-
   MDBuilder MDB(getContext());
   SmallVector<Metadata *, 3> Vals;
   Vals.push_back(ProfileData->getOperand(0));
   APInt APS(128, S), APT(128, T);
-  if (ProfDataName->getString().equals("branch_weights"))
+  if (ProfileData == BranchWeights) {
     for (unsigned i = 1; i < ProfileData->getNumOperands(); i++) {
       // Using APInt::div may be expensive, but most cases should fit 64 bits.
       APInt Val(128,
                 mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i))
                     ->getValue()
                     .getZExtValue());
       Val *= APS;
       Vals.push_back(MDB.createConstant(
           ConstantInt::get(Type::getInt64Ty(getContext()),
                            Val.udiv(APT).getLimitedValue())));
     }
-  else if (ProfDataName->getString().equals("VP"))
+    setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                    MDNode::get(getContext(), Vals));
+  } else if (ProfileData == VP) {
     for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) {
       // The first value is the key of the value profile, which will not change.
       Vals.push_back(ProfileData->getOperand(i));
       // Using APInt::div may be expensive, but most cases should fit 64 bits.
       APInt Val(128,
                 mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i + 1))
                     ->getValue()
                     .getZExtValue());
       Val *= APS;
       Vals.push_back(MDB.createConstant(
           ConstantInt::get(Type::getInt64Ty(getContext()),
                            Val.udiv(APT).getLimitedValue())));
     }
-  setMetadata(LLVMContext::MD_prof, MDNode::get(getContext(), Vals));
+    setProfMetadata(LLVMContext::MD_PROF_VP,
+                    MDNode::get(getContext(), Vals));
+  }
 }
 
 void Instruction::setProfWeight(uint64_t W) {
   assert((isa<CallInst>(this) || isa<InvokeInst>(this)) &&
          "Can only set weights for call and invoke instrucitons");
   SmallVector<uint32_t, 1> Weights;
   Weights.push_back(W);
   MDBuilder MDB(getContext());
-  setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
+  setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                  MDB.createBranchWeights(Weights));
 }

lib/IR/LLVMContext.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdlib>
 #include <string>
 #include <utility>
 
 using namespace llvm;
 
+const char *LLVMContext::MDProfKindNames[] = {
+  "branch_weights",
+  "function_entry_count",
+  "VP",
+};
+
 LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl(*this)) {
   // Create the fixed metadata kinds. This is done in the same order as the
   // MD_* enum values so that they correspond.
   std::pair<unsigned, StringRef> MDKinds[] = {
     {MD_dbg, "dbg"},
     {MD_tbaa, "tbaa"},
     {MD_prof, "prof"},
     {MD_fpmath, "fpmath"},

lib/IR/MDBuilder.cpp

 }
 
 MDNode *MDBuilder::createBranchWeights(uint32_t TrueWeight,
                                        uint32_t FalseWeight) {
   return createBranchWeights({TrueWeight, FalseWeight});
 }
 
 MDNode *MDBuilder::createBranchWeights(ArrayRef<uint32_t> Weights) {
-  assert(Weights.size() >= 1 && "Need at least one branch weights!");
+  return createProfWeights<uint32_t>(LLVMContext::MD_PROF_branch_weights,
+                                     Weights);
+}
+
+template<typename WeightIntType>
+MDNode *MDBuilder::createProfWeights(unsigned MDProfKindId,
+                                     WeightIntType TrueWeight,
+                                     WeightIntType FalseWeight) {
+  return createProfWeights<WeightIntType>(MDProfKindId,
+                                          {TrueWeight, FalseWeight});
+}
+
+template MDNode *MDBuilder::createProfWeights<uint32_t>(
+    unsigned MDProfKindId, uint32_t TrueWeight, uint32_t FalseWeight);
+template MDNode *MDBuilder::createProfWeights<uint64_t>(
+    unsigned MDProfKindId, uint64_t TrueWeight, uint64_t FalseWeight);
+
+template<typename WeightIntType>
+MDNode *MDBuilder::createProfWeights(unsigned MDProfKindId,
+                                     ArrayRef<WeightIntType> Weights) {
+  assert(Weights.size() >= 1 && "Need at least one weights!");
 
   SmallVector<Metadata *, 4> Vals(Weights.size() + 1);
-  Vals[0] = createString("branch_weights");
+  Vals[0] = createString(LLVMContext::getMDProfKindName(MDProfKindId));
 
-  Type *Int32Ty = Type::getInt32Ty(Context);
+  static_assert(sizeof(WeightIntType) == 8 || sizeof(WeightIntType) == 4,
+                "Weight type is not 4 nor 8 byte long");
+  Type *WeightType = sizeof(WeightIntType) == 8 ?
+      Type::getInt64Ty(Context) : Type::getInt32Ty(Context);
   for (unsigned i = 0, e = Weights.size(); i != e; ++i)
-    Vals[i + 1] = createConstant(ConstantInt::get(Int32Ty, Weights[i]));
+    Vals[i + 1] = createConstant(ConstantInt::get(WeightType, Weights[i]));
 
   return MDNode::get(Context, Vals);
 }
 
+template MDNode *MDBuilder::createProfWeights<uint32_t>(
+    unsigned MDProfKindId, ArrayRef<uint32_t> Weights);
+template MDNode *MDBuilder::createProfWeights<uint64_t>(
+    unsigned MDProfKindId, ArrayRef<uint64_t> Weights);
+
 MDNode *MDBuilder::createUnpredictable() {
   return MDNode::get(Context, None);
 }
 
 MDNode *MDBuilder::createFunctionEntryCount(
     uint64_t Count, const DenseSet<GlobalValue::GUID> *Imports) {
   Type *Int64Ty = Type::getInt64Ty(Context);
   SmallVector<Metadata *, 8> Ops;

lib/IR/Metadata.cpp

 }
 
 bool Instruction::extractProfMetadata(uint64_t &TrueVal,
                                       uint64_t &FalseVal) const {
   assert(
       (getOpcode() == Instruction::Br || getOpcode() == Instruction::Select) &&
       "Looking for branch weights on something besides branch or select");
 
-  auto *ProfileData = getMetadata(LLVMContext::MD_prof);
-  if (!ProfileData || ProfileData->getNumOperands() != 3)
+  auto *BranchWeights = getProfMetadata(LLVMContext::MD_PROF_branch_weights);
+  if (!BranchWeights || BranchWeights->getNumOperands() != 3)
     return false;
 
-  auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0));
-  if (!ProfDataName || !ProfDataName->getString().equals("branch_weights"))
-    return false;
-
-  auto *CITrue = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(1));
-  auto *CIFalse = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(2));
+  auto *CITrue = mdconst::dyn_extract<ConstantInt>(BranchWeights->getOperand(1));
+  auto *CIFalse = mdconst::dyn_extract<ConstantInt>(BranchWeights->getOperand(2));
   if (!CITrue || !CIFalse)
     return false;
 
   TrueVal = CITrue->getValue().getZExtValue();
   FalseVal = CIFalse->getValue().getZExtValue();
 
   return true;
 }
 
 bool Instruction::extractProfTotalWeight(uint64_t &TotalVal) const {
   assert((getOpcode() == Instruction::Br ||
           getOpcode() == Instruction::Select ||
           getOpcode() == Instruction::Call ||
           getOpcode() == Instruction::Invoke ||
           getOpcode() == Instruction::Switch) &&
          "Looking for branch weights on something besides branch");
 
   TotalVal = 0;
-  auto *ProfileData = getMetadata(LLVMContext::MD_prof);
+  auto *BranchWeights = getProfMetadata(LLVMContext::MD_PROF_branch_weights);
+  auto *VP = getProfMetadata(LLVMContext::MD_PROF_VP);
+  assert(((BranchWeights && !VP) || (!BranchWeights && VP) ||
+          (!BranchWeights && !VP)) &&
+         "Only up to one of BranchWeights and VP should be there");
+  auto *ProfileData = BranchWeights ? BranchWeights : VP;
   if (!ProfileData)
     return false;
 
-  auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0));
-  if (!ProfDataName)
-    return false;
-
-  if (ProfDataName->getString().equals("branch_weights")) {
+  if (ProfileData == BranchWeights) {
     TotalVal = 0;
     for (unsigned i = 1; i < ProfileData->getNumOperands(); i++) {
       auto *V = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i));
       if (!V)
         return false;
       TotalVal += V->getValue().getZExtValue();
     }
     return true;
-  } else if (ProfDataName->getString().equals("VP") &&
+  } else if (ProfileData == VP &&
              ProfileData->getNumOperands() > 3) {
     TotalVal = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(2))
                    ->getValue()
                    .getZExtValue();
     return true;
   }
   return false;
 }
 
+MDNode *Instruction::getProfMetadata(unsigned MDProfKindId) const {
+  MDNode *ProfNode = getMetadata(LLVMContext::MD_prof);
+  if (!ProfNode)
+    return nullptr;
+  if (ProfNode->getOperand(0) != ProfNode) {
+    // Single-level.
+    MDString *MDName = cast<MDString>(ProfNode->getOperand(0));
+    if (MDName->getString() == LLVMContext::getMDProfKindName(MDProfKindId))
+      return ProfNode;
+    return nullptr;
+  }
+  // Two-level.
+  for (unsigned I = 1; I < ProfNode->getNumOperands(); ++I) {
+    MDNode *MD = cast<MDNode>(ProfNode->getOperand(I));
+    MDString *MDName = cast<MDString>(MD->getOperand(0));
+    if (MDName->getString() == LLVMContext::getMDProfKindName(MDProfKindId))
+      return MD;
+  }
+  return nullptr;
+}
+
+void Instruction::setProfMetadata(unsigned MDProfKindId,
+                                  MDNode *NewNode) {
+  DEBUG({
+    if (NewNode) {
+      MDString *MDName = cast<MDString>(NewNode->getOperand(0));
+      assert(MDName->getString() ==
+             LLVMContext::getMDProfKindName(MDProfKindId) &&
+             "Mismatching MD prof kind name/id");
+    }
+  });
+  MDNode *ProfNode = getMetadata(LLVMContext::MD_prof);
+  if (!ProfNode) {
+    // Insert as a single-level.
+    setMetadata(LLVMContext::MD_prof, NewNode);
+    return;
+  }
+  if (ProfNode->getOperand(0) != ProfNode) {
+    // Single-level.
+    MDString *MDName = cast<MDString>(ProfNode->getOperand(0));
+    if (MDName->getString() == LLVMContext::getMDProfKindName(MDProfKindId)) {
+      // Replace.
+      setMetadata(LLVMContext::MD_prof, NewNode);
+      return;
+    }
+    if (NewNode == nullptr)
+      return;
+    // Promote to two-level.
+    LLVMContext &Ctx = getContext();
+    auto TempNode = MDNode::getTemporary(Ctx, None);
+    auto NewProfNode = MDNode::get(Ctx, {TempNode.get(), ProfNode, NewNode});
+    NewProfNode->replaceOperandWith(0, NewProfNode);
+    setMetadata(LLVMContext::MD_prof, NewProfNode);
+    return;
+  }
+  // Two-level.
+  for (unsigned I = 1; I < ProfNode->getNumOperands(); ++I) {
+    MDNode *MDI = cast<MDNode>(ProfNode->getOperand(I));
+    MDString *MDName = cast<MDString>(MDI->getOperand(0));
+    if (MDName->getString() == LLVMContext::getMDProfKindName(MDProfKindId)) {
+      if (NewNode == nullptr) {
+        // Remove.
+        SmallVector<Metadata *, 3> Ops;
+        Ops.reserve(ProfNode->getNumOperands() - 1);
+        for (unsigned J = 1; J < ProfNode->getNumOperands(); ++J)
+          if (I != J) {
+            MDNode *MDJ = cast<MDNode>(ProfNode->getOperand(J));
+            Ops.push_back(MDJ);
+          }
+        if (Ops.size() == 0) {
+          // No metadata left. Clear it.
+          setMetadata(LLVMContext::MD_prof, nullptr);
+        } else if (Ops.size() == 1) {
+          // One remaining. Demote to single-level.
+          setMetadata(LLVMContext::MD_prof, cast<MDNode>(Ops[0]));
+        } else {
+          setMetadata(LLVMContext::MD_prof, MDNode::get(getContext(), Ops));
+        }
+      } else {
+        // Replace.
+        ProfNode->replaceOperandWith(I, NewNode);
+      }
+      return;
+    }
+  }
+  if (NewNode == nullptr)
+    return;
+  // Append.
+  SmallVector<Metadata *, 3> Ops;
+  Ops.reserve(ProfNode->getNumOperands() + 1);
+  for (Metadata *MD : ProfNode->operands())
+    Ops.push_back(MD);
+  Ops.push_back(NewNode);
+  setMetadata(LLVMContext::MD_prof, MDNode::get(getContext(), Ops));
+}
+
 void Instruction::clearMetadataHashEntries() {
   assert(hasMetadataHashEntry() && "Caller should check");
   getContext().pImpl->InstructionMetadata.erase(this);
   setHasMetadataHashEntry(false);
 }
 
 void GlobalObject::getMetadata(unsigned KindID,
                                SmallVectorImpl<MDNode *> &MDs) const {

lib/ProfileData/InstrProf.cpp

void annotateValueSite(Module &M, Instruction &Inst,
   for (auto &VD : VDs) {
     Vals.push_back(MDHelper.createConstant(
         ConstantInt::get(Type::getInt64Ty(Ctx), VD.Value)));
     Vals.push_back(MDHelper.createConstant(
         ConstantInt::get(Type::getInt64Ty(Ctx), VD.Count)));
     if (--MDCount == 0)
       break;
   }
-  Inst.setMetadata(LLVMContext::MD_prof, MDNode::get(Ctx, Vals));
+  Inst.setProfMetadata(LLVMContext::MD_PROF_VP, MDNode::get(Ctx, Vals));
 }
 
 bool getValueProfDataFromInst(const Instruction &Inst,
                               InstrProfValueKind ValueKind,
                               uint32_t MaxNumValueData,
                               InstrProfValueData ValueData[],
                               uint32_t &ActualNumValueData, uint64_t &TotalC) {
-  MDNode *MD = Inst.getMetadata(LLVMContext::MD_prof);
+  MDNode *MD = Inst.getProfMetadata(LLVMContext::MD_PROF_VP);
   if (!MD)
     return false;
 
   unsigned NOps = MD->getNumOperands();
 
   if (NOps < 5)
     return false;
 
-  // Operand 0 is a string tag "VP":
-  MDString *Tag = cast<MDString>(MD->getOperand(0));
-  if (!Tag)
-    return false;
-
-  if (!Tag->getString().equals("VP"))
-    return false;
-
   // Now check kind:
   ConstantInt *KindInt = mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
   if (!KindInt)
     return false;
   if (KindInt->getZExtValue() != ValueKind)
     return false;
 
   // Get total count

lib/Transforms/IPO/CrossDSOCFI.cpp

for (uint64_t TypeId : TypeIds) {
     BasicBlock *TestBB = BasicBlock::Create(Ctx, "test", F);
     IRBuilder<> IRBTest(TestBB);
     Function *BitsetTestFn = Intrinsic::getDeclaration(&M, Intrinsic::type_test);
 
     Value *Test = IRBTest.CreateCall(
         BitsetTestFn, {&Addr, MetadataAsValue::get(
                                   Ctx, ConstantAsMetadata::get(CaseTypeId))});
     BranchInst *BI = IRBTest.CreateCondBr(Test, ExitBB, TrapBB);
-    BI->setMetadata(LLVMContext::MD_prof, VeryLikelyWeights);
+    BI->setProfMetadata(LLVMContext::MD_PROF_branch_weights, VeryLikelyWeights);
 
     SI->addCase(CaseTypeId, TestBB);
     ++NumTypeIds;
   }
 }
 
 bool CrossDSOCFI::runOnModule(Module &M) {
   if (skipModule(M))

lib/Transforms/IPO/LowerTypeTests.cpp

Value *LowerTypeTestsModule::lowerTypeTestCall(Metadata *TypeId, CallInst *CI,
   // where nothing happens between the type test and the br.
   // If so, create slightly simpler IR.
   if (CI->hasOneUse())
     if (auto *Br = dyn_cast<BranchInst>(*CI->user_begin()))
       if (CI->getNextNode() == Br) {
         BasicBlock *Then = InitialBB->splitBasicBlock(CI->getIterator());
         BasicBlock *Else = Br->getSuccessor(1);
         BranchInst *NewBr = BranchInst::Create(Then, Else, OffsetInRange);
-        NewBr->setMetadata(LLVMContext::MD_prof,
-                           Br->getMetadata(LLVMContext::MD_prof));
+        NewBr->setProfMetadata(
+            LLVMContext::MD_PROF_branch_weights,
+            Br->getProfMetadata(LLVMContext::MD_PROF_branch_weights));
         ReplaceInstWithInst(InitialBB->getTerminator(), NewBr);
 
         // Update phis in Else resulting from InitialBB being split
         for (auto &Phi : Else->phis())
           Phi.addIncoming(Phi.getIncomingValueForBlock(Then), InitialBB);
 
         IRBuilder<> ThenB(CI);
         return createBitSetTest(ThenB, TIL, BitOffset);

lib/Transforms/IPO/SampleProfile.cpp

if (BlockWeights[BB]) {
           SmallVector<InstrProfValueData, 2> SortedCallTargets;
           uint64_t Sum = SortCallTargets(SortedCallTargets, T.get());
           annotateValueSite(*I.getParent()->getParent()->getParent(), I,
                             SortedCallTargets, Sum, IPVK_IndirectCallTarget,
                             SortedCallTargets.size());
         } else if (!dyn_cast<IntrinsicInst>(&I)) {
           SmallVector<uint32_t, 1> Weights;
           Weights.push_back(BlockWeights[BB]);
-          I.setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
+          I.setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                            MDB.createBranchWeights(Weights));
         }
       }
     }
     TerminatorInst *TI = BB->getTerminator();
     if (TI->getNumSuccessors() == 1)
       continue;
     if (!isa<BranchInst>(TI) && !isa<SwitchInst>(TI))
       continue;
for (auto &BI : F) {
     uint64_t TempWeight;
     // Only set weights if there is at least one non-zero weight.
     // In any other case, let the analyzer set weights.
     // Do not set weights if the weights are present. In ThinLTO, the profile
     // annotation is done twice. If the first annotation already set the
     // weights, the second pass does not need to set it.
     if (MaxWeight > 0 && !TI->extractProfTotalWeight(TempWeight)) {
       DEBUG(dbgs() << "SUCCESS. Found non-zero weights.\n");
-      TI->setMetadata(llvm::LLVMContext::MD_prof,
+      TI->setProfMetadata(llvm::LLVMContext::MD_PROF_branch_weights,
                       MDB.createBranchWeights(Weights));
       ORE->emit(OptimizationRemark(DEBUG_TYPE, "PopularDest", MaxDestInst)
                 << "most popular destination for conditional branches at "
                 << ore::NV("CondBranchesLoc", BranchLoc));
     } else {
       DEBUG(dbgs() << "SKIPPED. All branch weights are zero.\n");
     }
   }

lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

if (CallInst *CI = dyn_cast<CallInst>(NewInst)) {
     II->mutateFunctionType(DirectCallee->getFunctionType());
     II->setNormalDest(MergeBB);
   }
 
   DirectCallBB->getInstList().insert(DirectCallBB->getFirstInsertionPt(),
                                      NewInst);
 
   // Clear the value profile data.
-  NewInst->setMetadata(LLVMContext::MD_prof, nullptr);
+  NewInst->setProfMetadata(LLVMContext::MD_PROF_VP, nullptr);
   CallSite NewCS(NewInst);
   FunctionType *DirectCalleeType = DirectCallee->getFunctionType();
   unsigned ParamNum = DirectCalleeType->getFunctionNumParams();
   for (unsigned I = 0; I < ParamNum; ++I) {
     Type *ATy = NewCS.getArgument(I)->getType();
     Type *PTy = DirectCalleeType->getParamType(I);
     if (ATy != PTy) {
       BitCastInst *BI = new BitCastInst(NewCS.getArgument(I), PTy, "", NewInst);
Instruction *llvm::promoteIndirectCall(Instruction *Inst,
   Instruction *NewInst =
       createDirectCallInst(Inst, DirectCallee, DirectCallBB, MergeBB);
 
   if (AttachProfToDirectCall) {
     SmallVector<uint32_t, 1> Weights;
     Weights.push_back(Count);
     MDBuilder MDB(NewInst->getContext());
     if (Instruction *DI = dyn_cast<Instruction>(NewInst->stripPointerCasts()))
-      DI->setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
+      DI->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                          MDB.createBranchWeights(Weights));
   }
 
   // Move Inst from MergeBB to IndirectCallBB.
   Inst->removeFromParent();
   IndirectCallBB->getInstList().insert(IndirectCallBB->getFirstInsertionPt(),
                                        Inst);
 
   if (InvokeInst *II = dyn_cast<InvokeInst>(Inst)) {
for (auto &I : findIndirectCallSites(F)) {
     auto PromotionCandidates = getPromotionCandidatesForCallSite(
         I, ICallProfDataRef, TotalCount, NumCandidates);
     uint32_t NumPromoted = tryToPromote(I, PromotionCandidates, TotalCount);
     if (NumPromoted == 0)
       continue;
 
     Changed = true;
     // Adjust the MD.prof metadata. First delete the old one.
-    I->setMetadata(LLVMContext::MD_prof, nullptr);
+    I->setProfMetadata(LLVMContext::MD_PROF_VP, nullptr);
     // If all promoted, we don't need the MD.prof metadata.
     if (TotalCount == 0 || NumPromoted == NumVals)
       continue;
     // Otherwise we need update with the un-promoted records back.
     annotateValueSite(*M, *I, ICallProfDataRef.slice(NumPromoted), TotalCount,
                       IPVK_IndirectCallTarget, NumCandidates);
   }
   return Changed;

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

for (unsigned s = 0; s < Size; s++) {
       if (DestBB == nullptr)
         continue;
       unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
       uint64_t EdgeCount = E->CountValue;
       if (EdgeCount > MaxCount)
         MaxCount = EdgeCount;
       EdgeCounts[SuccNum] = EdgeCount;
     }
-    setProfMetadata(M, TI, EdgeCounts, MaxCount);
+    setBranchWeightsMetadata(M, TI, EdgeCounts, MaxCount);
   }
 }
 
 void SelectInstVisitor::instrumentOneSelectInst(SelectInst &SI) {
   Module *M = F.getParent();
   IRBuilder<> Builder(&SI);
   Type *Int64Ty = Builder.getInt64Ty();
   Type *I8PtrTy = Builder.getInt8PtrTy();
void SelectInstVisitor::annotateOneSelectInst(SelectInst &SI) {
   uint64_t TotalCount = 0;
   auto BI = UseFunc->findBBInfo(SI.getParent());
   if (BI != nullptr)
     TotalCount = BI->CountValue;
   // False Count
   SCounts[1] = (TotalCount > SCounts[0] ? TotalCount - SCounts[0] : 0);
   uint64_t MaxCount = std::max(SCounts[0], SCounts[1]);
   if (MaxCount)
-    setProfMetadata(F.getParent(), &SI, SCounts, MaxCount);
+    setBranchWeightsMetadata(F.getParent(), &SI, SCounts, MaxCount);
 }
 
 void SelectInstVisitor::visitSelectInst(SelectInst &SI) {
   if (!PGOInstrSelect)
     return;
   // FIXME: do not handle this yet.
   if (SI.getCondition()->getType()->isVectorTy())
     return;
bool PGOInstrumentationUseLegacyPass::runOnModule(Module &M) {
   auto LookupBFI = [this](Function &F) {
     return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
   };
 
   return annotateAllFunctions(M, ProfileFileName, LookupBPI, LookupBFI);
 }
 
 namespace llvm {
-void setProfMetadata(Module *M, Instruction *TI, ArrayRef<uint64_t> EdgeCounts,
+void setBranchWeightsMetadata(Module *M, Instruction *TI,
+                              ArrayRef<uint64_t> EdgeCounts,
                               uint64_t MaxCount) {
   MDBuilder MDB(M->getContext());
   assert(MaxCount > 0 && "Bad max count");
   uint64_t Scale = calculateCountScale(MaxCount);
   SmallVector<unsigned, 4> Weights;
   for (const auto &ECI : EdgeCounts)
     Weights.push_back(scaleBranchCount(ECI, Scale));
 
   DEBUG(dbgs() << "Weight is: ";
         for (const auto &W : Weights) { dbgs() << W << " "; }
         dbgs() << "\n";);
-  TI->setMetadata(llvm::LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
+  TI->setProfMetadata(llvm::LLVMContext::MD_PROF_branch_weights,
+                      MDB.createBranchWeights(Weights));
   if (EmitBranchProbability) {
     std::string BrCondStr = getBranchCondString(TI);
     if (BrCondStr.empty())
       return;
 
     unsigned WSum =
         std::accumulate(Weights.begin(), Weights.end(), 0,
                         [](unsigned w1, unsigned w2) { return w1 + w2; });

lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp

bool MemOPSizeOpt::perform(MemIntrinsic *MI) {
 
   auto &Ctx = Func.getContext();
   IRBuilder<> IRB(BB);
   BB->getTerminator()->eraseFromParent();
   Value *SizeVar = MI->getLength();
   SwitchInst *SI = IRB.CreateSwitch(SizeVar, DefaultBB, SizeIds.size());
 
   // Clear the value profile data.
-  MI->setMetadata(LLVMContext::MD_prof, nullptr);
+  MI->setProfMetadata(LLVMContext::MD_PROF_VP, nullptr);
   // If all promoted, we don't need the MD.prof metadata.
   if (SavedRemainCount > 0 || Version != NumVals)
     // Otherwise we need update with the un-promoted records back.
     annotateValueSite(*Func.getParent(), *MI, VDs.slice(Version),
                       SavedRemainCount, IPVK_MemOPSize, NumVals);
 
   DEBUG(dbgs() << "\n\n== Basic Block After==\n");
 
   for (uint64_t SizeId : SizeIds) {
     BasicBlock *CaseBB = BasicBlock::Create(
         Ctx, Twine("MemOP.Case.") + Twine(SizeId), &Func, DefaultBB);
     Instruction *NewInst = MI->clone();
     // Fix the argument.
     MemIntrinsic * MemI = dyn_cast<MemIntrinsic>(NewInst);
     IntegerType *SizeType = dyn_cast<IntegerType>(MemI->getLength()->getType());
     assert(SizeType && "Expected integer type size argument.");
     ConstantInt *CaseSizeId = ConstantInt::get(SizeType, SizeId);
     MemI->setLength(CaseSizeId);
     CaseBB->getInstList().push_back(NewInst);
     IRBuilder<> IRBCase(CaseBB);
     IRBCase.CreateBr(MergeBB);
     SI->addCase(CaseSizeId, CaseBB);
     DEBUG(dbgs() << *CaseBB << "\n");
   }
-  setProfMetadata(Func.getParent(), SI, CaseCounts, MaxCount);
+  setBranchWeightsMetadata(Func.getParent(), SI, CaseCounts, MaxCount);
 
   DEBUG(dbgs() << *BB << "\n");
   DEBUG(dbgs() << *DefaultBB << "\n");
   DEBUG(dbgs() << *MergeBB << "\n");
 
   {
     using namespace ore;
     ORE.emit(OptimizationRemark(DEBUG_TYPE, "memopt-opt", MI)

lib/Transforms/Scalar/JumpThreading.cpp

for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
     SmallVector<uint32_t, 2> Weights;
     if (PredBr->getSuccessor(0) == PredOutEdge.second) {
       Weights.push_back(BP.getNumerator());
       Weights.push_back(BP.getCompl().getNumerator());
     } else {
       Weights.push_back(BP.getCompl().getNumerator());
       Weights.push_back(BP.getNumerator());
     }
-    PredBr->setMetadata(LLVMContext::MD_prof,
+    PredBr->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                             MDBuilder(PredBr->getParent()->getContext())
                             .createBranchWeights(Weights));
   }
 }
 
 /// runOnFunction - Toplevel algorithm.
 bool JumpThreading::runOnFunction(Function &F) {
   if (skipFunction(F))
     return false;
if (HasProfileData)
     BFI->setBlockFreq(PredBB, PredBBFreq.getFrequency());
   return PredBB;
 }
 
 bool JumpThreadingPass::doesBlockHaveProfileData(BasicBlock *BB) {
   const TerminatorInst *TI = BB->getTerminator();
   assert(TI->getNumSuccessors() > 1 && "not a split");
 
-  MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
+  MDNode *WeightsNode =
+      TI->getProfMetadata(LLVMContext::MD_PROF_branch_weights);
   if (!WeightsNode)
     return false;
 
-  MDString *MDName = cast<MDString>(WeightsNode->getOperand(0));
-  if (MDName->getString() != "branch_weights")
-    return false;
-
   // Ensure there are weights for all of the successors. Note that the first
   // operand to the metadata node is a name, not a weight.
   return WeightsNode->getNumOperands() == TI->getNumSuccessors() + 1;
 }
 
 /// Update the block frequency of BB and branch weight and the metadata on the
 /// edge BB->SuccBB. This is done by scaling the weight of BB->SuccBB by 1 -
 /// Freq(PredBB->BB) / Freq(BB->SuccBB).
void JumpThreadingPass::UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB,
   // shouldn't make edges extremely likely or unlikely based solely on static
   // estimation.
   if (BBSuccProbs.size() >= 2 && doesBlockHaveProfileData(BB)) {
     SmallVector<uint32_t, 4> Weights;
     for (auto Prob : BBSuccProbs)
       Weights.push_back(Prob.getNumerator());
 
     auto TI = BB->getTerminator();
-    TI->setMetadata(
-        LLVMContext::MD_prof,
+    TI->setProfMetadata(
+        LLVMContext::MD_PROF_branch_weights,
         MDBuilder(TI->getParent()->getContext()).createBranchWeights(Weights));
   }
 }
 
 /// DuplicateCondBranchOnPHIIntoPred - PredBB contains an unconditional branch
 /// to BB which contains an i1 PHI node and a conditional branch on that PHI.
 /// If we can duplicate the contents of BB up into PredBB do so now, this
 /// improves the odds that the branch will be on an analyzable instruction like

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

static bool handleSwitchExpect(SwitchInst &SI) {
   unsigned n = SI.getNumCases(); // +1 for default case.
   SmallVector<uint32_t, 16> Weights(n + 1, UnlikelyBranchWeight);
 
   if (Case == *SI.case_default())
     Weights[0] = LikelyBranchWeight;
   else
     Weights[Case.getCaseIndex() + 1] = LikelyBranchWeight;
 
-  SI.setMetadata(LLVMContext::MD_prof,
+  SI.setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                      MDBuilder(CI->getContext()).createBranchWeights(Weights));
 
   SI.setCondition(ArgValue);
   return true;
 }
 
 /// Handler for PHINodes that define the value argument to an
 /// @llvm.expect call.
 ///
auto IsOpndComingFromSuccessor = [&](BasicBlock *Succ) {
         // Otherwise, if the edge is directly from the branch
         // to the Phi, this successor is the one feeding this
         // Phi operand.
         return true;
       return false;
     };
 
     if (IsOpndComingFromSuccessor(BI->getSuccessor(1)))
-      BI->setMetadata(
-          LLVMContext::MD_prof,
+      BI->setProfMetadata(
+          LLVMContext::MD_PROF_branch_weights,
           MDB.createBranchWeights(LikelyBranchWeight, UnlikelyBranchWeight));
     else if (IsOpndComingFromSuccessor(BI->getSuccessor(0)))
-      BI->setMetadata(
-          LLVMContext::MD_prof,
+      BI->setProfMetadata(
+          LLVMContext::MD_PROF_branch_weights,
           MDB.createBranchWeights(UnlikelyBranchWeight, LikelyBranchWeight));
   }
 }
 
 // Handle both BranchInst and SelectInst.
 template <class BrSelInst> static bool handleBrSelExpect(BrSelInst &BSI) {
 
   // Handle non-optimized IR code like:
template <class BrSelInst> static bool handleBrSelExpect(BrSelInst &BSI) {
   MDNode *Node;
 
   if ((ExpectedValue->getZExtValue() == ValueComparedTo) ==
       (Predicate == CmpInst::ICMP_EQ))
     Node = MDB.createBranchWeights(LikelyBranchWeight, UnlikelyBranchWeight);
   else
     Node = MDB.createBranchWeights(UnlikelyBranchWeight, LikelyBranchWeight);
 
-  BSI.setMetadata(LLVMContext::MD_prof, Node);
+  BSI.setProfMetadata(LLVMContext::MD_PROF_branch_weights, Node);
 
   if (CmpI)
     CmpI->setOperand(0, ArgValue);
   else
     BSI.setCondition(ArgValue);
   return true;
 }
 

lib/Transforms/Scalar/LowerGuardIntrinsic.cpp

static void MakeGuardControlFlowExplicit(Function *DeoptIntrinsic,
 
   CheckBI->getSuccessor(0)->setName("guarded");
   CheckBI->getSuccessor(1)->setName("deopt");
 
   if (auto *MD = CI->getMetadata(LLVMContext::MD_make_implicit))
     CheckBI->setMetadata(LLVMContext::MD_make_implicit, MD);
 
   MDBuilder MDB(CI->getContext());
-  CheckBI->setMetadata(LLVMContext::MD_prof,
-                       MDB.createBranchWeights(PredicatePassBranchWeight, 1));
+  CheckBI->setProfMetadata(
+      LLVMContext::MD_PROF_branch_weights,
 
   IRBuilder<> B(DeoptBlockTerm);
   auto *DeoptCall = B.CreateCall(DeoptIntrinsic, Args, {DeoptOB}, "");
 
   if (DeoptIntrinsic->getReturnType()->isVoidTy()) {
     B.CreateRetVoid();
   } else {
     DeoptCall->setName("deoptcall");

lib/Transforms/Utils/BasicBlockUtils.cpp

llvm::SplitBlockAndInsertIfThen(Value *Cond, Instruction *SplitBefore,
   TerminatorInst *CheckTerm;
   if (Unreachable)
     CheckTerm = new UnreachableInst(C, ThenBlock);
   else
     CheckTerm = BranchInst::Create(Tail, ThenBlock);
   CheckTerm->setDebugLoc(SplitBefore->getDebugLoc());
   BranchInst *HeadNewTerm =
     BranchInst::Create(/*ifTrue*/ThenBlock, /*ifFalse*/Tail, Cond);
-  HeadNewTerm->setMetadata(LLVMContext::MD_prof, BranchWeights);
+  HeadNewTerm->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                               BranchWeights);
   ReplaceInstWithInst(HeadOldTerm, HeadNewTerm);
 
   if (DT) {
     if (DomTreeNode *OldNode = DT->getNode(Head)) {
       std::vector<DomTreeNode *> Children(OldNode->begin(), OldNode->end());
 
       DomTreeNode *NewNode = DT->addNewBlock(Tail, Head);
       for (DomTreeNode *Child : Children)
void llvm::SplitBlockAndInsertIfThenElse(Value *Cond, Instruction *SplitBefore,
   BasicBlock *ThenBlock = BasicBlock::Create(C, "", Head->getParent(), Tail);
   BasicBlock *ElseBlock = BasicBlock::Create(C, "", Head->getParent(), Tail);
   *ThenTerm = BranchInst::Create(Tail, ThenBlock);
   (*ThenTerm)->setDebugLoc(SplitBefore->getDebugLoc());
   *ElseTerm = BranchInst::Create(Tail, ElseBlock);
   (*ElseTerm)->setDebugLoc(SplitBefore->getDebugLoc());
   BranchInst *HeadNewTerm =
     BranchInst::Create(/*ifTrue*/ThenBlock, /*ifFalse*/ElseBlock, Cond);
-  HeadNewTerm->setMetadata(LLVMContext::MD_prof, BranchWeights);
+  HeadNewTerm->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
+                               BranchWeights);
   ReplaceInstWithInst(HeadOldTerm, HeadNewTerm);
 }
 
 
 Value *llvm::GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue,
                              BasicBlock *&IfFalse) {
   PHINode *SomePHI = dyn_cast<PHINode>(BB->begin());
   BasicBlock *Pred1 = nullptr;

lib/Transforms/Utils/CodeExtractor.cpp

void CodeExtractor::calculateNewCallTerminatorWeights(
   for (unsigned I = 0, E = BranchDist.Weights.size(); I < E; ++I) {
     const auto &Weight = BranchDist.Weights[I];
 
     // Get the weight and update the current BFI.
     BranchWeights[Weight.TargetNode.Index] = Weight.Amount;
     BranchProbability BP(Weight.Amount, BranchDist.Total);
     BPI->setEdgeProbability(CodeReplacer, Weight.TargetNode.Index, BP);
   }
-  TI->setMetadata(
-      LLVMContext::MD_prof,
+  TI->setProfMetadata(
+      LLVMContext::MD_PROF_branch_weights,
       MDBuilder(TI->getContext()).createBranchWeights(BranchWeights));
 }
 
 Function *CodeExtractor::extractCodeRegion() {
   if (!isEligible())
     return nullptr;
 
   ValueSet inputs, outputs, SinkingCands, HoistingCands;

lib/Transforms/Utils/Local.cpp

 #define DEBUG_TYPE "local"
 
 STATISTIC(NumRemoved, "Number of unreachable basic blocks removed");
 
 //===----------------------------------------------------------------------===//
 //  Local constant propagation.
 //
 
+template<typename WeightIntType>
+static void mergeProfWeightToDefaultCase(SwitchInst *SI,
+                                         SwitchInst::CaseIt CaseIt,
+                                         MDNode *MD, unsigned MDProfKindId,
+                                         LLVMContext &Ctx) {
+  assert(MD == SI->getProfMetadata(MDProfKindId) && "Mismatching MD");
+  // Collect branch weights into a vector.
+  SmallVector<WeightIntType, 8> Weights;
+  for (unsigned i = 1, e = MD->getNumOperands(); i < e; ++i) {
+    auto *CI = mdconst::extract<ConstantInt>(MD->getOperand(i));
+    Weights.push_back(CI->getValue().getZExtValue());
+  }
+  // Merge weight of this case to the default weight.
+  unsigned idx = CaseIt->getCaseIndex();
+  Weights[0] += Weights[idx+1];
+  // Remove weight for this case.
+  std::swap(Weights[idx+1], Weights.back());
+  Weights.pop_back();
+  SI->setProfMetadata(MDProfKindId, MDBuilder(Ctx).
+                      createProfWeights<WeightIntType>(
+                          MDProfKindId, Weights));
+}
+
+template<typename WeightIntType>
+static void copyProfWeightToBranch(MDNode *MD, unsigned MDProfKindId,
+                                   BranchInst *Br, LLVMContext &Ctx) {
+  ConstantInt *SICase =
+      mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
+  ConstantInt *SIDef =
+      mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
+  assert(SICase && SIDef);
+  // The TrueWeight should be the weight for the single case of SI.
+  Br->setProfMetadata(
+      LLVMContext::MD_PROF_branch_weights,
+      MDBuilder(Ctx).
+      createProfWeights<WeightIntType>(MDProfKindId,
+                                       SICase->getValue().getZExtValue(),
+                                       SIDef->getValue().getZExtValue()));
+}
+
 /// ConstantFoldTerminator - If a terminator instruction is predicated on a
 /// constant value, convert it into an unconditional branch to the constant
 /// destination.  This is a nontrivial operation because the successors of this
 /// basic block must have their PHI nodes updated.
 /// Also calls RecursivelyDeleteTriviallyDeadInstructions() on any branch/switch
 /// conditions and indirectbr addresses this might make dead if
 /// DeleteDeadConditions is true.
 bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions,
for (auto i = SI->case_begin(), e = SI->case_end(); i != e;) {
       if (i->getCaseValue() == CI) {
         TheOnlyDest = i->getCaseSuccessor();
         break;
       }
 
       // Check to see if this branch is going to the same place as the default
       // dest.  If so, eliminate it as an explicit compare.
       if (i->getCaseSuccessor() == DefaultDest) {
-        MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
+        MDNode *MDBranchWeight =
+            SI->getProfMetadata(LLVMContext::MD_PROF_branch_weights);
         unsigned NCases = SI->getNumCases();
         // Fold the case metadata into the default if there will be any branches
         // left, unless the metadata doesn't match the switch.
-        if (NCases > 1 && MD && MD->getNumOperands() == 2 + NCases) {
-          // Collect branch weights into a vector.
-          SmallVector<uint32_t, 8> Weights;
-          for (unsigned MD_i = 1, MD_e = MD->getNumOperands(); MD_i < MD_e;
-               ++MD_i) {
-            auto *CI = mdconst::extract<ConstantInt>(MD->getOperand(MD_i));
-            Weights.push_back(CI->getValue().getZExtValue());
-          }
-          // Merge weight of this case to the default weight.
-          unsigned idx = i->getCaseIndex();
-          Weights[0] += Weights[idx+1];
-          // Remove weight for this case.
-          std::swap(Weights[idx+1], Weights.back());
-          Weights.pop_back();
-          SI->setMetadata(LLVMContext::MD_prof,
-                          MDBuilder(BB->getContext()).
-                          createBranchWeights(Weights));
+        if (NCases > 1 && MDBranchWeight &&
+            MDBranchWeight->getNumOperands() == 2 + NCases) {
+          mergeProfWeightToDefaultCase<uint32_t>(
+              SI, i, MDBranchWeight,
+              LLVMContext::MD_PROF_branch_weights, BB->getContext());
         }
         // Remove this entry.
         DefaultDest->removePredecessor(SI->getParent());
         i = SI->removeCase(i);
         e = SI->case_end();
         continue;
       }
 
if (SI->getNumCases() == 1) {
       auto FirstCase = *SI->case_begin();
       Value *Cond = Builder.CreateICmpEQ(SI->getCondition(),
           FirstCase.getCaseValue(), "cond");
 
       // Insert the new branch.
       BranchInst *NewBr = Builder.CreateCondBr(Cond,
                                                FirstCase.getCaseSuccessor(),
                                                SI->getDefaultDest());
-      MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
-      if (MD && MD->getNumOperands() == 3) {
-        ConstantInt *SICase =
-            mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
-        ConstantInt *SIDef =
-            mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
-        assert(SICase && SIDef);
-        // The TrueWeight should be the weight for the single case of SI.
-        NewBr->setMetadata(LLVMContext::MD_prof,
-                        MDBuilder(BB->getContext()).
-                        createBranchWeights(SICase->getValue().getZExtValue(),
-                                            SIDef->getValue().getZExtValue()));
+      MDNode *MDBranchWeight =
+          SI->getProfMetadata(LLVMContext::MD_PROF_branch_weights);
+      if (MDBranchWeight && MDBranchWeight->getNumOperands() == 3) {
+        copyProfWeightToBranch<uint32_t>(
+            MDBranchWeight, LLVMContext::MD_PROF_branch_weights,
+            NewBr, BB->getContext());
       }
 
       // Update make.implicit metadata to the newly-created conditional branch.
       MDNode *MakeImplicitMD = SI->getMetadata(LLVMContext::MD_make_implicit);
       if (MakeImplicitMD)
         NewBr->setMetadata(LLVMContext::MD_make_implicit, MakeImplicitMD);
 
       // Delete the old switch.

lib/Transforms/Utils/LoopUnrollPeel.cpp

if (PeeledHeaderWeight) {
     uint64_t ExitWeight = PeeledHeaderWeight - FallThruWeight;
     PeeledHeaderWeight -= ExitWeight;
 
     unsigned HeaderIdx = (LatchBR->getSuccessor(0) == Header ? 0 : 1);
     MDBuilder MDB(LatchBR->getContext());
     MDNode *WeightNode =
         HeaderIdx ? MDB.createBranchWeights(ExitWeight, FallThruWeight)
                   : MDB.createBranchWeights(FallThruWeight, ExitWeight);
-    LatchBR->setMetadata(LLVMContext::MD_prof, WeightNode);
+    LatchBR->setProfMetadata(LLVMContext::MD_PROF_branch_weights, WeightNode);
   }
 }
 
 /// \brief Clones the body of the loop L, putting it between \p InsertTop and \p
 /// InsertBot.
 /// \param IterNumber The serial number of the iteration currently being
 /// peeled off.
 /// \param Exit The exit block of the original loop.
if (ExitWeight) {
     if (ExitWeight < CurHeaderWeight)
       BackEdgeWeight = CurHeaderWeight - ExitWeight;
     else
       BackEdgeWeight = 1;
     MDBuilder MDB(LatchBR->getContext());
     MDNode *WeightNode =
         HeaderIdx ? MDB.createBranchWeights(ExitWeight, BackEdgeWeight)
                   : MDB.createBranchWeights(BackEdgeWeight, ExitWeight);
-    LatchBR->setMetadata(LLVMContext::MD_prof, WeightNode);
+    LatchBR->setProfMetadata(LLVMContext::MD_PROF_branch_weights, WeightNode);
   }
 
   // If the loop is nested, we changed the parent loop, update SE.
   if (Loop *ParentLoop = L->getParentLoop()) {
     SE->forgetLoop(ParentLoop);
 
     // FIXME: Incrementally update loop-simplify
     simplifyLoop(ParentLoop, DT, LI, SE, AC, PreserveLCSSA);

lib/Transforms/Utils/SimplifyCFG.cpp

if (PredDef == TI->getParent()) {
     for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
       DeadCases.insert(PredCases[i].Value);
 
     DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()
                  << "Through successor TI: " << *TI);
 
     // Collect branch weights into a vector.
     SmallVector<uint32_t, 8> Weights;
-    MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
+    MDNode *MD = SI->getProfMetadata(LLVMContext::MD_PROF_branch_weights);
     bool HasWeight = MD && (MD->getNumOperands() == 2 + SI->getNumCases());
     if (HasWeight)
       for (unsigned MD_i = 1, MD_e = MD->getNumOperands(); MD_i < MD_e;
            ++MD_i) {
         ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(MD_i));
         Weights.push_back(CI->getValue().getZExtValue());
       }
     for (SwitchInst::CaseIt i = SI->case_end(), e = SI->case_begin(); i != e;) {
       --i;
       if (DeadCases.count(i->getCaseValue())) {
         if (HasWeight) {
           std::swap(Weights[i->getCaseIndex() + 1], Weights.back());
           Weights.pop_back();
         }
         i->getCaseSuccessor()->removePredecessor(TI->getParent());
         SI->removeCase(i);
       }
     }
     if (HasWeight && Weights.size() >= 2)
-      SI->setMetadata(LLVMContext::MD_prof,
+      SI->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                           MDBuilder(SI->getParent()->getContext())
                           .createBranchWeights(Weights));
 
     DEBUG(dbgs() << "Leaving: " << *TI << "\n");
     return true;
   }
 
   // Otherwise, TI's block must correspond to some matched value.  Find out
   // which value (or set of values) this is.
static int ConstantIntSortPredicate(ConstantInt *const *P1,
   const ConstantInt *LHS = *P1;
   const ConstantInt *RHS = *P2;
   if (LHS == RHS)
     return 0;
   return LHS->getValue().ult(RHS->getValue()) ? 1 : -1;
 }
 
 static inline bool HasBranchWeights(const Instruction *I) {
-  MDNode *ProfMD = I->getMetadata(LLVMContext::MD_prof);
-  if (ProfMD && ProfMD->getOperand(0))
-    if (MDString *MDS = dyn_cast<MDString>(ProfMD->getOperand(0)))
-      return MDS->getString().equals("branch_weights");
-
-  return false;
+  return I->getProfMetadata(LLVMContext::MD_PROF_branch_weights) != nullptr;
 }
 
 /// Get Weights of a given TerminatorInst, the default weight is at the front
 /// of the vector. If TI is a conditional eq, we need to swap the branch-weight
 /// metadata.
 static void GetBranchWeights(TerminatorInst *TI,
                              SmallVectorImpl<uint64_t> &Weights) {
-  MDNode *MD = TI->getMetadata(LLVMContext::MD_prof);
+  MDNode *MD = TI->getProfMetadata(LLVMContext::MD_PROF_branch_weights);
   assert(MD);
   for (unsigned i = 1, e = MD->getNumOperands(); i < e; ++i) {
     ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(i));
     Weights.push_back(CI->getValue().getZExtValue());
   }
 
   // If TI is a conditional eq, the default case is the false case,
   // and the corresponding branch-weight data is at index 2. We swap the
if (PCV == CV && TI != PTI) {
         NewSI->addCase(V.Value, V.Dest);
 
       if (PredHasWeights || SuccHasWeights) {
         // Halve the weights if any of them cannot fit in an uint32_t
         FitWeights(Weights);
 
         SmallVector<uint32_t, 8> MDWeights(Weights.begin(), Weights.end());
 
-        NewSI->setMetadata(
-            LLVMContext::MD_prof,
+        NewSI->setProfMetadata(
+            LLVMContext::MD_PROF_branch_weights,
             MDBuilder(BB->getContext()).createBranchWeights(MDWeights));
       }
 
       EraseTerminatorInstAndDCECond(PTI);
 
       // Okay, last check.  If BB is still a successor of PSI, then we must
       // have an infinite loop case.  If so, add an infinitely looping block
       // to handle the case to preserve the behavior of the code.
if (BI->isConditional()) {
         PBI->setSuccessor(1, FalseDest);
       }
       if (NewWeights.size() == 2) {
         // Halve the weights if any of them cannot fit in an uint32_t
         FitWeights(NewWeights);
 
         SmallVector<uint32_t, 8> MDWeights(NewWeights.begin(),
                                            NewWeights.end());
-        PBI->setMetadata(
-            LLVMContext::MD_prof,
+        PBI->setProfMetadata(
+            LLVMContext::MD_PROF_branch_weights,
             MDBuilder(BI->getContext()).createBranchWeights(MDWeights));
       } else
-        PBI->setMetadata(LLVMContext::MD_prof, nullptr);
+        PBI->setProfMetadata(LLVMContext::MD_PROF_branch_weights, nullptr);
     } else {
       // Update PHI nodes in the common successors.
       for (unsigned i = 0, e = PHIs.size(); i != e; ++i) {
         ConstantInt *PBI_C = cast<ConstantInt>(
             PHIs[i]->getIncomingValueForBlock(PBI->getParent()));
         assert(PBI_C->getType()->isIntegerTy(1));
         Instruction *MergedCond = nullptr;
         if (PBI->getSuccessor(0) == TrueDest) {
if (HasWeights) {
     //                                    PredOther * SuccCommon.
     // The weight to OtherDest should be PredOther * SuccOther.
     uint64_t NewWeights[2] = {PredCommon * (SuccCommon + SuccOther) +
                                   PredOther * SuccCommon,
                               PredOther * SuccOther};
     // Halve the weights if any of them cannot fit in an uint32_t
     FitWeights(NewWeights);
 
-    PBI->setMetadata(LLVMContext::MD_prof,
+    PBI->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                          MDBuilder(BI->getContext())
                          .createBranchWeights(NewWeights[0], NewWeights[1]));
   }
 
   // OtherDest may have phi nodes.  If so, add an entry from PBI's
   // block that are identical to the entries for BI's block.
   AddPredecessorToBlock(OtherDest, PBI->getParent(), BB);
 
   // We know that the CommonDest already had an edge from PBI to
if (BIV != PBIV) {
         uint64_t SuccOther = BIOp ? SuccTrueWeight : SuccFalseWeight;
         // The weight to PredCommonDest should be PredCommon * SuccTotal.
         // The weight to PredOtherDest should be PredOther * SuccCommon.
         uint64_t NewWeights[2] = {PredCommon * (SuccCommon + SuccOther),
                                   PredOther * SuccCommon};
 
         FitWeights(NewWeights);
 
-        NV->setMetadata(LLVMContext::MD_prof,
+        NV->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                             MDBuilder(BI->getContext())
                             .createBranchWeights(NewWeights[0], NewWeights[1]));
       }
     }
   }
 
   DEBUG(dbgs() << "INTO: " << *PBI->getParent());
   DEBUG(dbgs() << *PBI->getParent()->getParent());
 
if (TrueBB == FalseBB)
       // We were only looking for one successor, and it was present.
       // Create an unconditional branch to it.
       Builder.CreateBr(TrueBB);
     else {
       // We found both of the successors we were looking for.
       // Create a conditional branch sharing the condition of the select.
       BranchInst *NewBI = Builder.CreateCondBr(Cond, TrueBB, FalseBB);
       if (TrueWeight != FalseWeight)
-        NewBI->setMetadata(LLVMContext::MD_prof,
+        NewBI->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                                MDBuilder(OldTerm->getContext())
                                .createBranchWeights(TrueWeight, FalseWeight));
     }
   } else if (KeepEdge1 && (KeepEdge2 || TrueBB == FalseBB)) {
     // Neither of the selected blocks were successors, so this
     // terminator must be unreachable.
     new UnreachableInst(OldTerm->getContext(), OldTerm);
   } else {
     // One of the selected values was a successor, but the other wasn't.
static bool TryToSimplifyUncondBranchWithICmpInIt(
   if (HasWeights) {
     GetBranchWeights(SI, Weights);
     if (Weights.size() == 1 + SI->getNumCases()) {
       // Split weight for default case to case for "Cst".
       Weights[0] = (Weights[0] + 1) >> 1;
       Weights.push_back(Weights[0]);
 
       SmallVector<uint32_t, 8> MDWeights(Weights.begin(), Weights.end());
-      SI->setMetadata(
-          LLVMContext::MD_prof,
+      SI->setProfMetadata(
+          LLVMContext::MD_PROF_branch_weights,
           MDBuilder(SI->getContext()).createBranchWeights(MDWeights));
     }
   }
   SI->addCase(Cst, NewBB);
 
   // NewBB branches to the phi block, add the uncond branch and the phi entry.
   Builder.SetInsertPoint(NewBB);
   Builder.SetCurrentDebugLocation(SI->getDebugLoc());
if (Weights.size() == 1 + SI->getNumCases()) {
           TrueWeight += Weights[I];
         else
           FalseWeight += Weights[I];
       }
       while (TrueWeight > UINT32_MAX || FalseWeight > UINT32_MAX) {
         TrueWeight /= 2;
         FalseWeight /= 2;
       }
-      NewBI->setMetadata(LLVMContext::MD_prof,
+      NewBI->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                              MDBuilder(SI->getContext())
                              .createBranchWeights((uint32_t)TrueWeight,
                                                   (uint32_t)FalseWeight));
     }
   }
 
   // Prune obsolete incoming values off the successors' PHI nodes.
   for (auto BBI = ContiguousDest->begin(); isa<PHINode>(BBI); ++BBI) {
     unsigned PreviousEdges = ContiguousCases->size();
for (ConstantInt *DeadCase : DeadCases) {
     }
 
     // Prune unused values from PHI nodes.
     CaseI->getCaseSuccessor()->removePredecessor(SI->getParent());
     SI->removeCase(CaseI);
   }
   if (HasWeight && Weights.size() >= 2) {
     SmallVector<uint32_t, 8> MDWeights(Weights.begin(), Weights.end());
-    SI->setMetadata(LLVMContext::MD_prof,
+    SI->setProfMetadata(LLVMContext::MD_PROF_branch_weights,
                         MDBuilder(SI->getParent()->getContext())
                         .createBranchWeights(MDWeights));
   }
 
   return !DeadCases.empty();
 }
 
 /// If BB would be eligible for simplification by
 /// TryToSimplifyUncondBranchFromEmptyBlock (i.e. it is empty and terminated

test/Analysis/BlockFrequencyInfo/two_level_prof.ll

+; RUN: opt < %s -analyze -block-freq | FileCheck %s
+; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
+
+define i32 @test1(i32 %i, i32 %a, i32 %b) {
+; CHECK-LABEL: Printing analysis {{.*}} for function 'test1':
+; CHECK-NEXT: block-frequency-info: test1
+; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
+entry:
+  %cond = icmp ult i32 %i, 42
+  br i1 %cond, label %then, label %else, !prof !0
+
+; The 'then' branch is predicted more likely via branch weight metadata.
+; CHECK-NEXT: then: float = 0.9411{{[0-9]*}},
+then:
+  br label %exit
+
+; CHECK-NEXT: else: float = 0.05882{{[0-9]*}},
+else:
+  br label %exit
+
+; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
+exit:
+  %result = phi i32 [ %a, %then ], [ %b, %else ]
+  ret i32 %result
+}
+
+define i32 @test2(i32 %i, i32 %a, i32 %b) {
+; CHECK-LABEL: Printing analysis {{.*}} for function 'test2':
+; CHECK-NEXT: block-frequency-info: test2
+; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
+entry:
+  %cond = icmp ult i32 %i, 42
+  br i1 %cond, label %then, label %else, !prof !1
+
+; The 'then' branch is predicted more likely via branch weight metadata.
+; CHECK-NEXT: then: float = 0.9411{{[0-9]*}},
+then:
+  br label %exit
+
+; CHECK-NEXT: else: float = 0.05882{{[0-9]*}},
+else:
+  br label %exit
+
+; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
+exit:
+  %result = phi i32 [ %a, %then ], [ %b, %else ]
+  ret i32 %result
+}
+
+!0 = !{!"branch_weights", i32 64, i32 4}
+!1 = !{!1, !2, !3, !4}
+!2 = !{!"foo"}
+!3 = !{!"branch_weights", i32 64, i32 4}
+!4 = !{!"bar"}

test/Transforms/SimplifyCFG/preserve-branchweights.ll

Z:
   call void @helper(i32 1)
   ret void
 }
 
 define void @test2(i1 %a, i1 %b) {
 ; CHECK-LABEL: @test2(
 entry:
   br i1 %a, label %X, label %Y, !prof !1
-; CHECK: br i1 %or.cond, label %Z, label %Y, !prof !2
+; CHECK: br i1 %or.cond, label %Z, label %Y, !prof !4
 ; CHECK-NOT: !prof
 
 X:
   %c = or i1 %b, false
   br i1 %c, label %Z, label %Y, !prof !2
 
 Y:
   call void @helper(i32 0)
   ret void
 
 Z:
   call void @helper(i32 1)
   ret void
 }
 
 define void @test3(i1 %a, i1 %b) {
 ; CHECK-LABEL: @test3(
-; CHECK: br i1 %or.cond, label %Z, label %Y, !prof !1
+; CHECK: br i1 %or.cond, label %Z, label %Y, !prof !3
 entry:
   br i1 %a, label %X, label %Y, !prof !1
 
 X:
   %c = or i1 %b, false
   br i1 %c, label %Z, label %Y
 
 Y:
   call void @helper(i32 0)
   ret void
 
 Z:
   call void @helper(i32 1)
   ret void
 }
 
 define void @test4(i1 %a, i1 %b) {
 ; CHECK-LABEL: @test4(
-; CHECK: br i1 %or.cond, label %Z, label %Y, !prof !1
+; CHECK: br i1 %or.cond, label %Z, label %Y, !prof !3
 entry:
   br i1 %a, label %X, label %Y
 
 X:
   %c = or i1 %b, false
   br i1 %c, label %Z, label %Y, !prof !1
 
 Y:
switch i32 %N, label %sw2 [
     i32 1, label %sw2
     i32 2, label %sw.bb
     i32 3, label %sw.bb1
   ], !prof !3
 ; CHECK-LABEL: @test5(
 ; CHECK: switch i32 %N, label %sw2 [
 ; CHECK: i32 3, label %sw.bb1
 ; CHECK: i32 2, label %sw.bb
-; CHECK: ], !prof !3
+; CHECK: ], !prof !5
 
 sw.bb:
   call void @helper(i32 0)
   br label %sw.epilog
 
 sw.bb1:
   call void @helper(i32 1)
   br label %sw.epilog
switch i32 %N, label %sw2 [
     i32 2, label %sw.bb
     i32 3, label %sw.bb1
   ], !prof !4
 ; CHECK-LABEL: @test6(
 ; CHECK: switch i32 %N, label %sw.epilog
 ; CHECK: i32 3, label %sw.bb1
 ; CHECK: i32 2, label %sw.bb
 ; CHECK: i32 4, label %sw.bb5
-; CHECK: ], !prof !4
+; CHECK: ], !prof !6
 
 sw.bb:
   call void @helper(i32 0)
   br label %sw.epilog
 
 sw.bb1:
   call void @helper(i32 1)
   br label %sw.epilog
sw.epilog:
   ret void
 }
 
 ;; This test is based on test1 but swapped the targets of the second branch.
 define void @test1_swap(i1 %a, i1 %b) {
 ; CHECK-LABEL: @test1_swap(
 entry:
   br i1 %a, label %Y, label %X, !prof !0
-; CHECK: br i1 %or.cond, label %Y, label %Z, !prof !5
+; CHECK: br i1 %or.cond, label %Y, label %Z, !prof !7
 
 X:
   %c = or i1 %b, false
   br i1 %c, label %Y, label %Z, !prof !1
 
 Y:
   call void @helper(i32 0)
   ret void
 
 Z:
   call void @helper(i32 1)
   ret void
 }
 
 define void @test7(i1 %a, i1 %b) {
 ; CHECK-LABEL: @test7(
 entry:
   %c = or i1 %b, false
   br i1 %a, label %Y, label %X, !prof !0
-; CHECK: br i1 %brmerge, label %Y, label %Z, !prof !6
+; CHECK: br i1 %brmerge, label %Y, label %Z, !prof !8
 
 X:
   br i1 %c, label %Y, label %Z, !prof !6
 
 Y:
   call void @helper(i32 0)
   ret void
 
 Z:
   call void @helper(i32 1)
   ret void
 }
 
 ; Test basic folding to a conditional branch.
 define void @test8(i64 %x, i64 %y) nounwind {
 ; CHECK-LABEL: @test8(
 entry:
     %lt = icmp slt i64 %x, %y
-; CHECK: br i1 %lt, label %a, label %b, !prof !7
+; CHECK: br i1 %lt, label %a, label %b, !prof !9
     %qux = select i1 %lt, i32 0, i32 2
     switch i32 %qux, label %bees [
         i32 0, label %a
         i32 1, label %b
         i32 2, label %b
     ], !prof !7
 a:
     call void @helper(i32 0) nounwind
switch i32 %x, label %bees [
         i32 1, label %end
         i32 2, label %end
     ], !prof !7
 ; CHECK: switch i32 %x, label %bees [
 ; CHECK: i32 0, label %a
 ; CHECK: i32 1, label %end
 ; CHECK: i32 2, label %end
 ; CHECK: i32 92, label %end
-; CHECK: ], !prof !8
+; CHECK: ], !prof !10
 
 a:
     call void @helper(i32 0) nounwind
     %reta = icmp slt i32 %x, %y
     ret i1 %reta
 
 bees:
     %tmp = icmp eq i32 %x, 92

 
 lor.end:
  call void @helper(i32 0) nounwind
  ret void
 
 ; CHECK-LABEL: @test10(
 ; CHECK: %x.off = add i32 %x, -1
 ; CHECK: %switch = icmp ult i32 %x.off, 3
-; CHECK: br i1 %switch, label %lor.end, label %lor.rhs, !prof !9
+; CHECK: br i1 %switch, label %lor.end, label %lor.rhs, !prof !11
 }
 
 ; Remove dead cases from the switch.
 define void @test11(i32 %x) nounwind {
   %i = shl i32 %x, 1
   switch i32 %i, label %a [
     i32 21, label %b
     i32 24, label %c
   ], !prof !8
 ; CHECK-LABEL: @test11(
 ; CHECK: %cond = icmp eq i32 %i, 24
-; CHECK: br i1 %cond, label %c, label %a, !prof !10
+; CHECK: br i1 %cond, label %c, label %a, !prof !12
 
 a:
  call void @helper(i32 0) nounwind
  ret void
 b:
  call void @helper(i32 1) nounwind
  ret void
 c:

 }
 
 ;; When folding branches to common destination, the updated branch weights
 ;; can exceed uint32 by more than factor of 2. We should keep halving the
 ;; weights until they can fit into uint32.
 @max_regno = common global i32 0, align 4
 define void @test14(i32* %old, i32 %final) {
 ; CHECK-LABEL: @test14
-; CHECK: br i1 %or.cond, label %for.exit, label %for.inc, !prof !11
+; CHECK: br i1 %or.cond, label %for.exit, label %for.inc, !prof !13
 for.cond:
   br label %for.cond2
 for.cond2:
   %i.1 = phi i32 [ %inc19, %for.inc ], [ 0, %for.cond ]
   %bit.0 = phi i32 [ %shl, %for.inc ], [ 1, %for.cond ]
   %tobool = icmp eq i32 %bit.0, 0
   br i1 %tobool, label %for.exit, label %for.body3, !prof !10
 for.body3:

 }
 
 ; Don't drop the metadata.
 
 define i32 @HoistThenElseCodeToIf(i32 %n) {
 ; CHECK-LABEL: @HoistThenElseCodeToIf(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 %n, 0
-; CHECK-NEXT:    [[DOT:%.*]] = select i1 [[TOBOOL]], i32 1, i32 234, !prof !12
+; CHECK-NEXT:    [[DOT:%.*]] = select i1 [[TOBOOL]], i32 1, i32 234, !prof !14
 ; CHECK-NEXT:    ret i32 [[DOT]]
 ;
 entry:
   %tobool = icmp eq i32 %n, 0
   br i1 %tobool, label %if, label %else, !prof !0
 
 if:
   br label %return
 
 else:
   br label %return
 
 return:
   %retval.0 = phi i32 [ 1, %if ], [ 234, %else ]
   ret i32 %retval.0
 }
 
 ; The selects should have freshly calculated branch weights.
 
 define i32 @SimplifyCondBranchToCondBranch(i1 %cmpa, i1 %cmpb) {
 ; CHECK-LABEL: @SimplifyCondBranchToCondBranch(
 ; CHECK-NEXT:  block1:
 ; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 %cmpa, %cmpb
-; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 %cmpa, i32 0, i32 2, !prof !13
-; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !14
+; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 %cmpa, i32 0, i32 2, !prof !15
+; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !16
 ; CHECK-NEXT:    ret i32 [[OUTVAL]]
 ;
 block1:
   br i1 %cmpa, label %block3, label %block2, !prof !13
 
 block2:
   br i1 %cmpb, label %block3, label %exit, !prof !14
 

 ; Swap the operands of the compares to verify that the weights update correctly.
 
 define i32 @SimplifyCondBranchToCondBranchSwap(i1 %cmpa, i1 %cmpb) {
 ; CHECK-LABEL: @SimplifyCondBranchToCondBranchSwap(
 ; CHECK-NEXT:  block1:
 ; CHECK-NEXT:    [[CMPA_NOT:%.*]] = xor i1 %cmpa, true
 ; CHECK-NEXT:    [[CMPB_NOT:%.*]] = xor i1 %cmpb, true
 ; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 [[CMPA_NOT]], [[CMPB_NOT]]
-; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof !15
-; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !16
+; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof !17
+; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !18
 ; CHECK-NEXT:    ret i32 [[OUTVAL]]
 ;
 block1:
   br i1 %cmpa, label %block2, label %block3, !prof !13
 
 block2:
   br i1 %cmpb, label %exit, label %block3, !prof !14
 
 block3:
   %cowval = phi i32 [ 2, %block2 ], [ 0, %block1 ]
   br label %exit
 
 exit:
   %outval = phi i32 [ %cowval, %block3 ], [ 1, %block2 ]
   ret i32 %outval
 }
 
 define i32 @SimplifyCondBranchToCondBranchSwapMissingWeight(i1 %cmpa, i1 %cmpb) {
 ; CHECK-LABEL: @SimplifyCondBranchToCondBranchSwapMissingWeight(
 ; CHECK-NEXT:  block1:
 ; CHECK-NEXT:    [[CMPA_NOT:%.*]] = xor i1 %cmpa, true 
 ; CHECK-NEXT:    [[CMPB_NOT:%.*]] = xor i1 %cmpb, true
 ; CHECK-NEXT:    [[BRMERGE:%.*]] = or i1 [[CMPA_NOT]], [[CMPB_NOT]]
-; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof !17
-; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !18
+; CHECK-NEXT:    [[DOTMUX:%.*]] = select i1 [[CMPA_NOT]], i32 0, i32 2, !prof !19
+; CHECK-NEXT:    [[OUTVAL:%.*]] = select i1 [[BRMERGE]], i32 [[DOTMUX]], i32 1, !prof !20
 ; CHECK-NEXT:    ret i32 [[OUTVAL]]
 ;
 block1:
   br i1 %cmpa, label %block2, label %block3, !prof !13
 
 block2:
   br i1 %cmpb, label %exit, label %block3
 

 !9 = !{!"branch_weights", i32 7, i32 6}
 !10 = !{!"branch_weights", i32 672646, i32 21604207}
 !11 = !{!"branch_weights", i32 6960, i32 21597248}
 !12 = !{!"these_are_not_the_branch_weights_you_are_looking_for", i32 3, i32 5}
 !13 = !{!"branch_weights", i32 2, i32 3}
 !14 = !{!"branch_weights", i32 4, i32 7}
 
 ; CHECK: !0 = !{!"branch_weights", i32 5, i32 11}
-; CHECK: !1 = !{!"branch_weights", i32 1, i32 3}
-; CHECK: !2 = !{!"branch_weights", i32 1, i32 5}
-; CHECK: !3 = !{!"branch_weights", i32 7, i32 1, i32 2}
-; CHECK: !4 = !{!"branch_weights", i32 49, i32 12, i32 24, i32 35}
-; CHECK: !5 = !{!"branch_weights", i32 11, i32 5}
-; CHECK: !6 = !{!"branch_weights", i32 17, i32 15}
-; CHECK: !7 = !{!"branch_weights", i32 9, i32 7}
-; CHECK: !8 = !{!"branch_weights", i32 17, i32 9, i32 8, i32 7, i32 17}
-; CHECK: !9 = !{!"branch_weights", i32 24, i32 33}
-; CHECK: !10 = !{!"branch_weights", i32 8, i32 33}
+; CHECK: !1 = distinct !{!1, !2, !3}
+; CHECK: !2 = !{!"these_are_not_the_branch_weights_you_are_looking_for", i32 3, i32 5}
+; CHECK: !3 = !{!"branch_weights", i32 1, i32 3}
+; CHECK: !4 = !{!"branch_weights", i32 1, i32 5}
+; CHECK: !5 = !{!"branch_weights", i32 7, i32 1, i32 2}
+; CHECK: !6 = !{!"branch_weights", i32 49, i32 12, i32 24, i32 35}
+; CHECK: !7 = !{!"branch_weights", i32 11, i32 5}
+; CHECK: !8 = !{!"branch_weights", i32 17, i32 15}
+; CHECK: !9 = !{!"branch_weights", i32 9, i32 7}
+; CHECK: !10 = !{!"branch_weights", i32 17, i32 9, i32 8, i32 7, i32 17}
+; CHECK: !11 = !{!"branch_weights", i32 24, i32 33}
+; CHECK: !12 = !{!"branch_weights", i32 8, i32 33}
 ;; The false weight prints out as a negative integer here, but inside llvm, we
 ;; treat the weight as an unsigned integer.
-; CHECK: !11 = !{!"branch_weights", i32 112017436, i32 -735157296}
-; CHECK: !12 = !{!"branch_weights", i32 3, i32 5}
-; CHECK: !13 = !{!"branch_weights", i32 22, i32 12}
-; CHECK: !14 = !{!"branch_weights", i32 34, i32 21}
-; CHECK: !15 = !{!"branch_weights", i32 33, i32 14}
-; CHECK: !16 = !{!"branch_weights", i32 47, i32 8}
-; CHECK: !17 = !{!"branch_weights", i32 6, i32 2}
-; CHECK: !18 = !{!"branch_weights", i32 8, i32 2}
+; CHECK: !13 = !{!"branch_weights", i32 112017436, i32 -735157296}
+; CHECK: !14 = !{!"branch_weights", i32 3, i32 5}
+; CHECK: !15 = !{!"branch_weights", i32 22, i32 12}
+; CHECK: !16 = !{!"branch_weights", i32 34, i32 21}
+; CHECK: !17 = !{!"branch_weights", i32 33, i32 14}
+; CHECK: !18 = !{!"branch_weights", i32 47, i32 8}
+; CHECK: !19 = !{!"branch_weights", i32 6, i32 2}
+; CHECK: !20 = !{!"branch_weights", i32 8, i32 2}