diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h
index fb6bbc0163701..9bbd14d753958 100644
--- a/llvm/include/llvm/TargetParser/Triple.h
+++ b/llvm/include/llvm/TargetParser/Triple.h
@@ -370,8 +370,7 @@ class Triple {
   enum class CanonicalForm {
     ANY = 0,
     THREE_IDENT = 3, // ARCHITECTURE-VENDOR-OPERATING_SYSTEM
-    FOUR_IDENT = 4,  // ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT
-    FIVE_IDENT = 5,  // ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT-FORMAT
+    FOUR_IDENT = 4, // ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT(-FORMAT)
   };
 
   /// Turn an arbitrary machine specification into the canonical triple form (or
diff --git a/llvm/lib/TargetParser/Triple.cpp b/llvm/lib/TargetParser/Triple.cpp
index e9e6f130f757c..be350a73e75df 100644
--- a/llvm/lib/TargetParser/Triple.cpp
+++ b/llvm/lib/TargetParser/Triple.cpp
@@ -1162,11 +1162,12 @@ std::string Triple::normalize(StringRef Str, CanonicalForm Form) {
 
   // Note which components are already in their final position.  These will not
   // be moved.
-  bool Found[4];
+  bool Found[5];
   Found[0] = Arch != UnknownArch;
   Found[1] = Vendor != UnknownVendor;
   Found[2] = OS != UnknownOS;
   Found[3] = Environment != UnknownEnvironment;
+  Found[4] = ObjectFormat != UnknownObjectFormat;
 
   // If they are not there already, permute the components into their canonical
   // positions by seeing if they parse as a valid architecture, and if so moving
@@ -1202,10 +1203,10 @@ std::string Triple::normalize(StringRef Str, CanonicalForm Form) {
       case 3:
         Environment = parseEnvironment(Comp);
         Valid = Environment != UnknownEnvironment;
-        if (!Valid) {
-          ObjectFormat = parseFormat(Comp);
-          Valid = ObjectFormat != UnknownObjectFormat;
-        }
+        break;
+      case 4:
+        ObjectFormat = parseFormat(Comp);
+        Valid = ObjectFormat != UnknownObjectFormat;
         break;
       }
       if (!Valid)
@@ -1265,6 +1266,14 @@ std::string Triple::normalize(StringRef Str, CanonicalForm Form) {
     }
   }
 
+  // Environment "unknown-elf" is just "elf".
+  if (ObjectFormat != UnknownObjectFormat &&
+      (Components[3] == "unknown" || Components[3].empty())) {
+    Found[3] = true;
+    std::swap(Components[3], Components[4]);
+    Components.pop_back();
+  }
+
   // If "none" is in the middle component in a three-component triple, treat it
   // as the OS (Components[2]) instead of the vendor (Components[1]).
   if (Found[0] && !Found[1] && !Found[2] && Found[3] &&
@@ -1335,16 +1344,23 @@ std::string Triple::normalize(StringRef Str, CanonicalForm Form) {
     }
   }
 
+  // Leave out unknown object format from the string representation.
+  if (ObjectFormat == UnknownObjectFormat && Components.size() == 5)
+    Components.pop_back();
+
   // Canonicalize the components if necessary.
   switch (Form) {
   case CanonicalForm::ANY:
     break;
-  case CanonicalForm::THREE_IDENT:
-  case CanonicalForm::FOUR_IDENT:
-  case CanonicalForm::FIVE_IDENT: {
+  case CanonicalForm::THREE_IDENT: {
     Components.resize(static_cast<unsigned>(Form), "unknown");
     break;
   }
+  case CanonicalForm::FOUR_IDENT: {
+    if (Components.size() < 4)
+      Components.resize(static_cast<unsigned>(Form), "unknown");
+    break;
+  }
   }
 
   // Stick the corrected components back together to form the normalized string.
diff --git a/llvm/unittests/TargetParser/TripleTest.cpp b/llvm/unittests/TargetParser/TripleTest.cpp
index 61b3637bb48e2..ebfed202105af 100644
--- a/llvm/unittests/TargetParser/TripleTest.cpp
+++ b/llvm/unittests/TargetParser/TripleTest.cpp
@@ -1384,8 +1384,7 @@ TEST(TripleTest, Normalization) {
   EXPECT_EQ("unknown-unknown", Triple::normalize("-"));
   EXPECT_EQ("unknown-unknown-unknown", Triple::normalize("--"));
   EXPECT_EQ("unknown-unknown-unknown-unknown", Triple::normalize("---"));
-  EXPECT_EQ("unknown-unknown-unknown-unknown-unknown",
-            Triple::normalize("----"));
+  EXPECT_EQ("unknown-unknown-unknown-unknown", Triple::normalize("----"));
 
   EXPECT_EQ("a", Triple::normalize("a"));
   EXPECT_EQ("a-b", Triple::normalize("a-b"));
@@ -1403,7 +1402,7 @@ TEST(TripleTest, Normalization) {
   EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
 
   EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
-  EXPECT_EQ("unknown-unknown-linux-b-c", Triple::normalize("linux-b-c"));
+  EXPECT_EQ("unknown-unknown-linux-b-elf", Triple::normalize("linux-b-elf"));
   EXPECT_EQ("a-unknown-linux-c", Triple::normalize("a-linux-c"));
 
   EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
@@ -1438,27 +1437,15 @@ TEST(TripleTest, Normalization) {
             Triple::normalize("a-b-c-d", Triple::CanonicalForm::FOUR_IDENT));
   EXPECT_EQ("a-b-c-d",
             Triple::normalize("a-b-c-d-e", Triple::CanonicalForm::FOUR_IDENT));
-
-  EXPECT_EQ("a-unknown-unknown-unknown-unknown",
-            Triple::normalize("a", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("a-b-unknown-unknown-unknown",
-            Triple::normalize("a-b", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("a-b-c-unknown-unknown",
-            Triple::normalize("a-b-c", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("a-b-c-d-unknown",
-            Triple::normalize("a-b-c-d", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("a-b-c-d-e",
-            Triple::normalize("a-b-c-d-e", Triple::CanonicalForm::FIVE_IDENT));
+  EXPECT_EQ(
+      "a-b-c-d-elf",
+      Triple::normalize("a-b-c-d-elf", Triple::CanonicalForm::FOUR_IDENT));
 
   EXPECT_EQ("i386-b-c-unknown",
             Triple::normalize("i386-b-c", Triple::CanonicalForm::FOUR_IDENT));
-  EXPECT_EQ("i386-b-c-unknown-unknown",
-            Triple::normalize("i386-b-c", Triple::CanonicalForm::FIVE_IDENT));
 
   EXPECT_EQ("i386-a-c-unknown",
             Triple::normalize("a-i386-c", Triple::CanonicalForm::FOUR_IDENT));
-  EXPECT_EQ("i386-a-c-unknown-unknown",
-            Triple::normalize("a-i386-c", Triple::CanonicalForm::FIVE_IDENT));
 
   EXPECT_EQ("i386-a-b-unknown",
             Triple::normalize("a-b-i386", Triple::CanonicalForm::FOUR_IDENT));
@@ -1502,46 +1489,24 @@ TEST(TripleTest, Normalization) {
       "x86_64-unknown-linux-gnu",
       Triple::normalize("x86_64-gnu-linux", Triple::CanonicalForm::FOUR_IDENT));
 
-  EXPECT_EQ("i386-a-b-unknown-unknown",
-            Triple::normalize("a-b-i386", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("i386-a-b-c-unknown",
-            Triple::normalize("a-b-c-i386", Triple::CanonicalForm::FIVE_IDENT));
-
-  EXPECT_EQ("a-pc-c-unknown-unknown",
-            Triple::normalize("a-pc-c", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("unknown-pc-b-c-unknown",
-            Triple::normalize("pc-b-c", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("a-pc-b-unknown-unknown",
-            Triple::normalize("a-b-pc", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("a-pc-b-c-unknown",
-            Triple::normalize("a-b-c-pc", Triple::CanonicalForm::FIVE_IDENT));
-
-  EXPECT_EQ("a-b-linux-unknown-unknown",
-            Triple::normalize("a-b-linux", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("unknown-unknown-linux-b-c",
-            Triple::normalize("linux-b-c", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("a-unknown-linux-c-unknown",
-            Triple::normalize("a-linux-c", Triple::CanonicalForm::FIVE_IDENT));
-
-  EXPECT_EQ("i386-pc-a-unknown-unknown",
-            Triple::normalize("a-pc-i386", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("i386-pc-unknown-unknown-unknown",
-            Triple::normalize("-pc-i386", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("unknown-pc-linux-c-unknown",
-            Triple::normalize("linux-pc-c", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("unknown-pc-linux-unknown-unknown",
-            Triple::normalize("linux-pc-", Triple::CanonicalForm::FIVE_IDENT));
-
-  EXPECT_EQ("i386-unknown-unknown-unknown-unknown",
-            Triple::normalize("i386", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("unknown-pc-unknown-unknown-unknown",
-            Triple::normalize("pc", Triple::CanonicalForm::FIVE_IDENT));
-  EXPECT_EQ("unknown-unknown-linux-unknown-unknown",
-            Triple::normalize("linux", Triple::CanonicalForm::FIVE_IDENT));
-
-  EXPECT_EQ(
-      "x86_64-unknown-linux-gnu-unknown",
-      Triple::normalize("x86_64-gnu-linux", Triple::CanonicalForm::FIVE_IDENT));
+  EXPECT_EQ("arm-unknown-linux-gnueabi",
+            Triple::normalize("arm-linux-gnueabi",
+                              Triple::CanonicalForm::FOUR_IDENT));
+  EXPECT_EQ("arm-unknown-linux-gnueabi-elf",
+            Triple::normalize("arm-linux-gnueabi-elf",
+                              Triple::CanonicalForm::FOUR_IDENT));
+  EXPECT_EQ("arm-unknown-linux-gnueabi",
+            Triple::normalize("arm-linux-gnueabi-xyz",
+                              Triple::CanonicalForm::FOUR_IDENT));
+  EXPECT_EQ("arm-unknown-linux-gnueabi",
+            Triple::normalize("arm-linux-gnueabi-unknown",
+                              Triple::CanonicalForm::FOUR_IDENT));
+  EXPECT_EQ("arm-unknown-linux-gnueabi",
+            Triple::normalize("arm-unknown-linux-gnueabi-unknown",
+                              Triple::CanonicalForm::FOUR_IDENT));
+  EXPECT_EQ("arm-unknown-linux-gnueabi",
+            Triple::normalize("arm-unknown-linux-gnueabi-xyz",
+                              Triple::CanonicalForm::ANY));
 
   // Check that normalizing a permutated set of valid components returns a
   // triple with the unpermuted components.