diff --git a/llvm/include/llvm/MC/MCParser/AsmLexer.h b/llvm/include/llvm/MC/MCParser/AsmLexer.h
index 735b0c1..d1599dc 100644
--- a/llvm/include/llvm/MC/MCParser/AsmLexer.h
+++ b/llvm/include/llvm/MC/MCParser/AsmLexer.h
@@ -13,16 +13,182 @@
 #ifndef LLVM_MC_MCPARSER_ASMLEXER_H
 #define LLVM_MC_MCPARSER_ASMLEXER_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCParser/MCAsmLexer.h"
+#include "llvm/MC/MCAsmMacro.h"
+#include <cassert>
+#include <cstddef>
 #include <string>
+#include <utility>
 
 namespace llvm {
 
 class MCAsmInfo;
 
+/// A callback class which is notified of each comment in an assembly file as
+/// it is lexed.
+class AsmCommentConsumer {
+public:
+  virtual ~AsmCommentConsumer() = default;
+
+  /// Callback function for when a comment is lexed. Loc is the start of the
+  /// comment text (excluding the comment-start marker). CommentText is the text
+  /// of the comment, excluding the comment start and end markers, and the
+  /// newline for single-line comments.
+  virtual void HandleComment(SMLoc Loc, StringRef CommentText) = 0;
+};
+
+/// Generic assembler lexer interface, for use by target specific assembly
+/// lexers.
+class MCAsmLexer {
+  /// The current token, stored in the base class for faster access.
+  SmallVector<AsmToken, 1> CurTok;
+
+  /// The location and description of the current error
+  SMLoc ErrLoc;
+  std::string Err;
+
+protected: // Can only create subclasses.
+  const char *TokStart = nullptr;
+  bool SkipSpace = true;
+  bool AllowAtInIdentifier = false;
+  bool AllowHashInIdentifier = false;
+  bool IsAtStartOfStatement = true;
+  bool LexMasmHexFloats = false;
+  bool LexMasmIntegers = false;
+  bool LexMasmStrings = false;
+  bool LexMotorolaIntegers = false;
+  bool UseMasmDefaultRadix = false;
+  unsigned DefaultRadix = 10;
+  bool LexHLASMIntegers = false;
+  bool LexHLASMStrings = false;
+  AsmCommentConsumer *CommentConsumer = nullptr;
+
+  MCAsmLexer();
+
+  virtual AsmToken LexToken() = 0;
+
+  void SetError(SMLoc errLoc, const std::string &err) {
+    ErrLoc = errLoc;
+    Err = err;
+  }
+
+public:
+  MCAsmLexer(const MCAsmLexer &) = delete;
+  MCAsmLexer &operator=(const MCAsmLexer &) = delete;
+  virtual ~MCAsmLexer();
+
+  /// Consume the next token from the input stream and return it.
+  ///
+  /// The lexer will continuously return the end-of-file token once the end of
+  /// the main input file has been reached.
+  const AsmToken &Lex() {
+    assert(!CurTok.empty());
+    // Mark if we parsing out a EndOfStatement.
+    IsAtStartOfStatement = CurTok.front().getKind() == AsmToken::EndOfStatement;
+    CurTok.erase(CurTok.begin());
+    // LexToken may generate multiple tokens via UnLex but will always return
+    // the first one. Place returned value at head of CurTok vector.
+    if (CurTok.empty()) {
+      AsmToken T = LexToken();
+      CurTok.insert(CurTok.begin(), T);
+    }
+    return CurTok.front();
+  }
+
+  void UnLex(AsmToken const &Token) {
+    IsAtStartOfStatement = false;
+    CurTok.insert(CurTok.begin(), Token);
+  }
+
+  bool isAtStartOfStatement() { return IsAtStartOfStatement; }
+
+  virtual StringRef LexUntilEndOfStatement() = 0;
+
+  /// Get the current source location.
+  SMLoc getLoc() const;
+
+  /// Get the current (last) lexed token.
+  const AsmToken &getTok() const { return CurTok[0]; }
+
+  /// Look ahead at the next token to be lexed.
+  const AsmToken peekTok(bool ShouldSkipSpace = true) {
+    AsmToken Tok;
+
+    MutableArrayRef<AsmToken> Buf(Tok);
+    size_t ReadCount = peekTokens(Buf, ShouldSkipSpace);
+
+    assert(ReadCount == 1);
+    (void)ReadCount;
+
+    return Tok;
+  }
+
+  /// Look ahead an arbitrary number of tokens.
+  virtual size_t peekTokens(MutableArrayRef<AsmToken> Buf,
+                            bool ShouldSkipSpace = true) = 0;
+
+  /// Get the current error location
+  SMLoc getErrLoc() { return ErrLoc; }
+
+  /// Get the current error string
+  const std::string &getErr() { return Err; }
+
+  /// Get the kind of current token.
+  AsmToken::TokenKind getKind() const { return getTok().getKind(); }
+
+  /// Check if the current token has kind \p K.
+  bool is(AsmToken::TokenKind K) const { return getTok().is(K); }
+
+  /// Check if the current token has kind \p K.
+  bool isNot(AsmToken::TokenKind K) const { return getTok().isNot(K); }
+
+  /// Set whether spaces should be ignored by the lexer
+  void setSkipSpace(bool val) { SkipSpace = val; }
+
+  bool getAllowAtInIdentifier() { return AllowAtInIdentifier; }
+  void setAllowAtInIdentifier(bool v) { AllowAtInIdentifier = v; }
+
+  void setAllowHashInIdentifier(bool V) { AllowHashInIdentifier = V; }
+
+  void setCommentConsumer(AsmCommentConsumer *CommentConsumer) {
+    this->CommentConsumer = CommentConsumer;
+  }
+
+  /// Set whether to lex masm-style binary (e.g., 0b1101) and radix-specified
+  /// literals (e.g., 0ABCh [hex], 576t [decimal], 77o [octal], 1101y [binary]).
+  void setLexMasmIntegers(bool V) { LexMasmIntegers = V; }
+
+  /// Set whether to use masm-style default-radix integer literals. If disabled,
+  /// assume decimal unless prefixed (e.g., 0x2c [hex], 077 [octal]).
+  void useMasmDefaultRadix(bool V) { UseMasmDefaultRadix = V; }
+
+  unsigned getMasmDefaultRadix() const { return DefaultRadix; }
+  void setMasmDefaultRadix(unsigned Radix) { DefaultRadix = Radix; }
+
+  /// Set whether to lex masm-style hex float literals, such as 3f800000r.
+  void setLexMasmHexFloats(bool V) { LexMasmHexFloats = V; }
+
+  /// Set whether to lex masm-style string literals, such as 'Can''t find file'
+  /// and "This ""value"" not found".
+  void setLexMasmStrings(bool V) { LexMasmStrings = V; }
+
+  /// Set whether to lex Motorola-style integer literals, such as $deadbeef or
+  /// %01010110.
+  void setLexMotorolaIntegers(bool V) { LexMotorolaIntegers = V; }
+
+  /// Set whether to lex HLASM-flavour integers. For now this is only [0-9]*
+  void setLexHLASMIntegers(bool V) { LexHLASMIntegers = V; }
+
+  /// Set whether to "lex" HLASM-flavour character and string literals. For now,
+  /// setting this option to true, will disable lexing for character and string
+  /// literals.
+  void setLexHLASMStrings(bool V) { LexHLASMStrings = V; }
+};
+
 /// AsmLexer - Lexer class for assembly files.
-class AsmLexer : public MCAsmLexer {
+class AsmLexer final : public MCAsmLexer {
   const MCAsmInfo &MAI;
 
   const char *CurPtr = nullptr;
diff --git a/llvm/include/llvm/MC/MCParser/MCAsmLexer.h b/llvm/include/llvm/MC/MCParser/MCAsmLexer.h
index 61b89b9a..0b00453 100644
--- a/llvm/include/llvm/MC/MCParser/MCAsmLexer.h
+++ b/llvm/include/llvm/MC/MCParser/MCAsmLexer.h
@@ -6,187 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_MC_MCPARSER_MCASMLEXER_H
-#define LLVM_MC_MCPARSER_MCASMLEXER_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/MC/MCAsmMacro.h"
-#include <cassert>
-#include <cstddef>
-#include <string>
-#include <utility>
-
-namespace llvm {
-
-/// A callback class which is notified of each comment in an assembly file as
-/// it is lexed.
-class AsmCommentConsumer {
-public:
-  virtual ~AsmCommentConsumer() = default;
-
-  /// Callback function for when a comment is lexed. Loc is the start of the
-  /// comment text (excluding the comment-start marker). CommentText is the text
-  /// of the comment, excluding the comment start and end markers, and the
-  /// newline for single-line comments.
-  virtual void HandleComment(SMLoc Loc, StringRef CommentText) = 0;
-};
-
-
-/// Generic assembler lexer interface, for use by target specific assembly
-/// lexers.
-class MCAsmLexer {
-  /// The current token, stored in the base class for faster access.
-  SmallVector<AsmToken, 1> CurTok;
-
-  /// The location and description of the current error
-  SMLoc ErrLoc;
-  std::string Err;
-
-protected: // Can only create subclasses.
-  const char *TokStart = nullptr;
-  bool SkipSpace = true;
-  bool AllowAtInIdentifier = false;
-  bool AllowHashInIdentifier = false;
-  bool IsAtStartOfStatement = true;
-  bool LexMasmHexFloats = false;
-  bool LexMasmIntegers = false;
-  bool LexMasmStrings = false;
-  bool LexMotorolaIntegers = false;
-  bool UseMasmDefaultRadix = false;
-  unsigned DefaultRadix = 10;
-  bool LexHLASMIntegers = false;
-  bool LexHLASMStrings = false;
-  AsmCommentConsumer *CommentConsumer = nullptr;
-
-  MCAsmLexer();
-
-  virtual AsmToken LexToken() = 0;
-
-  void SetError(SMLoc errLoc, const std::string &err) {
-    ErrLoc = errLoc;
-    Err = err;
-  }
-
-public:
-  MCAsmLexer(const MCAsmLexer &) = delete;
-  MCAsmLexer &operator=(const MCAsmLexer &) = delete;
-  virtual ~MCAsmLexer();
-
-  /// Consume the next token from the input stream and return it.
-  ///
-  /// The lexer will continuously return the end-of-file token once the end of
-  /// the main input file has been reached.
-  const AsmToken &Lex() {
-    assert(!CurTok.empty());
-    // Mark if we parsing out a EndOfStatement.
-    IsAtStartOfStatement = CurTok.front().getKind() == AsmToken::EndOfStatement;
-    CurTok.erase(CurTok.begin());
-    // LexToken may generate multiple tokens via UnLex but will always return
-    // the first one. Place returned value at head of CurTok vector.
-    if (CurTok.empty()) {
-      AsmToken T = LexToken();
-      CurTok.insert(CurTok.begin(), T);
-    }
-    return CurTok.front();
-  }
-
-  void UnLex(AsmToken const &Token) {
-    IsAtStartOfStatement = false;
-    CurTok.insert(CurTok.begin(), Token);
-  }
-
-  bool isAtStartOfStatement() { return IsAtStartOfStatement; }
-
-  virtual StringRef LexUntilEndOfStatement() = 0;
-
-  /// Get the current source location.
-  SMLoc getLoc() const;
-
-  /// Get the current (last) lexed token.
-  const AsmToken &getTok() const {
-    return CurTok[0];
-  }
-
-  /// Look ahead at the next token to be lexed.
-  const AsmToken peekTok(bool ShouldSkipSpace = true) {
-    AsmToken Tok;
-
-    MutableArrayRef<AsmToken> Buf(Tok);
-    size_t ReadCount = peekTokens(Buf, ShouldSkipSpace);
-
-    assert(ReadCount == 1);
-    (void)ReadCount;
-
-    return Tok;
-  }
-
-  /// Look ahead an arbitrary number of tokens.
-  virtual size_t peekTokens(MutableArrayRef<AsmToken> Buf,
-                            bool ShouldSkipSpace = true) = 0;
-
-  /// Get the current error location
-  SMLoc getErrLoc() {
-    return ErrLoc;
-  }
-
-  /// Get the current error string
-  const std::string &getErr() {
-    return Err;
-  }
-
-  /// Get the kind of current token.
-  AsmToken::TokenKind getKind() const { return getTok().getKind(); }
-
-  /// Check if the current token has kind \p K.
-  bool is(AsmToken::TokenKind K) const { return getTok().is(K); }
-
-  /// Check if the current token has kind \p K.
-  bool isNot(AsmToken::TokenKind K) const { return getTok().isNot(K); }
-
-  /// Set whether spaces should be ignored by the lexer
-  void setSkipSpace(bool val) { SkipSpace = val; }
-
-  bool getAllowAtInIdentifier() { return AllowAtInIdentifier; }
-  void setAllowAtInIdentifier(bool v) { AllowAtInIdentifier = v; }
-
-  void setAllowHashInIdentifier(bool V) { AllowHashInIdentifier = V; }
-
-  void setCommentConsumer(AsmCommentConsumer *CommentConsumer) {
-    this->CommentConsumer = CommentConsumer;
-  }
-
-  /// Set whether to lex masm-style binary (e.g., 0b1101) and radix-specified
-  /// literals (e.g., 0ABCh [hex], 576t [decimal], 77o [octal], 1101y [binary]).
-  void setLexMasmIntegers(bool V) { LexMasmIntegers = V; }
-
-  /// Set whether to use masm-style default-radix integer literals. If disabled,
-  /// assume decimal unless prefixed (e.g., 0x2c [hex], 077 [octal]).
-  void useMasmDefaultRadix(bool V) { UseMasmDefaultRadix = V; }
-
-  unsigned getMasmDefaultRadix() const { return DefaultRadix; }
-  void setMasmDefaultRadix(unsigned Radix) { DefaultRadix = Radix; }
-
-  /// Set whether to lex masm-style hex float literals, such as 3f800000r.
-  void setLexMasmHexFloats(bool V) { LexMasmHexFloats = V; }
-
-  /// Set whether to lex masm-style string literals, such as 'Can''t find file'
-  /// and "This ""value"" not found".
-  void setLexMasmStrings(bool V) { LexMasmStrings = V; }
-
-  /// Set whether to lex Motorola-style integer literals, such as $deadbeef or
-  /// %01010110.
-  void setLexMotorolaIntegers(bool V) { LexMotorolaIntegers = V; }
-
-  /// Set whether to lex HLASM-flavour integers. For now this is only [0-9]*
-  void setLexHLASMIntegers(bool V) { LexHLASMIntegers = V; }
-
-  /// Set whether to "lex" HLASM-flavour character and string literals. For now,
-  /// setting this option to true, will disable lexing for character and string
-  /// literals.
-  void setLexHLASMStrings(bool V) { LexHLASMStrings = V; }
-};
-
-} // end namespace llvm
-
-#endif // LLVM_MC_MCPARSER_MCASMLEXER_H
+#include "llvm/MC/MCParser/AsmLexer.h"
diff --git a/llvm/lib/MC/MCParser/AsmLexer.cpp b/llvm/lib/MC/MCParser/AsmLexer.cpp
index 8715f94..4899336 100644
--- a/llvm/lib/MC/MCParser/AsmLexer.cpp
+++ b/llvm/lib/MC/MCParser/AsmLexer.cpp
@@ -21,6 +21,7 @@
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cctype>
 #include <cstdio>
@@ -31,6 +32,91 @@
 
 using namespace llvm;
 
+MCAsmLexer::MCAsmLexer() { CurTok.emplace_back(AsmToken::Space, StringRef()); }
+
+MCAsmLexer::~MCAsmLexer() = default;
+
+SMLoc MCAsmLexer::getLoc() const { return SMLoc::getFromPointer(TokStart); }
+
+SMLoc AsmToken::getLoc() const { return SMLoc::getFromPointer(Str.data()); }
+
+SMLoc AsmToken::getEndLoc() const {
+  return SMLoc::getFromPointer(Str.data() + Str.size());
+}
+
+SMRange AsmToken::getLocRange() const { return SMRange(getLoc(), getEndLoc()); }
+
+void AsmToken::dump(raw_ostream &OS) const {
+  switch (Kind) {
+  case AsmToken::Error:
+    OS << "error";
+    break;
+  case AsmToken::Identifier:
+    OS << "identifier: " << getString();
+    break;
+  case AsmToken::Integer:
+    OS << "int: " << getString();
+    break;
+  case AsmToken::Real:
+    OS << "real: " << getString();
+    break;
+  case AsmToken::String:
+    OS << "string: " << getString();
+    break;
+
+    // clang-format off
+  case AsmToken::Amp:                OS << "Amp"; break;
+  case AsmToken::AmpAmp:             OS << "AmpAmp"; break;
+  case AsmToken::At:                 OS << "At"; break;
+  case AsmToken::BackSlash:          OS << "BackSlash"; break;
+  case AsmToken::BigNum:             OS << "BigNum"; break;
+  case AsmToken::Caret:              OS << "Caret"; break;
+  case AsmToken::Colon:              OS << "Colon"; break;
+  case AsmToken::Comma:              OS << "Comma"; break;
+  case AsmToken::Comment:            OS << "Comment"; break;
+  case AsmToken::Dollar:             OS << "Dollar"; break;
+  case AsmToken::Dot:                OS << "Dot"; break;
+  case AsmToken::EndOfStatement:     OS << "EndOfStatement"; break;
+  case AsmToken::Eof:                OS << "Eof"; break;
+  case AsmToken::Equal:              OS << "Equal"; break;
+  case AsmToken::EqualEqual:         OS << "EqualEqual"; break;
+  case AsmToken::Exclaim:            OS << "Exclaim"; break;
+  case AsmToken::ExclaimEqual:       OS << "ExclaimEqual"; break;
+  case AsmToken::Greater:            OS << "Greater"; break;
+  case AsmToken::GreaterEqual:       OS << "GreaterEqual"; break;
+  case AsmToken::GreaterGreater:     OS << "GreaterGreater"; break;
+  case AsmToken::Hash:               OS << "Hash"; break;
+  case AsmToken::HashDirective:      OS << "HashDirective"; break;
+  case AsmToken::LBrac:              OS << "LBrac"; break;
+  case AsmToken::LCurly:             OS << "LCurly"; break;
+  case AsmToken::LParen:             OS << "LParen"; break;
+  case AsmToken::Less:               OS << "Less"; break;
+  case AsmToken::LessEqual:          OS << "LessEqual"; break;
+  case AsmToken::LessGreater:        OS << "LessGreater"; break;
+  case AsmToken::LessLess:           OS << "LessLess"; break;
+  case AsmToken::Minus:              OS << "Minus"; break;
+  case AsmToken::MinusGreater:       OS << "MinusGreater"; break;
+  case AsmToken::Percent:            OS << "Percent"; break;
+  case AsmToken::Pipe:               OS << "Pipe"; break;
+  case AsmToken::PipePipe:           OS << "PipePipe"; break;
+  case AsmToken::Plus:               OS << "Plus"; break;
+  case AsmToken::Question:           OS << "Question"; break;
+  case AsmToken::RBrac:              OS << "RBrac"; break;
+  case AsmToken::RCurly:             OS << "RCurly"; break;
+  case AsmToken::RParen:             OS << "RParen"; break;
+  case AsmToken::Slash:              OS << "Slash"; break;
+  case AsmToken::Space:              OS << "Space"; break;
+  case AsmToken::Star:               OS << "Star"; break;
+  case AsmToken::Tilde:              OS << "Tilde"; break;
+    // clang-format on
+  }
+
+  // Print the token string.
+  OS << " (\"";
+  OS.write_escaped(getString());
+  OS << "\")";
+}
+
 AsmLexer::AsmLexer(const MCAsmInfo &MAI) : MAI(MAI) {
   // For COFF targets, this is true, while for ELF targets, it should be false.
   // Currently, @specifier parsing depends on '@' being included in the token.
diff --git a/llvm/lib/MC/MCParser/CMakeLists.txt b/llvm/lib/MC/MCParser/CMakeLists.txt
index d3fa267..008a50e 100644
--- a/llvm/lib/MC/MCParser/CMakeLists.txt
+++ b/llvm/lib/MC/MCParser/CMakeLists.txt
@@ -6,7 +6,6 @@
   GOFFAsmParser.cpp
   DarwinAsmParser.cpp
   ELFAsmParser.cpp
-  MCAsmLexer.cpp
   MCAsmParser.cpp
   MCAsmParserExtension.cpp
   MCTargetAsmParser.cpp
diff --git a/llvm/lib/MC/MCParser/MCAsmLexer.cpp b/llvm/lib/MC/MCParser/MCAsmLexer.cpp
deleted file mode 100644
index 8bdba21..0000000
--- a/llvm/lib/MC/MCParser/MCAsmLexer.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-//===- MCAsmLexer.cpp - Abstract Asm Lexer Interface ----------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/MC/MCParser/MCAsmLexer.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/SMLoc.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace llvm;
-
-MCAsmLexer::MCAsmLexer() {
-  CurTok.emplace_back(AsmToken::Space, StringRef());
-}
-
-MCAsmLexer::~MCAsmLexer() = default;
-
-SMLoc MCAsmLexer::getLoc() const {
-  return SMLoc::getFromPointer(TokStart);
-}
-
-SMLoc AsmToken::getLoc() const {
-  return SMLoc::getFromPointer(Str.data());
-}
-
-SMLoc AsmToken::getEndLoc() const {
-  return SMLoc::getFromPointer(Str.data() + Str.size());
-}
-
-SMRange AsmToken::getLocRange() const {
-  return SMRange(getLoc(), getEndLoc());
-}
-
-void AsmToken::dump(raw_ostream &OS) const {
-  switch (Kind) {
-  case AsmToken::Error:
-    OS << "error";
-    break;
-  case AsmToken::Identifier:
-    OS << "identifier: " << getString();
-    break;
-  case AsmToken::Integer:
-    OS << "int: " << getString();
-    break;
-  case AsmToken::Real:
-    OS << "real: " << getString();
-    break;
-  case AsmToken::String:
-    OS << "string: " << getString();
-    break;
-
-  case AsmToken::Amp:                OS << "Amp"; break;
-  case AsmToken::AmpAmp:             OS << "AmpAmp"; break;
-  case AsmToken::At:                 OS << "At"; break;
-  case AsmToken::BackSlash:          OS << "BackSlash"; break;
-  case AsmToken::BigNum:             OS << "BigNum"; break;
-  case AsmToken::Caret:              OS << "Caret"; break;
-  case AsmToken::Colon:              OS << "Colon"; break;
-  case AsmToken::Comma:              OS << "Comma"; break;
-  case AsmToken::Comment:            OS << "Comment"; break;
-  case AsmToken::Dollar:             OS << "Dollar"; break;
-  case AsmToken::Dot:                OS << "Dot"; break;
-  case AsmToken::EndOfStatement:     OS << "EndOfStatement"; break;
-  case AsmToken::Eof:                OS << "Eof"; break;
-  case AsmToken::Equal:              OS << "Equal"; break;
-  case AsmToken::EqualEqual:         OS << "EqualEqual"; break;
-  case AsmToken::Exclaim:            OS << "Exclaim"; break;
-  case AsmToken::ExclaimEqual:       OS << "ExclaimEqual"; break;
-  case AsmToken::Greater:            OS << "Greater"; break;
-  case AsmToken::GreaterEqual:       OS << "GreaterEqual"; break;
-  case AsmToken::GreaterGreater:     OS << "GreaterGreater"; break;
-  case AsmToken::Hash:               OS << "Hash"; break;
-  case AsmToken::HashDirective:      OS << "HashDirective"; break;
-  case AsmToken::LBrac:              OS << "LBrac"; break;
-  case AsmToken::LCurly:             OS << "LCurly"; break;
-  case AsmToken::LParen:             OS << "LParen"; break;
-  case AsmToken::Less:               OS << "Less"; break;
-  case AsmToken::LessEqual:          OS << "LessEqual"; break;
-  case AsmToken::LessGreater:        OS << "LessGreater"; break;
-  case AsmToken::LessLess:           OS << "LessLess"; break;
-  case AsmToken::Minus:              OS << "Minus"; break;
-  case AsmToken::MinusGreater:       OS << "MinusGreater"; break;
-  case AsmToken::Percent:            OS << "Percent"; break;
-  case AsmToken::Pipe:               OS << "Pipe"; break;
-  case AsmToken::PipePipe:           OS << "PipePipe"; break;
-  case AsmToken::Plus:               OS << "Plus"; break;
-  case AsmToken::Question:           OS << "Question"; break;
-  case AsmToken::RBrac:              OS << "RBrac"; break;
-  case AsmToken::RCurly:             OS << "RCurly"; break;
-  case AsmToken::RParen:             OS << "RParen"; break;
-  case AsmToken::Slash:              OS << "Slash"; break;
-  case AsmToken::Space:              OS << "Space"; break;
-  case AsmToken::Star:               OS << "Star"; break;
-  case AsmToken::Tilde:              OS << "Tilde"; break;
-  }
-
-  // Print the token string.
-  OS << " (\"";
-  OS.write_escaped(getString());
-  OS << "\")";
-}
diff --git a/llvm/utils/gn/secondary/llvm/lib/MC/MCParser/BUILD.gn b/llvm/utils/gn/secondary/llvm/lib/MC/MCParser/BUILD.gn
index 8fa5189..3fd2976 100644
--- a/llvm/utils/gn/secondary/llvm/lib/MC/MCParser/BUILD.gn
+++ b/llvm/utils/gn/secondary/llvm/lib/MC/MCParser/BUILD.gn
@@ -14,7 +14,6 @@
     "DarwinAsmParser.cpp",
     "ELFAsmParser.cpp",
     "GOFFAsmParser.cpp",
-    "MCAsmLexer.cpp",
     "MCAsmParser.cpp",
     "MCAsmParserExtension.cpp",
     "MCTargetAsmParser.cpp",