[MC] Merge MCAsmLexer.{h,cpp} into AsmLexer.{h,cpp} #134207
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
MaskRay
requested review from
lenary,
compnerd,
ericastor,
topperc and
kazutakahirata
|
@llvm/pr-subscribers-mc Author: Fangrui Song (MaskRay) Changes2b11c7d introduced
To simplify the codebase, this change merges MCAsmLexer.{h,cpp} into AsmLexer.{h,cpp}. MCAsmLexer.h is temporarily kept as a forwarder. Note: I doubt that a downstream lexer handling an assembly syntax significantly different from the standard GNU Assembler syntax would want to inherit from Patch is 22.23 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/134207.diff 6 Files Affected:
diff --git a/llvm/include/llvm/MC/MCParser/AsmLexer.h b/llvm/include/llvm/MC/MCParser/AsmLexer.h
index 735b0c114f2aa..d1599dc47e76b 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 61b89b9a103f4..0b004537be4fc 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 8715f94d51fe5..489933649b624 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 d3fa2675a255e..008a50e9da660 100644
--- a/llvm/lib/MC/MCParser/CMakeLists.txt
+++ b/llvm/lib/MC/MCParser/CMakeLists.txt
@@ -6,7 +6,6 @@ add_llvm_component_library(LLVMMCParser
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 8bdba218aa9c0..0000000000000
--- 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::Excla...
[truncated]
|
ericastor
approved these changes
Apr 3, 2025
2b11c7d introduced `llvm/include/llvm/MC/MCAsmLexer.h` and made `AsmLexer` inherit from `MCAsmLexer`, likely to allow target-specific parsers to depend solely on `MCAsmLexer`. However, this separation now seems unnecessary and confusing. `MCAsmLexer` defines virtual functions with `AsmLexer` as its only implementation, and `AsmLexer` itself has few extra public methods. To simplify the codebase, this change merges MCAsmLexer.{h,cpp} into AsmLexer.{h,cpp}. MCAsmLexer.h is temporarily kept as a forwarder. MCAsmLexer will be merged into AsmLexer and MCAsmLexer will become a type alias. Note: I doubt that a downstream lexer handling an assembly syntax significantly different from the standard GNU Assembler syntax would want to inherit from `MCAsmLexer`. Instead, it's more likely they'd extend `AsmLexer` by adding new states and modifying its internal logic, as seen with variables for MASM, M68k, and HLASM. Pull Request: llvm#134208
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/51/builds/13802 Here is the relevant piece of the build log for the reference |
MaskRay
added a commit
that referenced
this pull request
Apr 4, 2025
Follow-up to #134207 Both classes define `IsAtStartOfStatement` but the semantics are confusingly different. Rename the base class one.
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/146/builds/2640 Here is the relevant piece of the build log for the reference |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
2b11c7d introduced
llvm/include/llvm/MC/MCAsmLexer.hand madeAsmLexerinherit fromMCAsmLexer, likely to allow target-specific parsers to depend solely onMCAsmLexer. However, this separation now seems unnecessary and confusing.MCAsmLexerdefines virtual functions withAsmLexeras its only implementation, andAsmLexeritself has few extra public methods.To simplify the codebase, this change merges MCAsmLexer.{h,cpp} into AsmLexer.{h,cpp}. MCAsmLexer.h is temporarily kept as a forwarder.
Note: I doubt that a downstream lexer handling an assembly syntax significantly different from the standard GNU Assembler syntax would want to inherit from
MCAsmLexer. Instead, it's more likely they'd extendAsmLexerby adding new states and modifying its internal logic, as seen with variables for MASM, M68k, and HLASM.