[mips] Add assembler support for .set arch=x directive.

[tomatabacu]

Summary

This directive is similar to ".set mipsX".
It is used to change the CPU target of the assembler, enabling it to accept instructions for a specific CPU.

This patch only implements the r4000 CPU (which is treated internally as generic mips3) and the generic ISAs.

Contains work done by Matheus Almeida.

[tomatabacu]

Improved a parsing error message.
Added a newline at the end of set-arch.s.

[tomatabacu]

Rebased.

[dsanders]

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

344–357

Why not true/false instead of 1/0?

2616–2624

A couple things here. The first is that the emitDirectiveSetArch() should be given the same string as was originally parsed. This will stop '.set arch=r4000' mutating into '.set arch=mips3'. The second is that we can detect unsupported strings at the same time we convert them to feature names using something like:

ArchFeatureName = StringSwitch<std::string>(Arch)
                                  .Case("mips1", "mips1")
                                  ...
                                  .Case("mips64r6", "mips64r6")
                                  .Case("r4000", "mips3")
                                  .Default("");
if (ArchFeatureName.empty())
  return reportParseError(...);
selectArch(ArchFeatureName);
getTargetStreamer().emitDirectiveSetArch(Arch);

test/MC/Mips/set-arch.s

32

This one should be '.set arch=r4000'.

[tomatabacu]

Addressed comments, rebased and ran clang-format.
Also (basically) inlined isSupportedArch.

[dsanders]

LGTM

[tomatabacu]

Improve test and rebased.

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

#include "MipsGenAsmMatcher.inc"
   bool reportParseError(SMLoc Loc, Twine ErrorMsg);
 
   bool parseMemOffset(const MCExpr *&Res, bool isParenExpr);
   bool parseRelocOperand(const MCExpr *&Res);
 
   const MCExpr *evaluateRelocExpr(const MCExpr *Expr, StringRef RelocStr);
 
   bool isEvaluated(const MCExpr *Expr);
+  bool parseSetArchDirective();
   bool parseSetFeature(uint64_t Feature);
   bool parseDirectiveCPLoad(SMLoc Loc);
   bool parseDirectiveCPSetup();
   bool parseDirectiveNaN();
   bool parseDirectiveSet();
   bool parseDirectiveOption();
 
   bool parseSetAtDirective();
bool hasMips64r2() const {
     return (STI.getFeatureBits() & Mips::FeatureMips64r2);
   }
   bool hasMips32r6() const {
     return (STI.getFeatureBits() & Mips::FeatureMips32r6);
   }
   bool hasMips64r6() const {
     return (STI.getFeatureBits() & Mips::FeatureMips64r6);
   }
+
+  bool isSupportedArch(StringRef Arch) {
+    bool Result;
+    Result = StringSwitch<bool>(Arch)
+                 .Case("mips1", 1)
+                 .Case("mips2", 1)
+                 .Case("mips3", 1)
+                 .Case("mips4", 1)
+                 .Case("mips5", 1)
+                 .Case("mips32", 1)
+                 .Case("mips32r2", 1)
+                 .Case("mips32r6", 1)
+                 .Case("mips64", 1)
+                 .Case("mips64r2", 1)
+                 .Case("mips64r6", 1)
+                 .Case("cnmips", 1)
+                 .Case("r4000", 1) // This is an implementation of Mips3!
+                 .Default(0);
+    return Result;
+  }
+
   bool hasDSP() const { return (STI.getFeatureBits() & Mips::FeatureDSP); }
   bool hasDSPR2() const { return (STI.getFeatureBits() & Mips::FeatureDSPR2); }
   bool hasMSA() const { return (STI.getFeatureBits() & Mips::FeatureMSA); }
 
   bool inMips16Mode() const {
     return STI.getFeatureBits() & Mips::FeatureMips16;
   }
   // TODO: see how can we get this info.
bool MipsAsmParser::parseSetAssignment() {
   if (Sym)
     return reportParseError("symbol already defined");
   Sym = getContext().GetOrCreateSymbol(Name);
   Sym->setVariableValue(Value);
 
   return false;
 }
 
+bool MipsAsmParser::parseSetArchDirective() {
+  Parser.Lex();
+  if (getLexer().isNot(AsmToken::Equal))
+    return reportParseError("unexpected token in .set arch directive");
+
+  Parser.Lex();
+  StringRef Arch;
+  if (Parser.parseIdentifier(Arch))
+    return reportParseError("expected arch identifier");
+
+  if (!isSupportedArch(Arch))
+    return reportParseError("unsupported architecture");
+
+  // FIXME: Improve this.
+  if (Arch == "r4000")
+    Arch = "mips3";
+
+  selectArch(Arch);
+  getTargetStreamer().emitDirectiveSetArch(Arch);
+  return false;
+}
+
 bool MipsAsmParser::parseSetFeature(uint64_t Feature) {
   Parser.Lex();
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return reportParseError("unexpected token in .set directive");
 
   switch (Feature) {
   default:
     llvm_unreachable("Unimplemented feature");
bool MipsAsmParser::parseDirectiveSet() {
 
   // Get the next token.
   const AsmToken &Tok = Parser.getTok();
 
   if (Tok.getString() == "noat") {
     return parseSetNoAtDirective();
   } else if (Tok.getString() == "at") {
     return parseSetAtDirective();
+  } else if (Tok.getString() == "arch") {
+    return parseSetArchDirective();
   } else if (Tok.getString() == "fp") {
     return parseSetFpDirective();
   } else if (Tok.getString() == "reorder") {
     return parseSetReorderDirective();
   } else if (Tok.getString() == "noreorder") {
     return parseSetNoReorderDirective();
   } else if (Tok.getString() == "macro") {
     return parseSetMacroDirective();

lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp

 void MipsTargetStreamer::emitDirectiveNaNLegacy() {}
 void MipsTargetStreamer::emitDirectiveOptionPic0() {}
 void MipsTargetStreamer::emitDirectiveOptionPic2() {}
 void MipsTargetStreamer::emitFrame(unsigned StackReg, unsigned StackSize,
                                    unsigned ReturnReg) {}
 void MipsTargetStreamer::emitMask(unsigned CPUBitmask, int CPUTopSavedRegOff) {}
 void MipsTargetStreamer::emitFMask(unsigned FPUBitmask, int FPUTopSavedRegOff) {
 }
+void MipsTargetStreamer::emitDirectiveSetArch(StringRef Arch) {
+  setCanHaveModuleDir(false);
+}
 void MipsTargetStreamer::emitDirectiveSetMips1() {}
 void MipsTargetStreamer::emitDirectiveSetMips2() {}
 void MipsTargetStreamer::emitDirectiveSetMips3() {}
 void MipsTargetStreamer::emitDirectiveSetMips4() {}
 void MipsTargetStreamer::emitDirectiveSetMips5() {}
 void MipsTargetStreamer::emitDirectiveSetMips32() {}
 void MipsTargetStreamer::emitDirectiveSetMips32R2() {}
 void MipsTargetStreamer::emitDirectiveSetMips32R6() {}

 void MipsTargetAsmStreamer::emitFrame(unsigned StackReg, unsigned StackSize,
                                       unsigned ReturnReg) {
   OS << "\t.frame\t$"
      << StringRef(MipsInstPrinter::getRegisterName(StackReg)).lower() << ","
      << StackSize << ",$"
      << StringRef(MipsInstPrinter::getRegisterName(ReturnReg)).lower() << '\n';
 }
 
+void MipsTargetAsmStreamer::emitDirectiveSetArch(StringRef Arch) {
+  OS << "\t.set arch=" << Arch << "\n";
+  MipsTargetStreamer::emitDirectiveSetArch(Arch);
+}
+
 void MipsTargetAsmStreamer::emitDirectiveSetMips1() {
   OS << "\t.set\tmips1\n";
   setCanHaveModuleDir(false);
 }
 
 void MipsTargetAsmStreamer::emitDirectiveSetMips2() {
   OS << "\t.set\tmips2\n";
   setCanHaveModuleDir(false);

lib/Target/Mips/MipsTargetStreamer.h

public:
   virtual void emitDirectiveNaNLegacy();
   virtual void emitDirectiveOptionPic0();
   virtual void emitDirectiveOptionPic2();
   virtual void emitFrame(unsigned StackReg, unsigned StackSize,
                          unsigned ReturnReg);
   virtual void emitMask(unsigned CPUBitmask, int CPUTopSavedRegOff);
   virtual void emitFMask(unsigned FPUBitmask, int FPUTopSavedRegOff);
 
+  virtual void emitDirectiveSetArch(StringRef Arch);
   virtual void emitDirectiveSetMips1();
   virtual void emitDirectiveSetMips2();
   virtual void emitDirectiveSetMips3();
   virtual void emitDirectiveSetMips4();
   virtual void emitDirectiveSetMips5();
   virtual void emitDirectiveSetMips32();
   virtual void emitDirectiveSetMips32R2();
   virtual void emitDirectiveSetMips32R6();
public:
   void emitDirectiveNaNLegacy() override;
   void emitDirectiveOptionPic0() override;
   void emitDirectiveOptionPic2() override;
   void emitFrame(unsigned StackReg, unsigned StackSize,
                  unsigned ReturnReg) override;
   void emitMask(unsigned CPUBitmask, int CPUTopSavedRegOff) override;
   void emitFMask(unsigned FPUBitmask, int FPUTopSavedRegOff) override;
 
+  void emitDirectiveSetArch(StringRef Arch) override;
   void emitDirectiveSetMips1() override;
   void emitDirectiveSetMips2() override;
   void emitDirectiveSetMips3() override;
   void emitDirectiveSetMips4() override;
   void emitDirectiveSetMips5() override;
   void emitDirectiveSetMips32() override;
   void emitDirectiveSetMips32R2() override;
   void emitDirectiveSetMips32R6() override;

test/MC/Mips/set-arch.s

+# RUN: llvm-mc %s -triple=mipsel-unknown-linux -show-encoding -mcpu=mips32 | \
+# RUN: FileCheck %s
+# Note that r4000 is an implementation of mips3.
+.text
+        .set arch=mips1
+        .set arch=mips2
+        .set arch=mips3
+        .set arch=mips4
+        .set arch=mips5
+        .set arch=mips32
+        .set arch=mips32r2
+        .set arch=mips32r6
+        .set arch=mips64
+        .set arch=mips64r2
+        .set arch=mips64r6
+        .set arch=cnmips
+        .set arch=r4000
+
+# CHECK: .set arch=mips1
+# CHECK: .set arch=mips2
+# CHECK: .set arch=mips3
+# CHECK: .set arch=mips4
+# CHECK: .set arch=mips5
+# CHECK: .set arch=mips32
+# CHECK: .set arch=mips32r2
+# CHECK: .set arch=mips32r6
+# CHECK: .set arch=mips64
+# CHECK: .set arch=mips64r2
+# CHECK: .set arch=mips64r6
+# CHECK: .set arch=cnmips
+# CHECK: .set arch=mips3
 No newline at end of file