diff --git a/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp b/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
@@ -92,7 +92,7 @@ TEST(DebugPubSection, TestDebugPubSection) {
   ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
 
   ASSERT_TRUE(Data.PubNames.has_value());
-  DWARFYAML::PubSection PubNames = Data.PubNames.getValue();
+  DWARFYAML::PubSection PubNames = Data.PubNames.value();
 
   ASSERT_EQ(PubNames.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)PubNames.Entries[0].DieOffset, 0x1234u);
@@ -101,7 +101,7 @@ TEST(DebugPubSection, TestDebugPubSection) {
   EXPECT_EQ(PubNames.Entries[1].Name, "def");
 
   ASSERT_TRUE(Data.PubTypes.has_value());
-  DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue();
+  DWARFYAML::PubSection PubTypes = Data.PubTypes.value();
 
   ASSERT_EQ(PubTypes.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)PubTypes.Entries[0].DieOffset, 0x1234u);
@@ -158,7 +158,7 @@ TEST(DebugGNUPubSection, TestDebugGNUPubSections) {
   ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
 
   ASSERT_TRUE(Data.GNUPubNames.has_value());
-  DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue();
+  DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.value();
 
   ASSERT_EQ(GNUPubNames.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)GNUPubNames.Entries[0].DieOffset, 0x1234u);
@@ -169,7 +169,7 @@ TEST(DebugGNUPubSection, TestDebugGNUPubSections) {
   EXPECT_EQ(GNUPubNames.Entries[1].Name, "def");
 
   ASSERT_TRUE(Data.GNUPubTypes.has_value());
-  DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue();
+  DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.value();
 
   ASSERT_EQ(GNUPubTypes.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)GNUPubTypes.Entries[0].DieOffset, 0x1234u);

diff --git a/llvm/unittests/ProfileData/MemProfTest.cpp b/llvm/unittests/ProfileData/MemProfTest.cpp
@@ -104,9 +104,9 @@ MATCHER_P4(FrameContains, FunctionName, LineOffset, Column, Inline, "") {
     *result_listener << "Hash mismatch";
     return false;
   }
-  if (F.SymbolName && F.SymbolName.getValue() != FunctionName) {
+  if (F.SymbolName && F.SymbolName.value() != FunctionName) {
     *result_listener << "SymbolName mismatch\nWant: " << FunctionName
-                     << "\nGot: " << F.SymbolName.getValue();
+                     << "\nGot: " << F.SymbolName.value();
     return false;
   }
   if (F.LineOffset == LineOffset && F.Column == Column &&

diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp
@@ -150,8 +150,8 @@ TEST(AlignmentTest, isAligned_isAddrAligned) {
     MaybeAlign A(T.alignment);
     // Test Align
     if (A) {
-      EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
-      EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
+      EXPECT_EQ(isAligned(A.value(), T.offset), T.isAligned);
+      EXPECT_EQ(isAddrAligned(A.value(), T.forgedAddr()), T.isAligned);
     }
   }
 }

diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp
@@ -369,27 +369,27 @@ TEST(KnownBitsTest, ICmpExhaustive) {
       EXPECT_EQ(AllSLT || NoneSLT, KnownSLT.has_value());
       EXPECT_EQ(AllSLE || NoneSLE, KnownSLE.has_value());
 
-      EXPECT_EQ(AllEQ, KnownEQ.has_value() && KnownEQ.getValue());
-      EXPECT_EQ(AllNE, KnownNE.has_value() && KnownNE.getValue());
-      EXPECT_EQ(AllUGT, KnownUGT.has_value() && KnownUGT.getValue());
-      EXPECT_EQ(AllUGE, KnownUGE.has_value() && KnownUGE.getValue());
-      EXPECT_EQ(AllULT, KnownULT.has_value() && KnownULT.getValue());
-      EXPECT_EQ(AllULE, KnownULE.has_value() && KnownULE.getValue());
-      EXPECT_EQ(AllSGT, KnownSGT.has_value() && KnownSGT.getValue());
-      EXPECT_EQ(AllSGE, KnownSGE.has_value() && KnownSGE.getValue());
-      EXPECT_EQ(AllSLT, KnownSLT.has_value() && KnownSLT.getValue());
-      EXPECT_EQ(AllSLE, KnownSLE.has_value() && KnownSLE.getValue());
-
-      EXPECT_EQ(NoneEQ, KnownEQ.has_value() && !KnownEQ.getValue());
-      EXPECT_EQ(NoneNE, KnownNE.has_value() && !KnownNE.getValue());
-      EXPECT_EQ(NoneUGT, KnownUGT.has_value() && !KnownUGT.getValue());
-      EXPECT_EQ(NoneUGE, KnownUGE.has_value() && !KnownUGE.getValue());
-      EXPECT_EQ(NoneULT, KnownULT.has_value() && !KnownULT.getValue());
-      EXPECT_EQ(NoneULE, KnownULE.has_value() && !KnownULE.getValue());
-      EXPECT_EQ(NoneSGT, KnownSGT.has_value() && !KnownSGT.getValue());
-      EXPECT_EQ(NoneSGE, KnownSGE.has_value() && !KnownSGE.getValue());
-      EXPECT_EQ(NoneSLT, KnownSLT.has_value() && !KnownSLT.getValue());
-      EXPECT_EQ(NoneSLE, KnownSLE.has_value() && !KnownSLE.getValue());
+      EXPECT_EQ(AllEQ, KnownEQ.has_value() && KnownEQ.value());
+      EXPECT_EQ(AllNE, KnownNE.has_value() && KnownNE.value());
+      EXPECT_EQ(AllUGT, KnownUGT.has_value() && KnownUGT.value());
+      EXPECT_EQ(AllUGE, KnownUGE.has_value() && KnownUGE.value());
+      EXPECT_EQ(AllULT, KnownULT.has_value() && KnownULT.value());
+      EXPECT_EQ(AllULE, KnownULE.has_value() && KnownULE.value());
+      EXPECT_EQ(AllSGT, KnownSGT.has_value() && KnownSGT.value());
+      EXPECT_EQ(AllSGE, KnownSGE.has_value() && KnownSGE.value());
+      EXPECT_EQ(AllSLT, KnownSLT.has_value() && KnownSLT.value());
+      EXPECT_EQ(AllSLE, KnownSLE.has_value() && KnownSLE.value());
+
+      EXPECT_EQ(NoneEQ, KnownEQ.has_value() && !KnownEQ.value());
+      EXPECT_EQ(NoneNE, KnownNE.has_value() && !KnownNE.value());
+      EXPECT_EQ(NoneUGT, KnownUGT.has_value() && !KnownUGT.value());
+      EXPECT_EQ(NoneUGE, KnownUGE.has_value() && !KnownUGE.value());
+      EXPECT_EQ(NoneULT, KnownULT.has_value() && !KnownULT.value());
+      EXPECT_EQ(NoneULE, KnownULE.has_value() && !KnownULE.value());
+      EXPECT_EQ(NoneSGT, KnownSGT.has_value() && !KnownSGT.value());
+      EXPECT_EQ(NoneSGE, KnownSGE.has_value() && !KnownSGE.value());
+      EXPECT_EQ(NoneSLT, KnownSLT.has_value() && !KnownSLT.value());
+      EXPECT_EQ(NoneSLE, KnownSLE.has_value() && !KnownSLE.value());
     });
   });
 }

diff --git a/llvm/unittests/TableGen/ParserEntryPointTest.cpp b/llvm/unittests/TableGen/ParserEntryPointTest.cpp
@@ -36,5 +36,5 @@ TEST(Parser, SanityTest) {
   Record *Foo = Records.getDef("Foo");
   Optional<StringRef> Field = Foo->getValueAsOptionalString("strField");
   EXPECT_TRUE(Field.has_value());
-  EXPECT_EQ(Field.getValue(), "value");
+  EXPECT_EQ(Field.value(), "value");
 }
diff --git a/llvm/utils/TableGen/GlobalISelEmitter.cpp b/llvm/utils/TableGen/GlobalISelEmitter.cpp
@@ -2970,7 +2970,7 @@ class RenderComplexPatternOperand : public OperandRenderer {
           << MatchTable::IntValue(RendererID);
     if (SubOperand)
       Table << MatchTable::Comment("SubOperand")
-            << MatchTable::IntValue(SubOperand.getValue());
+            << MatchTable::IntValue(SubOperand.value());
     Table << MatchTable::Comment(SymbolicName) << MatchTable::LineBreak;
   }
 };
@@ -4986,8 +4986,8 @@ Error GlobalISelEmitter::importDefaultOperandRenderers(
       auto Def = DefaultDefOp->getDef();
       if (Def->getName() == "undef_tied_input") {
         unsigned TempRegID = M.allocateTempRegID();
-        M.insertAction<MakeTempRegisterAction>(
-          InsertPt, OpTyOrNone.getValue(), TempRegID);
+        M.insertAction<MakeTempRegisterAction>(InsertPt, OpTyOrNone.value(),
+                                               TempRegID);
         InsertPt = M.insertAction<BuildMIAction>(
           InsertPt, M.allocateOutputInsnID(),
           &Target.getInstruction(RK.getDef("IMPLICIT_DEF")));