[AVR] Rename VariantKind to Specifier

Follow the X86, Mips, and RISCV renaming.

> "Relocation modifier" suggests adjustments happen during the linker's relocation step rather than the assembler's expression evaluation.
> "Relocation specifier" is clear, aligns with Arm and IBM AIX's documentation, and fits the assembler's role seamlessly.

In addition, rename *MCExpr::getKind, which confusingly shadows the base class getKind.

Author: MaskRay

llvm/lib/Target/AVR/AsmParser/AVRAsmParser.cpp

@@ -447,7 +447,7 @@ bool AVRAsmParser::tryParseExpression(OperandVector &Operands, int64_t offset) {
 
 bool AVRAsmParser::tryParseRelocExpression(OperandVector &Operands) {
   bool isNegated = false;
-  AVRMCExpr::VariantKind ModifierKind = AVRMCExpr::VK_AVR_NONE;
+  AVRMCExpr::Specifier ModifierKind = AVRMCExpr::VK_AVR_NONE;
 
   SMLoc S = Parser.getTok().getLoc();
 
@@ -471,15 +471,15 @@ bool AVRAsmParser::tryParseRelocExpression(OperandVector &Operands) {
     return true;
   }
   StringRef ModifierName = Parser.getTok().getString();
-  ModifierKind = AVRMCExpr::getKindByName(ModifierName);
+  ModifierKind = AVRMCExpr::parseSpecifier(ModifierName);
 
   if (ModifierKind != AVRMCExpr::VK_AVR_NONE) {
     Parser.Lex();
     Parser.Lex(); // Eat modifier name and parenthesis
     if (Parser.getTok().getString() == GENERATE_STUBS &&
         Parser.getTok().getKind() == AsmToken::Identifier) {
       std::string GSModName = ModifierName.str() + "_" + GENERATE_STUBS;
-      ModifierKind = AVRMCExpr::getKindByName(GSModName);
+      ModifierKind = AVRMCExpr::parseSpecifier(GSModName);
       if (ModifierKind != AVRMCExpr::VK_AVR_NONE)
         Parser.Lex(); // Eat gs modifier name
     }
@@ -705,17 +705,16 @@ ParseStatus AVRAsmParser::parseLiteralValues(unsigned SizeInBytes, SMLoc L) {
   if (Parser.getTok().getKind() == AsmToken::Identifier &&
       Parser.getLexer().peekTok().getKind() == AsmToken::LParen) {
     StringRef ModifierName = Parser.getTok().getString();
-    AVRMCExpr::VariantKind ModifierKind =
-        AVRMCExpr::getKindByName(ModifierName);
-    if (ModifierKind != AVRMCExpr::VK_AVR_NONE) {
+    AVRMCExpr::Specifier Spec = AVRMCExpr::parseSpecifier(ModifierName);
+    if (Spec != AVRMCExpr::VK_AVR_NONE) {
       Parser.Lex();
       Parser.Lex(); // Eat the modifier and parenthesis
     } else {
       return Error(Parser.getTok().getLoc(), "unknown modifier");
     }
     MCSymbol *Symbol =
         getContext().getOrCreateSymbol(Parser.getTok().getString());
-    AVRStreamer.emitValueForModiferKind(Symbol, SizeInBytes, L, ModifierKind);
+    AVRStreamer.emitValueForModiferKind(Symbol, SizeInBytes, L, Spec);
     Lex(); // Eat the symbol name.
     if (parseToken(AsmToken::RParen))
       return ParseStatus::Failure;

llvm/lib/Target/AVR/MCTargetDesc/AVRELFObjectWriter.cpp

@@ -40,7 +40,7 @@ unsigned AVRELFObjectWriter::getRelocType(MCContext &Ctx, const MCValue &Target,
   const unsigned Kind = Fixup.getTargetKind();
   if (Kind >= FirstLiteralRelocationKind)
     return Kind - FirstLiteralRelocationKind;
-  auto Modifier = AVRMCExpr::VariantKind(Target.getAccessVariant());
+  auto Modifier = AVRMCExpr::Specifier(Target.getAccessVariant());
   switch ((unsigned)Fixup.getKind()) {
   case FK_Data_1:
     switch (Modifier) {

llvm/lib/Target/AVR/MCTargetDesc/AVRMCELFStreamer.cpp

@@ -22,8 +22,8 @@ using namespace llvm;
 
 void AVRMCELFStreamer::emitValueForModiferKind(
     const MCSymbol *Sym, unsigned SizeInBytes, SMLoc Loc,
-    AVRMCExpr::VariantKind ModifierKind) {
-  AVRMCExpr::VariantKind Kind = AVRMCExpr::VK_AVR_NONE;
+    AVRMCExpr::Specifier ModifierKind) {
+  AVRMCExpr::Specifier Kind = AVRMCExpr::VK_AVR_NONE;
   if (ModifierKind == AVRMCExpr::VK_AVR_NONE) {
     Kind = AVRMCExpr::VK_DIFF8;
     if (SizeInBytes == SIZE_LONG)

llvm/lib/Target/AVR/MCTargetDesc/AVRMCELFStreamer.h

@@ -43,7 +43,7 @@ class AVRMCELFStreamer : public MCELFStreamer {
 
   void emitValueForModiferKind(
       const MCSymbol *Sym, unsigned SizeInBytes, SMLoc Loc = SMLoc(),
-      AVRMCExpr::VariantKind ModifierKind = AVRMCExpr::VK_AVR_NONE);
+      AVRMCExpr::Specifier ModifierKind = AVRMCExpr::VK_AVR_NONE);
 };
 
 MCStreamer *createAVRELFStreamer(Triple const &TT, MCContext &Context,

llvm/lib/Target/AVR/MCTargetDesc/AVRMCExpr.cpp

@@ -19,7 +19,7 @@ namespace {
 
 const struct ModifierEntry {
   const char *const Spelling;
-  AVRMCExpr::VariantKind VariantKind;
+  AVRMCExpr::Specifier specifier;
 } ModifierNames[] = {
     {"lo8", AVRMCExpr::VK_LO8},       {"hi8", AVRMCExpr::VK_HI8},
     {"hh8", AVRMCExpr::VK_HH8}, // synonym with hlo8
@@ -34,13 +34,13 @@ const struct ModifierEntry {
 
 } // end of anonymous namespace
 
-const AVRMCExpr *AVRMCExpr::create(VariantKind Kind, const MCExpr *Expr,
+const AVRMCExpr *AVRMCExpr::create(Specifier Kind, const MCExpr *Expr,
                                    bool Negated, MCContext &Ctx) {
   return new (Ctx) AVRMCExpr(Kind, Expr, Negated);
 }
 
 void AVRMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
-  assert(Kind != VK_AVR_NONE);
+  assert(specifier != VK_AVR_NONE);
   OS << getName() << '(';
   if (isNegated())
     OS << '-' << '(';
@@ -85,7 +85,7 @@ bool AVRMCExpr::evaluateAsRelocatableImpl(MCValue &Result,
     MCSymbolRefExpr::VariantKind Modifier = Sym->getKind();
     if (Modifier != MCSymbolRefExpr::VK_None)
       return false;
-    if (Kind == VK_PM) {
+    if (specifier == VK_PM) {
       Modifier = MCSymbolRefExpr::VariantKind(AVRMCExpr::VK_PM);
     }
 
@@ -100,7 +100,7 @@ int64_t AVRMCExpr::evaluateAsInt64(int64_t Value) const {
   if (Negated)
     Value *= -1;
 
-  switch (Kind) {
+  switch (specifier) {
   case AVRMCExpr::VK_LO8:
     Value &= 0xff;
     break;
@@ -147,7 +147,7 @@ int64_t AVRMCExpr::evaluateAsInt64(int64_t Value) const {
 AVR::Fixups AVRMCExpr::getFixupKind() const {
   AVR::Fixups Kind = AVR::Fixups::LastTargetFixupKind;
 
-  switch (getKind()) {
+  switch (specifier) {
   case VK_LO8:
     Kind = isNegated() ? AVR::fixup_lo8_ldi_neg : AVR::fixup_lo8_ldi;
     break;
@@ -195,7 +195,7 @@ void AVRMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
 const char *AVRMCExpr::getName() const {
   const auto &Modifier =
       llvm::find_if(ModifierNames, [this](ModifierEntry const &Mod) {
-        return Mod.VariantKind == Kind;
+        return Mod.specifier == specifier;
       });
 
   if (Modifier != std::end(ModifierNames)) {
@@ -204,14 +204,14 @@ const char *AVRMCExpr::getName() const {
   return nullptr;
 }
 
-AVRMCExpr::VariantKind AVRMCExpr::getKindByName(StringRef Name) {
+AVRMCExpr::Specifier AVRMCExpr::parseSpecifier(StringRef Name) {
   const auto &Modifier =
       llvm::find_if(ModifierNames, [&Name](ModifierEntry const &Mod) {
         return Mod.Spelling == Name;
       });
 
   if (Modifier != std::end(ModifierNames)) {
-    return Modifier->VariantKind;
+    return Modifier->specifier;
   }
   return VK_AVR_NONE;
 }

llvm/lib/Target/AVR/MCTargetDesc/AVRMCExpr.h

@@ -19,12 +19,10 @@ namespace llvm {
 class AVRMCExpr : public MCTargetExpr {
 public:
   /// Specifies the type of an expression.
-  enum VariantKind {
+  enum Specifier {
     VK_None,
 
-    // While not strictly necessary, start at a larger number to avoid confusion
-    // with MCSymbolRefExpr::VariantKind.
-    VK_AVR_NONE = 100,
+    VK_AVR_NONE = MCSymbolRefExpr::FirstTargetSpecifier,
 
     VK_HI8,  ///< Corresponds to `hi8()`.
     VK_LO8,  ///< Corresponds to `lo8()`.
@@ -47,11 +45,11 @@ class AVRMCExpr : public MCTargetExpr {
 
 public:
   /// Creates an AVR machine code expression.
-  static const AVRMCExpr *create(VariantKind Kind, const MCExpr *Expr,
+  static const AVRMCExpr *create(Specifier S, const MCExpr *Expr,
                                  bool isNegated, MCContext &Ctx);
 
   /// Gets the type of the expression.
-  VariantKind getKind() const { return Kind; }
+  Specifier getSpecifier() const { return specifier; }
   /// Gets the name of the expression.
   const char *getName() const;
   const MCExpr *getSubExpr() const { return SubExpr; }
@@ -77,18 +75,18 @@ class AVRMCExpr : public MCTargetExpr {
   }
 
 public:
-  static VariantKind getKindByName(StringRef Name);
+  static Specifier parseSpecifier(StringRef Name);
 
 private:
   int64_t evaluateAsInt64(int64_t Value) const;
 
-  const VariantKind Kind;
+  const Specifier specifier;
   const MCExpr *SubExpr;
   bool Negated;
 
 private:
-  explicit AVRMCExpr(VariantKind Kind, const MCExpr *Expr, bool Negated)
-      : Kind(Kind), SubExpr(Expr), Negated(Negated) {}
+  explicit AVRMCExpr(Specifier S, const MCExpr *Expr, bool Negated)
+      : specifier(S), SubExpr(Expr), Negated(Negated) {}
   ~AVRMCExpr() = default;
 };