diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -9271,6 +9271,12 @@
 This metadata can only be applied to loads of a pointer type. If the returned
 value is not appropriately aligned at runtime, the behavior is undefined.
 
+The optional ``!noundef`` metadata must reference a single metadata name
+``<empty_node>`` corresponding to a node with no entries. The existence of
+``!noundef`` metadata on the instruction tells the optimizer that the value
+loaded is known to be :ref:`well defined <_welldefinedvalues>`.
+If the value isn't well defined, the behavior is undefined.
+
 Semantics:
 """"""""""
 
diff --git a/llvm/docs/LangRef.rst.rej b/llvm/docs/LangRef.rst.rej
new file mode 100644
--- /dev/null
+++ b/llvm/docs/LangRef.rst.rej
@@ -0,0 +1,77 @@
+diff a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst	(rejected hunks)
+@@ -9149,10 +9149,11 @@
+ 
+ ::
+ 
+-      <result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.load !<index>][, !invariant.group !<index>][, !nonnull !<index>][, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node>][, !align !<align_node>]
+-      <result> = load atomic [volatile] <ty>, <ty>* <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<index>]
+-      !<index> = !{ i32 1 }
+-      !<deref_bytes_node> = !{i64 <dereferenceable_bytes>}
++      <result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<nontemp_node>][, !invariant.load !<empty_node>][, !invariant.group !<empty_node>][, !nonnull !<empty_node>][, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node>][, !align !<align_node>][, !noundef !<empty_node>]
++      <result> = load atomic [volatile] <ty>, <ty>* <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<empty_node>]
++      !<nontemp_node> = !{ i32 1 }
++      !<empty_node> = !{}
++      !<deref_bytes_node> = !{ i64 <dereferenceable_bytes> }
+       !<align_node> = !{ i64 <value_alignment> }
+ 
+ Overview:
+@@ -9196,27 +9197,25 @@
+ ``sanitize_thread`` or ``sanitize_address`` attributes.
+ 
+ The optional ``!nontemporal`` metadata must reference a single
+-metadata name ``<index>`` corresponding to a metadata node with one
+-``i32`` entry of value 1. The existence of the ``!nontemporal``
++metadata node ``<nontemp_node>`` corresponding to a node with one ``i32``
++entry of value 1. The existence of the ``!nontemporal``
+ metadata on the instruction tells the optimizer and code generator
+ that this load is not expected to be reused in the cache. The code
+ generator may select special instructions to save cache bandwidth, such
+ as the ``MOVNT`` instruction on x86.
+ 
+-The optional ``!invariant.load`` metadata must reference a single
+-metadata name ``<index>`` corresponding to a metadata node with no
+-entries. If a load instruction tagged with the ``!invariant.load``
++The optional ``!invariant.load`` metadata must reference a single metadata
++node with no entries. If a load instruction tagged with the ``!invariant.load``
+ metadata is executed, the optimizer may assume the memory location
+ referenced by the load contains the same value at all points in the
+ program where the memory location is known to be dereferenceable;
+ otherwise, the behavior is undefined.
+ 
+-The optional ``!invariant.group`` metadata must reference a single metadata name
+- ``<index>`` corresponding to a metadata node with no entries.
+- See ``invariant.group`` metadata :ref:`invariant.group <md_invariant.group>`
++The optional ``!invariant.group`` metadata must reference a single metadata
++node with no entries. See ``invariant.group`` metadata :ref:`invariant.group
++<md_invariant.group>`
+ 
+-The optional ``!nonnull`` metadata must reference a single
+-metadata name ``<index>`` corresponding to a metadata node with no
++The optional ``!nonnull`` metadata must reference a single metadata node with no
+ entries. The existence of the ``!nonnull`` metadata on the
+ instruction tells the optimizer that the value loaded is known to
+ never be null. If the value is null at runtime, the behavior is undefined.
+@@ -9224,18 +9223,17 @@
+ values. This metadata can only be applied to loads of a pointer type.
+ 
+ The optional ``!dereferenceable`` metadata must reference a single metadata
+-name ``<deref_bytes_node>`` corresponding to a metadata node with one ``i64``
+-entry.
++node ``<deref_bytes_node>`` corresponding to a node with one ``i64`` entry.
+ See ``dereferenceable`` metadata :ref:`dereferenceable <md_dereferenceable>`
+ 
+ The optional ``!dereferenceable_or_null`` metadata must reference a single
+-metadata name ``<deref_bytes_node>`` corresponding to a metadata node with one
+-``i64`` entry.
++metadata node ``<deref_bytes_node>`` corresponding to a node with one ``i64``
++entry.
+ See ``dereferenceable_or_null`` metadata :ref:`dereferenceable_or_null
+ <md_dereferenceable_or_null>`
+ 
+-The optional ``!align`` metadata must reference a single metadata name
+-``<align_node>`` corresponding to a metadata node with one ``i64`` entry.
++The optional ``!align`` metadata must reference a single metadata node
++``<align_node>`` corresponding to a node with one ``i64`` entry.
+ The existence of the ``!align`` metadata on the instruction tells the
+ optimizer that the value loaded is known to be aligned to a boundary specified
+ by the integer value in the metadata node. The alignment must be a power of 2.
diff --git a/llvm/include/llvm/IR/FixedMetadataKinds.def b/llvm/include/llvm/IR/FixedMetadataKinds.def
--- a/llvm/include/llvm/IR/FixedMetadataKinds.def
+++ b/llvm/include/llvm/IR/FixedMetadataKinds.def
@@ -41,3 +41,4 @@
 LLVM_FIXED_MD_KIND(MD_preserve_access_index, "llvm.preserve.access.index", 27)
 LLVM_FIXED_MD_KIND(MD_misexpect, "misexpect", 28)
 LLVM_FIXED_MD_KIND(MD_vcall_visibility, "vcall_visibility", 29)
+LLVM_FIXED_MD_KIND(MD_noundef, "noundef", 30)
\ No newline at end of file
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -4892,6 +4892,10 @@
       return true;
   }
 
+  if (auto *I = dyn_cast<LoadInst>(V))
+    if (I->getMetadata(LLVMContext::MD_noundef))
+      return true;
+
   if (programUndefinedIfUndefOrPoison(V, PoisonOnly))
     return true;
 
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
--- a/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
@@ -522,6 +522,7 @@
       break;
     case LLVMContext::MD_invariant_load:
     case LLVMContext::MD_nonnull:
+    case LLVMContext::MD_noundef:
     case LLVMContext::MD_range:
     case LLVMContext::MD_align:
     case LLVMContext::MD_dereferenceable:
diff --git a/llvm/test/Transforms/InstSimplify/freeze-noundef.ll b/llvm/test/Transforms/InstSimplify/freeze-noundef.ll
--- a/llvm/test/Transforms/InstSimplify/freeze-noundef.ll
+++ b/llvm/test/Transforms/InstSimplify/freeze-noundef.ll
@@ -104,3 +104,23 @@
   %f = freeze i1 %y
   ret i1 %f
 }
+
+define i32 @noundef_metadata(i32* %p) {
+; CHECK-LABEL: @noundef_metadata(
+; CHECK-NEXT:    [[V:%.*]] = load i32, i32* [[P:%.*]], align 4, !noundef !0
+; CHECK-NEXT:    ret i32 [[V]]
+;
+  %v = load i32, i32* %p, !noundef !{}
+  %v.fr = freeze i32 %v
+  ret i32 %v.fr
+}
+
+define {i8, i32} @noundef_metadata2({i8, i32}* %p) {
+; CHECK-LABEL: @noundef_metadata2(
+; CHECK-NEXT:    [[V:%.*]] = load { i8, i32 }, { i8, i32 }* [[P:%.*]], align 4, !noundef !0
+; CHECK-NEXT:    ret { i8, i32 } [[V]]
+;
+  %v = load {i8, i32}, {i8, i32}* %p, !noundef !{}
+  %v.fr = freeze {i8, i32} %v
+  ret {i8, i32} %v.fr
+}