[EraVM][MC] Reuse analyzeMCOperandsStack for adjusting opcode on encoding

Author: atrosinenko

llvm/lib/Target/EraVM/MCTargetDesc/EraVMAsmBackend.cpp

@@ -231,6 +231,19 @@ void EraVM::analyzeMCOperandsStack(const MCInst &MI, unsigned Idx, bool IsSrc,
   Addend &= 0xFFFF;
 }
 
+EraVM::MemOperandKind EraVM::getStackOperandKind(const MCInst &MI, unsigned Idx,
+                                                 bool IsSrc) {
+  // TODO After refactoring, make analyzeMCOperandsStack() call this function.
+  // For now, calling this way to not reimplement handling of (@SYM, 0, 0) here.
+  unsigned Reg = 0;
+  MemOperandKind Kind = MemOperandKind::OperandInvalid;
+  const MCSymbol *Symbol = nullptr;
+  int Addend = 0;
+
+  analyzeMCOperandsStack(MI, Idx, IsSrc, Reg, Kind, Symbol, Addend);
+  return Kind;
+}
+
 static MCOperand createStackOperandMarker(EraVM::MemOperandKind Kind) {
   switch (Kind) {
   default:

llvm/lib/Target/EraVM/MCTargetDesc/EraVMMCCodeEmitter.cpp

@@ -91,15 +91,9 @@ class EraVMMCCodeEmitter : public MCCodeEmitter {
                             SmallVectorImpl<MCFixup> &Fixups) const;
 };
 
-static int modeEncodingByMarker(const MCOperand &Op) {
-  assert((Op.isImm() || Op.isReg()) && "Unexpected marker operand");
-
-  if (Op.isImm())
-    return EraVM::ModeStackAbs;
-
-  unsigned MarkerReg = Op.getReg();
-  assert(MarkerReg == EraVM::R0 || MarkerReg == EraVM::SP);
-  return (MarkerReg == EraVM::SP) ? EraVM::ModeSpRel : EraVM::ModeSpMod;
+static int getStackModeEncoding(const MCInst &MI, unsigned Idx, bool IsSrc) {
+  EraVM::MemOperandKind Kind = EraVM::getStackOperandKind(MI, Idx, IsSrc);
+  return EraVM::getModeEncodingForOperandKind(Kind);
 }
 
 uint64_t EraVMMCCodeEmitter::adjustForStackOperands(
@@ -117,15 +111,13 @@ uint64_t EraVMMCCodeEmitter::adjustForStackOperands(
   assert(Info && "Incorrect EncodedOpcode produced by the encoder");
 
   if (OldSrcMode == EraVM::ModeStackAbs) {
-    const MCOperand &Op =
-        MI.getOperand(Info->getMCOperandIndexOfStackSrc(Desc));
-    int NewSrcMode = modeEncodingByMarker(Op);
+    unsigned SrcIdx = Info->getMCOperandIndexOfStackSrc(Desc);
+    int NewSrcMode = getStackModeEncoding(MI, SrcIdx, /*IsSrc=*/true);
     EncodedOpcode += (NewSrcMode - (int)OldSrcMode) * (int)Info->SrcMultiplier;
   }
   if (OldDstMode == EraVM::ModeStackAbs) {
-    const MCOperand &Op =
-        MI.getOperand(Info->getMCOperandIndexOfStackDst(Desc));
-    int NewDstMode = modeEncodingByMarker(Op);
+    unsigned DstIdx = Info->getMCOperandIndexOfStackDst(Desc);
+    int NewDstMode = getStackModeEncoding(MI, DstIdx, /*IsSrc=*/false);
     EncodedOpcode += (NewDstMode - (int)OldDstMode) * (int)Info->DstMultiplier;
   }
 

llvm/lib/Target/EraVM/MCTargetDesc/EraVMMCTargetDesc.h

@@ -140,6 +140,9 @@ void analyzeMCOperandsStack(const MCInst &MI, unsigned Idx, bool IsSrc,
                             unsigned &Reg, MemOperandKind &Kind,
                             const MCSymbol *&Symbol, int &Addend);
 
+// Returns the same Kind as analyzeMCOperandsStack returns, without other info.
+MemOperandKind getStackOperandKind(const MCInst &MI, unsigned Idx, bool IsSrc);
+
 void appendMCOperands(MCContext &Ctx, MCInst &MI, MemOperandKind Kind,
                       unsigned Reg, const MCSymbol *Symbol, int Addend);
 
@@ -156,6 +159,23 @@ enum EncodedOperandMode {
   NumSrcModes = 6,
 };
 
+static inline EncodedOperandMode
+getModeEncodingForOperandKind(MemOperandKind Kind) {
+  switch (Kind) {
+  case OperandInvalid:
+    return ModeNotApplicable;
+  case OperandCode:
+    return ModeCode;
+  case OperandStackAbsolute:
+    return ModeStackAbs;
+  case OperandStackSPRelative:
+    return ModeSpRel;
+  case OperandStackSPDecrement:
+  case OperandStackSPIncrement:
+    return ModeSpMod;
+  }
+}
+
 const uint64_t EncodedOpcodeMask = UINT64_C(0x7ff);
 
 const EraVMOpcodeInfo *findOpcodeInfo(unsigned Opcode);