[Target][MC] Cleaning up AssemblerDialect / InstructionPrinterSyntaxVariant

[rainerzufalldererste]

Summary

I'm fairly new to LLVM, so I'm not entirely sure if this is remotely something that'll ever get accepted, however, I've found the seemingly random integers representing various different syntax variants to be not particularly well documented and found the option to simply add a comment to be not particularly future proof. I apologize in advance if this change isn't appreciated as I'm not familiar with how such things are usually being improved, so I won't be upset if this is simply going to be rejected.

I've had another branch that included InlineAsm variants as well, but the rabbit hole was already a lot deeper than I originally anticipated, so I've left those changes out, unless otherwise requested.

I've only tagged the code-owners of projects that received meaningful changes, if this isn't correct, please let me know and I'll add everyone else as well.

[MaskRay]

llvm/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp

388

Nit: Delete the blank line and elsewhere.

[rainerzufalldererste]

llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

120–137

This is where I expected to be a good place for a point of separation - but my initial version also transitioned all of InlineAsm to the new enum.
I'm not sure how the inline assembly is supported across different target platforms, so please let me know whether that separation is justified.

llvm/lib/MC/MCDisassembler/Disassembler.cpp

324–325

The comment obviously needs to be removed, but I wasn't sure what the line is trying to achieve and there's probably a cleaner way to do it now.

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmInfo.h

18

Would you prefer to keep this around, even through it's now unused (for potential backwards-compatibility)?

llvm/include/llvm/MC/MCAsmInfo.h

 } // end namespace WinEH
 
 namespace LCOMM {
 
 enum LCOMMType { NoAlignment, ByteAlignment, Log2Alignment };
 
 } // end namespace LCOMM
 
+namespace AsmDialect {
+
+enum Type {
+  Generic = 0,
+  AArch64_Generic = 0,
+  AArch64_Apple = 1,
+  AMDGPU_Generic = 0,
+  ARM_Generic = 0,
+  AVR_Generic = 0,
+  BPF_Generic = 0,
+  Hexagon_Generic = 0,
+  Lanai_Generic = 0,
+  LoongArch_Generic = 0,
+  MSP430_Generic = 0,
+  Mips_Generic = 0,
+  NVPTX_Generic = 0,
+  PPC_XCOFF = 0,
+  PPC_ELF = 1,
+  RISCV_Generic = 0,
+  Sparc_Generic = 0,
+  SystemZ_ATT = 0,
+  SystemZ_HLASM = 1,
+  VE_Generic = 0,
+  WebAssembly_Generic = 0,
+  
+  // Note: This numbering has to match the GCC assembler dialects for inline
+  // asm alternatives to work right.
+  X86_ATT = 0,
+  X86_Intel = 1,
+  
+  XCore_Generic = 0,
+};
+
+}  // end namespace AsmDialect
+
 /// This class is intended to be used as a base class for asm
 /// properties and features specific to the target.
 class MCAsmInfo {
 public:
   /// Assembly character literal syntax types.
   enum AsmCharLiteralSyntax {
     ACLS_Unknown, /// Unknown; character literals not used by LLVM for this
                   /// target.
protected:
 
   /// These are assembly directives that tells the assembler to interpret the
   /// following instructions differently.  Defaults to ".code16", ".code32",
   /// ".code64".
   const char *Code16Directive;
   const char *Code32Directive;
   const char *Code64Directive;
 
-  /// Which dialect of an assembler variant to use.  Defaults to 0
-  unsigned AssemblerDialect = 0;
+  /// Which dialect of an assembler variant to use.  Defaults to 0 / Generic
+  AsmDialect::Type AssemblerDialect = AsmDialect::Generic;
 
   /// This is true if the assembler allows @ characters in symbol names.
   /// Defaults to false.
   bool AllowAtInName = false;
 
   /// This is true if the assembler allows the "?" character at the start of
   /// of a string to be lexed as an AsmToken::Identifier.
   /// If the AsmLexer determines that the string can be lexed as a possible
StringRef getLinkerPrivateGlobalPrefix() const {
     return getPrivateGlobalPrefix();
   }
 
   const char *getInlineAsmStart() const { return InlineAsmStart; }
   const char *getInlineAsmEnd() const { return InlineAsmEnd; }
   const char *getCode16Directive() const { return Code16Directive; }
   const char *getCode32Directive() const { return Code32Directive; }
   const char *getCode64Directive() const { return Code64Directive; }
-  unsigned getAssemblerDialect() const { return AssemblerDialect; }
+  AsmDialect::Type getAssemblerDialect() const { return AssemblerDialect; }
   bool doesAllowAtInName() const { return AllowAtInName; }
   void setAllowAtInName(bool V) { AllowAtInName = V; }
   bool doesAllowQuestionAtStartOfIdentifier() const {
     return AllowQuestionAtStartOfIdentifier;
   }
   bool doesAllowAtAtStartOfIdentifier() const {
     return AllowAtAtStartOfIdentifier;
   }

llvm/include/llvm/MC/MCParser/MCAsmParser.h

 //===- llvm/MC/MCAsmParser.h - Abstract Asm Parser Interface ----*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCPARSER_MCASMPARSER_H
 #define LLVM_MC_MCPARSER_MCASMPARSER_H
 
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAsmMacro.h"
 #include "llvm/Support/SMLoc.h"
 #include <cstdint>
 #include <string>
 #include <utility>
 
 namespace llvm {
 
public:
   virtual MCContext &getContext() = 0;
 
   /// Return the output streamer for the assembler.
   virtual MCStreamer &getStreamer() = 0;
 
   MCTargetAsmParser &getTargetParser() const { return *TargetParser; }
   void setTargetParser(MCTargetAsmParser &P);
 
-  virtual unsigned getAssemblerDialect() { return 0;}
-  virtual void setAssemblerDialect(unsigned i) { }
+  virtual AsmDialect::Type getAssemblerDialect() { 
+    return AsmDialect::Generic;
+  }
+
+  virtual void setAssemblerDialect(AsmDialect::Type i) {}
 
   bool getShowParsedOperands() const { return ShowParsedOperands; }
   void setShowParsedOperands(bool Value) { ShowParsedOperands = Value; }
 
   /// Run the parser on the input source buffer.
   virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
 
   virtual void setParsingMSInlineAsm(bool V) = 0;

llvm/include/llvm/MC/TargetRegistry.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_TARGETREGISTRY_H
 #define LLVM_MC_TARGETREGISTRY_H
 
 #include "llvm-c/DisassemblerTypes.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/TargetParser/Triple.h"
 #include <cassert>
 #include <cstddef>
 #include <iterator>
using MCAsmBackendCtorTy = MCAsmBackend *(*)(const Target &T,
                                                const MCTargetOptions &Options);
   using MCAsmParserCtorTy = MCTargetAsmParser *(*)(
       const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII,
       const MCTargetOptions &Options);
   using MCDisassemblerCtorTy = MCDisassembler *(*)(const Target &T,
                                                    const MCSubtargetInfo &STI,
                                                    MCContext &Ctx);
   using MCInstPrinterCtorTy = MCInstPrinter *(*)(const Triple &T,
-                                                 unsigned SyntaxVariant,
+                                                 AsmDialect::Type Variant,
                                                  const MCAsmInfo &MAI,
                                                  const MCInstrInfo &MII,
                                                  const MCRegisterInfo &MRI);
   using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(const MCInstrInfo &II,
                                                  MCContext &Ctx);
   using ELFStreamerCtorTy =
       MCStreamer *(*)(const Triple &T, MCContext &Ctx,
                       std::unique_ptr<MCAsmBackend> &&TAB,
public:
 
   MCDisassembler *createMCDisassembler(const MCSubtargetInfo &STI,
                                        MCContext &Ctx) const {
     if (!MCDisassemblerCtorFn)
       return nullptr;
     return MCDisassemblerCtorFn(*this, STI, Ctx);
   }
 
-  MCInstPrinter *createMCInstPrinter(const Triple &T, unsigned SyntaxVariant,
+  MCInstPrinter *createMCInstPrinter(const Triple &T,
+                                     AsmDialect::Type SyntaxVariant,
                                      const MCAsmInfo &MAI,
                                      const MCInstrInfo &MII,
                                      const MCRegisterInfo &MRI) const {
     if (!MCInstPrinterCtorFn)
       return nullptr;
     return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);
   }
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

void AsmPrinter::emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
   // because it's not subtarget dependent.
   std::unique_ptr<MCInstrInfo> MII(TM.getTarget().createMCInstrInfo());
   assert(MII && "Failed to create instruction info");
   std::unique_ptr<MCTargetAsmParser> TAP(TM.getTarget().createMCAsmParser(
       STI, *Parser, *MII, MCOptions));
   if (!TAP)
     report_fatal_error("Inline asm not supported by this streamer because"
                        " we don't have an asm parser for this target\n");
-  Parser->setAssemblerDialect(Dialect);
+
+  // Resolve `InlineAsm::AsmDialect` to `AsmDialect`.
+  AsmDialect::Type CorrespondingAsmDialect;
+
+  switch (Dialect) {
+  case InlineAsm::AD_ATT:
+    CorrespondingAsmDialect = AsmDialect::X86_ATT;
+    break;
+
+  case InlineAsm::AD_Intel:
+    CorrespondingAsmDialect = AsmDialect::X86_Intel;
+    break;
+
+  default:
+    assert(false && "Inline Assembly Dialect not supported.");
+    break;
+  }
+
+  Parser->setAssemblerDialect(CorrespondingAsmDialect);
+
   Parser->setTargetParser(*TAP);
   // Enable lexing Masm binary and hex integer literals in intel inline
   // assembly.
   if (Dialect == InlineAsm::AD_Intel)
     Parser->getLexer().setLexMasmIntegers(true);
 
   emitInlineAsmStart();
   // Don't implicitly switch to the text section before the asm.

llvm/lib/MC/MCDisassembler/Disassembler.cpp

LLVMCreateDisasmCPUFeatures(const char *TT, const char *CPU,
   if (!RelInfo)
     return nullptr;
 
   std::unique_ptr<MCSymbolizer> Symbolizer(TheTarget->createMCSymbolizer(
       TT, GetOpInfo, SymbolLookUp, DisInfo, Ctx.get(), std::move(RelInfo)));
   DisAsm->setSymbolizer(std::move(Symbolizer));
 
   // Set up the instruction printer.
-  int AsmPrinterVariant = MAI->getAssemblerDialect();
+  AsmDialect::Type AsmPrinterVariant = MAI->getAssemblerDialect();
   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
       Triple(TT), AsmPrinterVariant, *MAI, *MII, *MRI));
   if (!IP)
     return nullptr;
 
   LLVMDisasmContext *DC = new LLVMDisasmContext(
       TT, DisInfo, TagType, GetOpInfo, SymbolLookUp, TheTarget, std::move(MAI),
       std::move(MRI), std::move(STI), std::move(MII), std::move(Ctx),
if (Options & LLVMDisassembler_Option_PrintImmHex){
       Options &= ~LLVMDisassembler_Option_PrintImmHex;
   }
   if (Options & LLVMDisassembler_Option_AsmPrinterVariant){
       LLVMDisasmContext *DC = static_cast<LLVMDisasmContext *>(DCR);
       // Try to set up the new instruction printer.
       const MCAsmInfo *MAI = DC->getAsmInfo();
       const MCInstrInfo *MII = DC->getInstrInfo();
       const MCRegisterInfo *MRI = DC->getRegisterInfo();
-      int AsmPrinterVariant = MAI->getAssemblerDialect();
-      AsmPrinterVariant = AsmPrinterVariant == 0 ? 1 : 0;
+      AsmDialect::Type AsmPrinterVariant = MAI->getAssemblerDialect();
+      // what is the following line supposed to achieve? Do we want this?
+      AsmPrinterVariant = (AsmDialect::Type)(AsmPrinterVariant == 0 ? 1 : 0);
       MCInstPrinter *IP = DC->getTarget()->createMCInstPrinter(
           Triple(DC->getTripleName()), AsmPrinterVariant, *MAI, *MII, *MRI);
       if (IP) {
         DC->setIP(IP);
         DC->addOptions(LLVMDisassembler_Option_AsmPrinterVariant);
         Options &= ~LLVMDisassembler_Option_AsmPrinterVariant;
       }
   }

llvm/lib/MC/MCParser/AsmParser.cpp

private:
   StringRef FirstCppHashFilename;
 
   /// List of forward directional labels for diagnosis at the end.
   SmallVector<std::tuple<SMLoc, CppHashInfoTy, MCSymbol *>, 4> DirLabels;
 
   SmallSet<StringRef, 2> LTODiscardSymbols;
 
   /// AssemblerDialect. ~OU means unset value and use value provided by MAI.
-  unsigned AssemblerDialect = ~0U;
+  AsmDialect::Type AssemblerDialect = (AsmDialect::Type)~0U;
 
   /// is Darwin compatibility enabled?
   bool IsDarwin = false;
 
   /// Are we parsing ms-style inline assembly?
   bool ParsingMSInlineAsm = false;
 
   /// Did we already inform the user about inconsistent MD5 usage?
public:
 
   SourceMgr &getSourceManager() override { return SrcMgr; }
   MCAsmLexer &getLexer() override { return Lexer; }
   MCContext &getContext() override { return Ctx; }
   MCStreamer &getStreamer() override { return Out; }
 
   CodeViewContext &getCVContext() { return Ctx.getCVContext(); }
 
-  unsigned getAssemblerDialect() override {
+  AsmDialect::Type getAssemblerDialect() override {
     if (AssemblerDialect == ~0U)
       return MAI.getAssemblerDialect();
     else
       return AssemblerDialect;
   }
-  void setAssemblerDialect(unsigned i) override {
+  void setAssemblerDialect(AsmDialect::Type i) override {
     AssemblerDialect = i;
   }
 
   void Note(SMLoc L, const Twine &Msg, SMRange Range = std::nullopt) override;
   bool Warning(SMLoc L, const Twine &Msg,
                SMRange Range = std::nullopt) override;
   bool printError(SMLoc L, const Twine &Msg,
                   SMRange Range = std::nullopt) override;

llvm/lib/MC/MCParser/MasmParser.cpp

private:
 
   /// The filename from the first cpp hash file line comment, if any.
   StringRef FirstCppHashFilename;
 
   /// List of forward directional labels for diagnosis at the end.
   SmallVector<std::tuple<SMLoc, CppHashInfoTy, MCSymbol *>, 4> DirLabels;
 
   /// AssemblerDialect. ~OU means unset value and use value provided by MAI.
-  /// Defaults to 1U, meaning Intel.
-  unsigned AssemblerDialect = 1U;
+  /// Defaults to Intel.
+  AsmDialect::Type AssemblerDialect = AsmDialect::X86_Intel;
 
   /// is Darwin compatibility enabled?
   bool IsDarwin = false;
 
   /// Are we parsing ms-style inline assembly?
   bool ParsingMSInlineAsm = false;
 
   /// Did we already inform the user about inconsistent MD5 usage?
public:
 
   SourceMgr &getSourceManager() override { return SrcMgr; }
   MCAsmLexer &getLexer() override { return Lexer; }
   MCContext &getContext() override { return Ctx; }
   MCStreamer &getStreamer() override { return Out; }
 
   CodeViewContext &getCVContext() { return Ctx.getCVContext(); }
 
-  unsigned getAssemblerDialect() override {
+  AsmDialect::Type getAssemblerDialect() override {
     if (AssemblerDialect == ~0U)
       return MAI.getAssemblerDialect();
     else
       return AssemblerDialect;
   }
-  void setAssemblerDialect(unsigned i) override {
+  void setAssemblerDialect(AsmDialect::Type i) override {
     AssemblerDialect = i;
   }
 
   void Note(SMLoc L, const Twine &Msg, SMRange Range = std::nullopt) override;
   bool Warning(SMLoc L, const Twine &Msg,
                SMRange Range = std::nullopt) override;
   bool printError(SMLoc L, const Twine &Msg,
                   SMRange Range = std::nullopt) override;

llvm/lib/Object/ModuleSymbolTable.cpp

initializeRecordStreamer(const Module &M,
 
   std::unique_ptr<MCTargetAsmParser> TAP(
       T->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));
   if (!TAP)
     return;
 
   // Module-level inline asm is assumed to use At&t syntax (see
   // AsmPrinter::doInitialization()).
-  Parser->setAssemblerDialect(InlineAsm::AD_ATT);
+  Parser->setAssemblerDialect(AsmDialect::X86_ATT);
 
   Parser->setTargetParser(*TAP);
   if (Parser->Run(false))
     return;
 
   Init(Streamer);
 }
 

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp

 #include "AArch64MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/TargetParser/Triple.h"
 using namespace llvm;
 
-enum AsmWriterVariantTy {
-  Default = -1,
-  Generic = 0,
-  Apple = 1
-};
-
-static cl::opt<AsmWriterVariantTy> AsmWriterVariant(
-    "aarch64-neon-syntax", cl::init(Default),
+static cl::opt<AsmDialect::Type> AsmWriterVariant(
+    "aarch64-neon-syntax", cl::init((AsmDialect::Type)-1),
     cl::desc("Choose style of NEON code to emit from AArch64 backend:"),
-    cl::values(clEnumValN(Generic, "generic", "Emit generic NEON assembly"),
-               clEnumValN(Apple, "apple", "Emit Apple-style NEON assembly")));
+    cl::values(clEnumValN(AsmDialect::AArch64_Generic, "generic",
+                          "Emit generic NEON assembly"),
+               clEnumValN(AsmDialect::AArch64_Apple, "apple",
+                          "Emit Apple-style NEON assembly")));
 
 AArch64MCAsmInfoDarwin::AArch64MCAsmInfoDarwin(bool IsILP32) {
   // We prefer NEON instructions to be printed in the short, Apple-specific
   // form when targeting Darwin.
-  AssemblerDialect = AsmWriterVariant == Default ? Apple : AsmWriterVariant;
+  AssemblerDialect = AsmWriterVariant == -1 ? AsmDialect::AArch64_Apple
+                                            : AsmDialect::AArch64_Generic;
 
   PrivateGlobalPrefix = "L";
   PrivateLabelPrefix = "L";
   SeparatorString = "%%";
   CommentString = ";";
   CalleeSaveStackSlotSize = 8;
   CodePointerSize = IsILP32 ? 4 : 8;
 

 }
 
 AArch64MCAsmInfoELF::AArch64MCAsmInfoELF(const Triple &T) {
   if (T.getArch() == Triple::aarch64_be)
     IsLittleEndian = false;
 
   // We prefer NEON instructions to be printed in the generic form when
   // targeting ELF.
-  AssemblerDialect = AsmWriterVariant == Default ? Generic : AsmWriterVariant;
+  AssemblerDialect = AsmWriterVariant == -1 ? AsmDialect::AArch64_Generic : AsmWriterVariant;
 
   CodePointerSize = T.getEnvironment() == Triple::GNUILP32 ? 4 : 8;
 
   // ".comm align is in bytes but .align is pow-2."
   AlignmentIsInBytes = false;
 
   CommentString = "//";
   PrivateGlobalPrefix = ".L";

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp

static MCAsmInfo *createAArch64MCAsmInfo(const MCRegisterInfo &MRI,
   unsigned Reg = MRI.getDwarfRegNum(AArch64::SP, true);
   MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(nullptr, Reg, 0);
   MAI->addInitialFrameState(Inst);
 
   return MAI;
 }
 
 static MCInstPrinter *createAArch64MCInstPrinter(const Triple &T,
-                                                 unsigned SyntaxVariant,
+                                                 AsmDialect::Type Variant,
                                                  const MCAsmInfo &MAI,
                                                  const MCInstrInfo &MII,
                                                  const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::AArch64_Generic)
     return new AArch64InstPrinter(MAI, MII, MRI);
-  if (SyntaxVariant == 1)
+  else if (Variant == AsmDialect::AArch64_Apple)
     return new AArch64AppleInstPrinter(MAI, MII, MRI);
-
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
                                      std::unique_ptr<MCAsmBackend> &&TAB,
                                      std::unique_ptr<MCObjectWriter> &&OW,
                                      std::unique_ptr<MCCodeEmitter> &&Emitter,
                                      bool RelaxAll) {

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp

 static MCSubtargetInfo *
 createAMDGPUMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
   if (TT.getArch() == Triple::r600)
     return createR600MCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
   return createAMDGPUMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
 }
 
 static MCInstPrinter *createAMDGPUMCInstPrinter(const Triple &T,
-                                                unsigned SyntaxVariant,
+                                                AsmDialect::Type Variant,
                                                 const MCAsmInfo &MAI,
                                                 const MCInstrInfo &MII,
                                                 const MCRegisterInfo &MRI) {
+  assert(Variant == AsmDialect::AMDGPU_Generic && 
+    "Unknown or unsupported syntax variant.");
+
   if (T.getArch() == Triple::r600)
     return new R600InstPrinter(MAI, MII, MRI);
   else
     return new AMDGPUInstPrinter(MAI, MII, MRI);
 }
 
 static MCTargetStreamer *createAMDGPUAsmTargetStreamer(MCStreamer &S,
                                                       formatted_raw_ostream &OS,

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
   MCAsmParser &Parser = getParser();
 
   // Apply mnemonic aliases before doing anything else, as the destination
   // mnemonic may include suffices and we want to handle them normally.
   // The generic tblgen'erated code does this later, at the start of
   // MatchInstructionImpl(), but that's too late for aliases that include
   // any sort of suffix.
   const FeatureBitset &AvailableFeatures = getAvailableFeatures();
-  unsigned AssemblerDialect = getParser().getAssemblerDialect();
+  AsmDialect::Type AssemblerDialect = getParser().getAssemblerDialect();
   applyMnemonicAliases(Name, AvailableFeatures, AssemblerDialect);
 
   // First check for the ARM-specific .req directive.
   if (Parser.getTok().is(AsmToken::Identifier) &&
       Parser.getTok().getIdentifier().lower() == ".req") {
     parseDirectiveReq(Name, NameLoc);
     // We always return 'error' for this, as we're done with this
     // statement and don't need to match the 'instruction."

llvm/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp

createARMMachOStreamer(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&MAB,
                        std::unique_ptr<MCObjectWriter> &&OW,
                        std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
                        bool DWARFMustBeAtTheEnd) {
   return createMachOStreamer(Ctx, std::move(MAB), std::move(OW),
                              std::move(Emitter), false, DWARFMustBeAtTheEnd);
 }
 
 static MCInstPrinter *createARMMCInstPrinter(const Triple &T,
-                                             unsigned SyntaxVariant,
+                                             AsmDialect::Type Variant,
                                              const MCAsmInfo &MAI,
                                              const MCInstrInfo &MII,
                                              const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::ARM_Generic)
     return new ARMInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 static MCRelocationInfo *createARMMCRelocationInfo(const Triple &TT,
                                                    MCContext &Ctx) {
   if (TT.isOSBinFormatMachO())
     return createARMMachORelocationInfo(Ctx);
   // Default to the stock relocation info.
   return llvm::createMCRelocationInfo(TT, Ctx);
 }

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

 }
 
 static MCSubtargetInfo *createAVRMCSubtargetInfo(const Triple &TT,
                                                  StringRef CPU, StringRef FS) {
   return createAVRMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
 }
 
 static MCInstPrinter *createAVRMCInstPrinter(const Triple &T,
-                                             unsigned SyntaxVariant,
+                                             AsmDialect::Type Variant,
                                              const MCAsmInfo &MAI,
                                              const MCInstrInfo &MII,
                                              const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0) {
+  if (Variant == AsmDialect::AVR_Generic)
     return new AVRInstPrinter(MAI, MII, MRI);
-  }
-
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     std::unique_ptr<MCObjectWriter> &&OW,
                                     std::unique_ptr<MCCodeEmitter> &&Emitter,
                                     bool RelaxAll) {

llvm/lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp

static MCStreamer *createBPFMCStreamer(const Triple &T, MCContext &Ctx,
                                        std::unique_ptr<MCObjectWriter> &&OW,
                                        std::unique_ptr<MCCodeEmitter> &&Emitter,
                                        bool RelaxAll) {
   return createELFStreamer(Ctx, std::move(MAB), std::move(OW), std::move(Emitter),
                            RelaxAll);
 }
 
 static MCInstPrinter *createBPFMCInstPrinter(const Triple &T,
-                                             unsigned SyntaxVariant,
+                                             AsmDialect::Type Variant,
                                              const MCAsmInfo &MAI,
                                              const MCInstrInfo &MII,
                                              const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::BPF_Generic)
     return new BPFInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 namespace {
 
 class BPFMCInstrAnalysis : public MCInstrAnalysis {
 public:
   explicit BPFMCInstrAnalysis(const MCInstrInfo *Info)

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp

static MCAsmInfo *createHexagonMCAsmInfo(const MCRegisterInfo &MRI,
   MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(
       nullptr, MRI.getDwarfRegNum(Hexagon::R30, true), 0);
   MAI->addInitialFrameState(Inst);
 
   return MAI;
 }
 
 static MCInstPrinter *createHexagonMCInstPrinter(const Triple &T,
-                                                 unsigned SyntaxVariant,
+                                                 AsmDialect::Type Variant,
                                                  const MCAsmInfo &MAI,
                                                  const MCInstrInfo &MII,
                                                  const MCRegisterInfo &MRI)
 {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::Hexagon_Generic)
     return new HexagonInstPrinter(MAI, MII, MRI);
-  else
-    return nullptr;
+  assert(false && "Unknown or unsupported syntax variant.");
 }
 
 static MCTargetStreamer *
 createMCAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS,
                           MCInstPrinter *IP, bool IsVerboseAsm) {
   return new HexagonTargetAsmStreamer(S, OS, IsVerboseAsm, *IP);
 }
 

llvm/lib/Target/Lanai/MCTargetDesc/LanaiMCTargetDesc.cpp

static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
   if (!T.isOSBinFormatELF())
     llvm_unreachable("OS not supported");
 
   return createELFStreamer(Context, std::move(MAB), std::move(OW),
                            std::move(Emitter), RelaxAll);
 }
 
 static MCInstPrinter *createLanaiMCInstPrinter(const Triple & /*T*/,
-                                               unsigned SyntaxVariant,
+                                               AsmDialect::Type Variant,
                                                const MCAsmInfo &MAI,
                                                const MCInstrInfo &MII,
                                                const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::Lanai_Generic)
     return new LanaiInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 static MCRelocationInfo *createLanaiElfRelocation(const Triple &TheTriple,
                                                   MCContext &Ctx) {
   return createMCRelocationInfo(TheTriple, Ctx);
 }
 

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchMCTargetDesc.cpp

static MCAsmInfo *createLoongArchMCAsmInfo(const MCRegisterInfo &MRI,
   MCRegister SP = MRI.getDwarfRegNum(LoongArch::R3, true);
   MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(nullptr, SP, 0);
   MAI->addInitialFrameState(Inst);
 
   return MAI;
 }
 
 static MCInstPrinter *createLoongArchMCInstPrinter(const Triple &T,
-                                                   unsigned SyntaxVariant,
+                                                   AsmDialect::Type Variant,
                                                    const MCAsmInfo &MAI,
                                                    const MCInstrInfo &MII,
                                                    const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::LoongArch_Generic)
     return new LoongArchInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 static MCTargetStreamer *
 createLoongArchObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
   return STI.getTargetTriple().isOSBinFormatELF()
              ? new LoongArchTargetELFStreamer(S, STI)
              : nullptr;
 }

llvm/lib/Target/MSP430/MCTargetDesc/MSP430MCTargetDesc.cpp

 }
 
 static MCSubtargetInfo *
 createMSP430MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
   return createMSP430MCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
 }
 
 static MCInstPrinter *createMSP430MCInstPrinter(const Triple &T,
-                                                unsigned SyntaxVariant,
+                                                AsmDialect::Type Variant,
                                                 const MCAsmInfo &MAI,
                                                 const MCInstrInfo &MII,
                                                 const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::MSP430_Generic)
     return new MSP430InstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeMSP430TargetMC() {
   Target &T = getTheMSP430Target();
 
   TargetRegistry::RegisterMCAsmInfo(T, createMSP430MCAsmInfo);
   TargetRegistry::RegisterMCInstrInfo(T, createMSP430MCInstrInfo);
   TargetRegistry::RegisterMCRegInfo(T, createMSP430MCRegisterInfo);
   TargetRegistry::RegisterMCSubtargetInfo(T, createMSP430MCSubtargetInfo);
   TargetRegistry::RegisterMCInstPrinter(T, createMSP430MCInstPrinter);
   TargetRegistry::RegisterMCCodeEmitter(T, createMSP430MCCodeEmitter);
   TargetRegistry::RegisterMCAsmBackend(T, createMSP430MCAsmBackend);
   TargetRegistry::RegisterObjectTargetStreamer(
       T, createMSP430ObjectTargetStreamer);
 }

llvm/lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp

static MCAsmInfo *createMipsMCAsmInfo(const MCRegisterInfo &MRI,
   unsigned SP = MRI.getDwarfRegNum(Mips::SP, true);
   MCCFIInstruction Inst = MCCFIInstruction::createDefCfaRegister(nullptr, SP);
   MAI->addInitialFrameState(Inst);
 
   return MAI;
 }
 
 static MCInstPrinter *createMipsMCInstPrinter(const Triple &T,
-                                              unsigned SyntaxVariant,
+                                              AsmDialect::Type Variant,
                                               const MCAsmInfo &MAI,
                                               const MCInstrInfo &MII,
                                               const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::Mips_Generic)
     return new MipsInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     std::unique_ptr<MCObjectWriter> &&OW,
                                     std::unique_ptr<MCCodeEmitter> &&Emitter,
                                     bool RelaxAll) {
   MCStreamer *S;

llvm/lib/Target/NVPTX/MCTargetDesc/NVPTXMCTargetDesc.cpp

 }
 
 static MCSubtargetInfo *
 createNVPTXMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
   return createNVPTXMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
 }
 
 static MCInstPrinter *createNVPTXMCInstPrinter(const Triple &T,
-                                               unsigned SyntaxVariant,
+                                               AsmDialect::Type Variant,
                                                const MCAsmInfo &MAI,
                                                const MCInstrInfo &MII,
                                                const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::NVPTX_Generic)
     return new NVPTXInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
                                                  formatted_raw_ostream &,
                                                  MCInstPrinter *, bool) {
   return new NVPTXAsmTargetStreamer(S);
 }

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCAsmInfo.cpp

PPCELFMCAsmInfo::PPCELFMCAsmInfo(bool is64Bit, const Triple& T) {
   // Set up DWARF directives
   MinInstAlignment = 4;
 
   // Exceptions handling
   ExceptionsType = ExceptionHandling::DwarfCFI;
 
   ZeroDirective = "\t.space\t";
   Data64bitsDirective = is64Bit ? "\t.quad\t" : nullptr;
-  AssemblerDialect = 1;           // New-Style mnemonics.
+  AssemblerDialect = AsmDialect::PPC_ELF; // New-Style mnemonics.
   LCOMMDirectiveAlignmentType = LCOMM::ByteAlignment;
 }
 
 void PPCXCOFFMCAsmInfo::anchor() {}
 
 PPCXCOFFMCAsmInfo::PPCXCOFFMCAsmInfo(bool Is64Bit, const Triple &T) {
   if (T.getArch() == Triple::ppc64le || T.getArch() == Triple::ppcle)
     report_fatal_error("XCOFF is not supported for little-endian targets");

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
   if (TT.isOSBinFormatELF())
     return new PPCTargetELFStreamer(S);
   if (TT.isOSBinFormatXCOFF())
     return new PPCTargetXCOFFStreamer(S);
   return new PPCTargetMachOStreamer(S);
 }
 
 static MCInstPrinter *createPPCMCInstPrinter(const Triple &T,
-                                             unsigned SyntaxVariant,
+                                             AsmDialect::Type Variant,
                                              const MCAsmInfo &MAI,
                                              const MCInstrInfo &MII,
                                              const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::PPC_XCOFF || Variant == AsmDialect::PPC_ELF)
     return new PPCInstPrinter(MAI, MII, MRI, T);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 namespace {
 
 class PPCMCInstrAnalysis : public MCInstrAnalysis {
 public:
   explicit PPCMCInstrAnalysis(const MCInstrInfo *Info)
       : MCInstrAnalysis(Info) {}

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCTargetDesc.cpp

static MCSubtargetInfo *createRISCVMCSubtargetInfo(const Triple &TT,
                                                    StringRef CPU, StringRef FS) {
   if (CPU.empty() || CPU == "generic")
     CPU = TT.isArch64Bit() ? "generic-rv64" : "generic-rv32";
 
   return createRISCVMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
 }
 
 static MCInstPrinter *createRISCVMCInstPrinter(const Triple &T,
-                                               unsigned SyntaxVariant,
+                                               AsmDialect::Type Variant,
                                                const MCAsmInfo &MAI,
                                                const MCInstrInfo &MII,
                                                const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::RISCV_Generic)
     return new RISCVInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 static MCTargetStreamer *
 createRISCVObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
   const Triple &TT = STI.getTargetTriple();
   if (TT.isOSBinFormatELF())
     return new RISCVTargetELFStreamer(S, STI);
   return nullptr;

llvm/lib/Target/Sparc/MCTargetDesc/SparcMCTargetDesc.cpp

static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
   return new SparcTargetAsmStreamer(S, OS);
 }
 
 static MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) {
   return new SparcTargetStreamer(S);
 }
 
 static MCInstPrinter *createSparcMCInstPrinter(const Triple &T,
-                                               unsigned SyntaxVariant,
+                                               AsmDialect::Type Variant,
                                                const MCAsmInfo &MAI,
                                                const MCInstrInfo &MII,
                                                const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::Sparc_Generic)
     return new SparcInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSparcTargetMC() {
   // Register the MC asm info.
   RegisterMCAsmInfoFn X(getTheSparcTarget(), createSparcMCAsmInfo);
   RegisterMCAsmInfoFn Y(getTheSparcV9Target(), createSparcV9MCAsmInfo);
   RegisterMCAsmInfoFn Z(getTheSparcelTarget(), createSparcMCAsmInfo);
 

llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp

private:
   // The problematic part is because, we forcibly set the inline asm dialect
   // in the AsmParser instance in AsmPrinterInlineAsm.cpp. Soo any query
   // to the overriden getAssemblerDialect function in AsmParser.cpp, will
   // not return the assembler dialect set in the respective MCAsmInfo instance.
   //
   // For this purpose, we explicitly query the SystemZMCAsmInfo instance
   // here, to get the "correct" assembler dialect, and use it in various
   // functions.
-  unsigned getMAIAssemblerDialect() {
+  AsmDialect::Type getMAIAssemblerDialect() {
     return Parser.getContext().getAsmInfo()->getAssemblerDialect();
   }
 
   // An alphabetic character in HLASM is a letter from 'A' through 'Z',
   // or from 'a' through 'z', or '$', '_','#', or '@'.
   inline bool isHLASMAlpha(char C) {
     return isAlpha(C) || llvm::is_contained("_@#$", C);
   }
 
   // A digit in HLASM is a number from 0 to 9.
   inline bool isHLASMAlnum(char C) { return isHLASMAlpha(C) || isDigit(C); }
 
   // Are we parsing using the AD_HLASM dialect?
-  inline bool isParsingHLASM() { return getMAIAssemblerDialect() == AD_HLASM; }
+  inline bool isParsingHLASM() {
+    return getMAIAssemblerDialect() == AsmDialect::SystemZ_HLASM;
+  }
 
   // Are we parsing using the AD_ATT dialect?
-  inline bool isParsingATT() { return getMAIAssemblerDialect() == AD_ATT; }
+  inline bool isParsingATT() {
+    return getMAIAssemblerDialect() == AsmDialect::SystemZ_ATT;
+  }
 
 public:
   SystemZAsmParser(const MCSubtargetInfo &sti, MCAsmParser &parser,
                    const MCInstrInfo &MII,
                    const MCTargetOptions &Options)
     : MCTargetAsmParser(Options, sti, MII), Parser(parser) {
     MCAsmParserExtension::Initialize(Parser);
 

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZInstPrinter.cpp

void SystemZInstPrinter::printOperand(const MCOperand &MO, const MCAsmInfo *MAI,
   else
     llvm_unreachable("Invalid operand");
 }
 
 void SystemZInstPrinter::printFormattedRegName(const MCAsmInfo *MAI,
                                                MCRegister Reg,
                                                raw_ostream &O) const {
   const char *RegName = getRegisterName(Reg);
-  if (MAI->getAssemblerDialect() == AD_HLASM) {
+  if (MAI->getAssemblerDialect() == AsmDialect::SystemZ_HLASM) {
     // Skip register prefix so that only register number is left
     assert(isalpha(RegName[0]) && isdigit(RegName[1]));
     O << markup("<reg:") << (RegName + 1) << markup(">");
   } else
     O << markup("<reg:") << '%' << RegName << markup(">");
 }
 
 void SystemZInstPrinter::printRegName(raw_ostream &O, MCRegister Reg) const {

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmInfo.h

 #define LLVM_LIB_TARGET_SYSTEMZ_MCTARGETDESC_SYSTEMZMCASMINFO_H
 
 #include "llvm/MC/MCAsmInfoELF.h"
 #include "llvm/MC/MCAsmInfoGOFF.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
 class Triple;
-enum SystemZAsmDialect { AD_ATT = 0, AD_HLASM = 1 };
 
 class SystemZMCAsmInfoELF : public MCAsmInfoELF {
 public:
   explicit SystemZMCAsmInfoELF(const Triple &TT);
 };
 
 class SystemZMCAsmInfoGOFF : public MCAsmInfoGOFF {
 public:
   explicit SystemZMCAsmInfoGOFF(const Triple &TT);
   bool isAcceptableChar(char C) const override;
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmInfo.cpp

 //===-- SystemZMCAsmInfo.cpp - SystemZ asm properties ---------------------===//
 //
 // 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 "SystemZMCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionELF.h"
 
 using namespace llvm;
 
 SystemZMCAsmInfoELF::SystemZMCAsmInfoELF(const Triple &TT) {
-  AssemblerDialect = AD_ATT;
+  AssemblerDialect = AsmDialect::SystemZ_ATT;
   CalleeSaveStackSlotSize = 8;
   CodePointerSize = 8;
   Data64bitsDirective = "\t.quad\t";
   ExceptionsType = ExceptionHandling::DwarfCFI;
   IsLittleEndian = false;
   MaxInstLength = 6;
   SupportsDebugInformation = true;
   UsesELFSectionDirectiveForBSS = true;
   ZeroDirective = "\t.space\t";
 }
 
 SystemZMCAsmInfoGOFF::SystemZMCAsmInfoGOFF(const Triple &TT) {
   AllowAdditionalComments = false;
   AllowAtInName = true;
   AllowAtAtStartOfIdentifier = true;
   AllowDollarAtStartOfIdentifier = true;
   AllowHashAtStartOfIdentifier = true;
-  AssemblerDialect = AD_HLASM;
+  AssemblerDialect = AsmDialect::SystemZ_HLASM;
   CalleeSaveStackSlotSize = 8;
   CodePointerSize = 8;
   CommentString = "*";
   DotIsPC = false;
   EmitGNUAsmStartIndentationMarker = false;
   EmitLabelsInUpperCase = true;
   IsLittleEndian = false;
   MaxInstLength = 6;
   RestrictCommentStringToStartOfStatement = true;
   StarIsPC = true;
   SupportsDebugInformation = true;
 }
 
 bool SystemZMCAsmInfoGOFF::isAcceptableChar(char C) const {
   return MCAsmInfo::isAcceptableChar(C) || C == '#';
 }

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCTargetDesc.cpp

 }
 
 static MCSubtargetInfo *
 createSystemZMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
   return createSystemZMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
 }
 
 static MCInstPrinter *createSystemZMCInstPrinter(const Triple &T,
-                                                 unsigned SyntaxVariant,
+                                                 AsmDialect::Type Variant,
                                                  const MCAsmInfo &MAI,
                                                  const MCInstrInfo &MII,
                                                  const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::SystemZ_ATT || 
+    Variant == AsmDialect::SystemZ_HLASM)
     return new SystemZInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 void SystemZTargetStreamer::emitConstantPools() {
   // Emit EXRL target instructions.
   if (EXRLTargets2Sym.empty())
     return;
   // Switch to the .text section.
   const MCObjectFileInfo &OFI = *Streamer.getContext().getObjectFileInfo();

llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp

void SystemZAsmPrinter::emitMachineConstantPoolValue(
   uint64_t Size = getDataLayout().getTypeAllocSize(ZCPV->getType());
 
   OutStreamer->emitValue(Expr, Size);
 }
 
 static void printFormattedRegName(const MCAsmInfo *MAI, unsigned RegNo,
                                   raw_ostream &OS) {
   const char *RegName = SystemZInstPrinter::getRegisterName(RegNo);
-  if (MAI->getAssemblerDialect() == AD_HLASM) {
+  if (MAI->getAssemblerDialect() == AsmDialect::SystemZ_HLASM) {
     // Skip register prefix so that only register number is left
     assert(isalpha(RegName[0]) && isdigit(RegName[1]));
     OS << (RegName + 1);
   } else
     OS << '%' << RegName;
 }
 
 static void printOperand(const MCOperand &MCOp, const MCAsmInfo *MAI,

llvm/lib/Target/VE/MCTargetDesc/VEMCTargetDesc.cpp

static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
   return new VETargetAsmStreamer(S, OS);
 }
 
 static MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) {
   return new VETargetStreamer(S);
 }
 
 static MCInstPrinter *createVEMCInstPrinter(const Triple &T,
-                                            unsigned SyntaxVariant,
+                                            AsmDialect::Type Variant,
                                             const MCAsmInfo &MAI,
                                             const MCInstrInfo &MII,
                                             const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::VE_Generic)
     return new VEInstPrinter(MAI, MII, MRI);
+
+  assert(false && "Unknown or unsupported syntax variant.");
+
+  return nullptr;
 }
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeVETargetMC() {
   // Register the MC asm info.
   RegisterMCAsmInfoFn X(getTheVETarget(), createVEMCAsmInfo);
 
   for (Target *T : {&getTheVETarget()}) {
     // Register the MC instruction info.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp

 
 static MCRegisterInfo *createMCRegisterInfo(const Triple & /*T*/) {
   auto *X = new MCRegisterInfo();
   InitWebAssemblyMCRegisterInfo(X, 0);
   return X;
 }
 
 static MCInstPrinter *createMCInstPrinter(const Triple & /*T*/,
-                                          unsigned SyntaxVariant,
+                                          AsmDialect::Type Variant,
                                           const MCAsmInfo &MAI,
                                           const MCInstrInfo &MII,
                                           const MCRegisterInfo &MRI) {
-  assert(SyntaxVariant == 0 && "WebAssembly only has one syntax variant");
+  if (Variant == AsmDialect::WebAssembly_Generic)
     return new WebAssemblyInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 static MCCodeEmitter *createCodeEmitter(const MCInstrInfo &MCII,
                                         MCContext &Ctx) {
   return createWebAssemblyMCCodeEmitter(MCII, Ctx);
 }
 
 static MCAsmBackend *createAsmBackend(const Target & /*T*/,

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

   unsigned getPointerWidth() {
     if (is16BitMode()) return 16;
     if (is32BitMode()) return 32;
     if (is64BitMode()) return 64;
     llvm_unreachable("invalid mode");
   }
 
   bool isParsingIntelSyntax() {
-    return getParser().getAssemblerDialect();
+    return getParser().getAssemblerDialect() == AsmDialect::X86_Intel;
   }
 
   /// @name Auto-generated Matcher Functions
   /// {
 
 #define GET_ASSEMBLER_HEADER
 #include "X86GenAsmMatcher.inc"
 
else if (IDVal.startswith(".att_syntax")) {
     if (getLexer().isNot(AsmToken::EndOfStatement)) {
       if (Parser.getTok().getString() == "prefix")
         Parser.Lex();
       else if (Parser.getTok().getString() == "noprefix")
         return Error(DirectiveID.getLoc(), "'.att_syntax noprefix' is not "
                                            "supported: registers must have a "
                                            "'%' prefix in .att_syntax");
     }
-    getParser().setAssemblerDialect(0);
+    getParser().setAssemblerDialect(AsmDialect::X86_ATT);
     return false;
   } else if (IDVal.startswith(".intel_syntax")) {
-    getParser().setAssemblerDialect(1);
+    getParser().setAssemblerDialect(AsmDialect::X86_Intel);
     if (getLexer().isNot(AsmToken::EndOfStatement)) {
       if (Parser.getTok().getString() == "noprefix")
         Parser.Lex();
       else if (Parser.getTok().getString() == "prefix")
         return Error(DirectiveID.getLoc(), "'.intel_syntax prefix' is not "
                                            "supported: registers must not have "
                                            "a '%' prefix in .intel_syntax");
     }

llvm/lib/Target/X86/MCTargetDesc/X86MCAsmInfo.cpp

 
 #include "X86MCAsmInfo.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/TargetParser/Triple.h"
 using namespace llvm;
 
-enum AsmWriterFlavorTy {
-  // Note: This numbering has to match the GCC assembler dialects for inline
-  // asm alternatives to work right.
-  ATT = 0, Intel = 1
-};
-
-static cl::opt<AsmWriterFlavorTy> AsmWriterFlavor(
-    "x86-asm-syntax", cl::init(ATT), cl::Hidden,
+static cl::opt<AsmDialect::Type> AsmWriterFlavor(
+    "x86-asm-syntax", cl::init(AsmDialect::X86_ATT), cl::Hidden,
     cl::desc("Choose style of code to emit from X86 backend:"),
-    cl::values(clEnumValN(ATT, "att", "Emit AT&T-style assembly"),
-               clEnumValN(Intel, "intel", "Emit Intel-style assembly")));
+    cl::values(clEnumValN(AsmDialect::X86_ATT, "att",
+                          "Emit AT&T-style assembly"),
+               clEnumValN(AsmDialect::X86_Intel, "intel",
+                          "Emit Intel-style assembly")));
 
 static cl::opt<bool>
 MarkedJTDataRegions("mark-data-regions", cl::init(true),
   cl::desc("Mark code section jump table data regions."),
   cl::Hidden);
 
 void X86MCAsmInfoDarwin::anchor() { }
 

llvm/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

static MCAsmInfo *createX86MCAsmInfo(const MCRegisterInfo &MRI,
   MCCFIInstruction Inst2 = MCCFIInstruction::createOffset(
       nullptr, MRI.getDwarfRegNum(InstPtr, true), stackGrowth);
   MAI->addInitialFrameState(Inst2);
 
   return MAI;
 }
 
 static MCInstPrinter *createX86MCInstPrinter(const Triple &T,
-                                             unsigned SyntaxVariant,
+                                             AsmDialect::Type Variant,
                                              const MCAsmInfo &MAI,
                                              const MCInstrInfo &MII,
                                              const MCRegisterInfo &MRI) {
-  if (SyntaxVariant == 0)
+  if (Variant == AsmDialect::X86_ATT)
     return new X86ATTInstPrinter(MAI, MII, MRI);
-  if (SyntaxVariant == 1)
+  else if (Variant == AsmDialect::X86_Intel)
     return new X86IntelInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
   return nullptr;
 }
 
 static MCRelocationInfo *createX86MCRelocationInfo(const Triple &TheTriple,
                                                    MCContext &Ctx) {
   // Default to the stock relocation info.
   return llvm::createMCRelocationInfo(TheTriple, Ctx);
 }

llvm/lib/Target/XCore/MCTargetDesc/XCoreMCTargetDesc.cpp

static MCAsmInfo *createXCoreMCAsmInfo(const MCRegisterInfo &MRI,
   // Initial state of the frame pointer is SP.
   MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(nullptr, XCore::SP, 0);
   MAI->addInitialFrameState(Inst);
 
   return MAI;
 }
 
 static MCInstPrinter *createXCoreMCInstPrinter(const Triple &T,
-                                               unsigned SyntaxVariant,
+                                               AsmDialect::Type Variant,
                                                const MCAsmInfo &MAI,
                                                const MCInstrInfo &MII,
                                                const MCRegisterInfo &MRI) {
+  if (Variant == AsmDialect::XCore_Generic)
     return new XCoreInstPrinter(MAI, MII, MRI);
+  assert(false && "Unknown or unsupported syntax variant.");
+  return nullptr;
 }
 
 XCoreTargetStreamer::XCoreTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
 
 XCoreTargetStreamer::~XCoreTargetStreamer() = default;
 
 namespace {
 

llvm/tools/llvm-exegesis/lib/DisassemblerHelper.cpp

 
 DisassemblerHelper::DisassemblerHelper(const LLVMState &State) : State_(State) {
   MCTargetOptions MCOptions;
   const auto &TM = State.getTargetMachine();
   const auto &Triple = TM.getTargetTriple();
   AsmInfo_.reset(TM.getTarget().createMCAsmInfo(State_.getRegInfo(),
                                                 Triple.str(), MCOptions));
   InstPrinter_.reset(TM.getTarget().createMCInstPrinter(
-      Triple, 0 /*default variant*/, *AsmInfo_, State_.getInstrInfo(),
+      Triple, AsmDialect::Generic, *AsmInfo_, State_.getInstrInfo(),
       State_.getRegInfo()));
 
   Context_ = std::make_unique<MCContext>(
       Triple, AsmInfo_.get(), &State_.getRegInfo(), &State_.getSubtargetInfo());
   Disasm_.reset(TM.getTarget().createMCDisassembler(State_.getSubtargetInfo(),
                                                     *Context_));
   assert(Disasm_ && "cannot create MCDisassembler. missing call to "
                     "InitializeXXXTargetDisassembler ?");
 }
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
   raw_pwrite_stream *OS = &Out->os();
   std::unique_ptr<MCStreamer> Str;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   assert(MCII && "Unable to create instruction info!");
 
   MCInstPrinter *IP = nullptr;
   if (FileType == OFT_AssemblyFile) {
-    IP = TheTarget->createMCInstPrinter(Triple(TripleName), OutputAsmVariant,
-                                        *MAI, *MCII, *MRI);
+    IP = TheTarget->createMCInstPrinter(
+        Triple(TripleName), (AsmDialect::Type)OutputAsmVariant.getValue(),
 
     if (!IP) {
       WithColor::error()
           << "unable to create instruction printer for target triple '"
           << TheTriple.normalize() << "' with assembly variant "
           << OutputAsmVariant << ".\n";
       return 1;
     }

llvm/tools/llvm-mca/CodeRegionGenerator.h

 
 /// This abstract class is responsible for parsing input ASM and
 /// generating a CodeRegions instance.
 class AsmCodeRegionGenerator : public virtual CodeRegionGenerator {
   const Target &TheTarget;
   const MCAsmInfo &MAI;
   const MCSubtargetInfo &STI;
   const MCInstrInfo &MCII;
-  unsigned AssemblerDialect; // This is set during parsing.
+  AsmDialect::Type AssemblerDialect; // This is set during parsing.
 
 protected:
   MCContext &Ctx;
 
 public:
   AsmCodeRegionGenerator(const Target &T, MCContext &C, const MCAsmInfo &A,
                          const MCSubtargetInfo &S, const MCInstrInfo &I)
-      : TheTarget(T), MAI(A), STI(S), MCII(I), AssemblerDialect(0), Ctx(C) {}
+      : TheTarget(T), MAI(A), STI(S), MCII(I),
+        AssemblerDialect(AsmDialect::Generic), Ctx(C) {}
 
   virtual MCACommentConsumer *getCommentConsumer() = 0;
   virtual CodeRegions &getRegions() = 0;
   virtual MCStreamerWrapper *getMCStreamer() = 0;
 
-  unsigned getAssemblerDialect() const { return AssemblerDialect; }
+  AsmDialect::Type getAssemblerDialect() const { return AssemblerDialect; }
   Expected<const CodeRegions &>
   parseCodeRegions(const std::unique_ptr<MCInstPrinter> &IP) override;
 };
 
 class AsmAnalysisRegionGenerator final : public AnalysisRegionGenerator,
                                          public AsmCodeRegionGenerator {
   AnalysisRegionCommentConsumer CC;
   MCStreamerWrapper Streamer;

llvm/tools/llvm-mca/llvm-mca.cpp

std::unique_ptr<MCInstrAnalysis> MCIA(
       TheTarget->createMCInstrAnalysis(MCII.get()));
 
   // Need to initialize an MCInstPrinter as it is
   // required for initializing the MCTargetStreamer
   // which needs to happen within the CRG.parseAnalysisRegions() call below.
   // Without an MCTargetStreamer, certain assembly directives can trigger a
   // segfault. (For example, the .cv_fpo_proc directive on x86 will segfault if
   // we don't initialize the MCTargetStreamer.)
-  unsigned IPtempOutputAsmVariant =
-      OutputAsmVariant == -1 ? 0 : OutputAsmVariant;
+  const AsmDialect::Type IPtempOutputAsmVariant =
+      (AsmDialect::Type)(OutputAsmVariant == -1 ? 0 : OutputAsmVariant);
   std::unique_ptr<MCInstPrinter> IPtemp(TheTarget->createMCInstPrinter(
       Triple(TripleName), IPtempOutputAsmVariant, *MAI, *MCII, *MRI));
   if (!IPtemp) {
     WithColor::error()
         << "unable to create instruction printer for target triple '"
         << TheTriple.normalize() << "' with assembly variant "
         << IPtempOutputAsmVariant << ".\n";
     return 1;
int main(int argc, char **argv) {
 
   // Now initialize the output file.
   auto OF = getOutputStream();
   if (std::error_code EC = OF.getError()) {
     WithColor::error() << EC.message() << '\n';
     return 1;
   }
 
-  unsigned AssemblerDialect = CRG.getAssemblerDialect();
+  AsmDialect::Type AssemblerDialect = CRG.getAssemblerDialect();
   if (OutputAsmVariant >= 0)
-    AssemblerDialect = static_cast<unsigned>(OutputAsmVariant);
+    AssemblerDialect = (AsmDialect::Type)OutputAsmVariant.getValue();
   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
       Triple(TripleName), AssemblerDialect, *MAI, *MCII, *MRI));
   if (!IP) {
     WithColor::error()
         << "unable to create instruction printer for target triple '"
         << TheTriple.normalize() << "' with assembly variant "
         << AssemblerDialect << ".\n";
     return 1;