From 52aa478e15cdb40244e05f3fe8949db9a451a6cd Mon Sep 17 00:00:00 2001
From: Anatoly Trosinenko <atrosinenko@accesssoftek.com>
Date: Tue, 14 May 2024 18:43:02 +0300
Subject: [PATCH] [EraVM][AsmParser] Migrate to new asm syntax

---
 lld/test/ELF/eravm-code-reloc.s               |  60 ++---
 .../Target/EraVM/AsmParser/EraVMAsmParser.cpp |  36 +++
 llvm/lib/Target/EraVM/EraVMInstrFormats.td    |   4 +-
 llvm/lib/Target/EraVM/EraVMInstrInfo.td       |  25 +-
 llvm/lib/Target/EraVM/EraVMOpcodes.td         | 105 ++++----
 .../EraVM/MCTargetDesc/EraVMInstPrinter.cpp   |  25 +-
 llvm/test/CodeGen/EraVM/adjsp.ll              |   6 +-
 llvm/test/CodeGen/EraVM/apint-assert.ll       |   2 +-
 llvm/test/CodeGen/EraVM/array.ll              |  26 +-
 llvm/test/CodeGen/EraVM/as3_nullptr_bug.ll    |   2 +-
 llvm/test/CodeGen/EraVM/bytes2cells.ll        |   4 +-
 .../test/CodeGen/EraVM/calling-convensions.ll | 100 ++++----
 llvm/test/CodeGen/EraVM/compound.ll           |   2 +-
 llvm/test/CodeGen/EraVM/context-remat.ll      |  24 +-
 llvm/test/CodeGen/EraVM/cse-sub-cmp.ll        |  16 +-
 llvm/test/CodeGen/EraVM/cxa_throw.ll          |   4 +-
 llvm/test/CodeGen/EraVM/def-spill.ll          |  24 +-
 .../CodeGen/EraVM/dollar-id-unparentesized.ll |  12 +-
 llvm/test/CodeGen/EraVM/exception-handling.ll |  14 +-
 llvm/test/CodeGen/EraVM/farcall-spill.ll      |  14 +-
 llvm/test/CodeGen/EraVM/fold-add-to-select.ll |   4 +-
 .../EraVM/fold-similar-instructions.ll        |   4 +-
 llvm/test/CodeGen/EraVM/frame_memory.ll       |   4 +-
 llvm/test/CodeGen/EraVM/gasleft-no-sink.ll    |   8 +-
 llvm/test/CodeGen/EraVM/globals.ll            |   4 +-
 llvm/test/CodeGen/EraVM/hoist-flag-setting.ll |   2 +-
 llvm/test/CodeGen/EraVM/immediate-remat.ll    |   8 +-
 llvm/test/CodeGen/EraVM/indexed-memops.ll     |  24 +-
 llvm/test/CodeGen/EraVM/intrinsic.ll          |  98 ++++----
 llvm/test/CodeGen/EraVM/large_offset.ll       |   4 +-
 .../EraVM/machinesink-inst-with-cp-operand.ll |   4 +-
 .../CodeGen/EraVM/memcpy-expansion-asm.ll     |  68 +++---
 llvm/test/CodeGen/EraVM/memintrinsics.ll      |  20 +-
 .../CodeGen/EraVM/memmove-expansion-asm.ll    |  52 ++--
 llvm/test/CodeGen/EraVM/overflow-branch.ll    |  48 ++--
 llvm/test/CodeGen/EraVM/overflow-neg.ll       |   4 +-
 llvm/test/CodeGen/EraVM/overflow.ll           |  50 ++--
 llvm/test/CodeGen/EraVM/pointer.ll            |  24 +-
 llvm/test/CodeGen/EraVM/ptradd.ll             |  64 ++---
 llvm/test/CodeGen/EraVM/ptrpack.ll            |  64 ++---
 llvm/test/CodeGen/EraVM/ptrshrink.ll          |  64 ++---
 llvm/test/CodeGen/EraVM/reload-use.ll         |  18 +-
 llvm/test/CodeGen/EraVM/rol.ll                |  20 +-
 llvm/test/CodeGen/EraVM/ror.ll                |  20 +-
 llvm/test/CodeGen/EraVM/select-zero.ll        |   4 +-
 llvm/test/CodeGen/EraVM/selectcc.ll           |  50 ++--
 llvm/test/CodeGen/EraVM/selectcc_fatptr.ll    |   4 +-
 .../separate-const-offset-from-gep-bug.ll     |   4 +-
 llvm/test/CodeGen/EraVM/stack-address.ll      |  16 +-
 llvm/test/CodeGen/EraVM/storage.ll            |   4 +-
 llvm/test/CodeGen/EraVM/transient.ll          |   4 +-
 llvm/test/CodeGen/EraVM/uma.ll                |  38 +--
 llvm/test/CodeGen/EraVM/zeroinitializer.ll    |   2 +-
 .../asm-parser/arith-instructions-errors.s    |  54 ++---
 llvm/test/MC/EraVM/asm-parser/events.s        |  32 +--
 llvm/test/MC/EraVM/asm-parser/far-calls.s     | 120 +++++-----
 llvm/test/MC/EraVM/asm-parser/far-returns.s   |  24 +-
 .../EraVM/asm-parser/misc-operands-errors.s   |  90 ++++---
 llvm/test/MC/EraVM/asm-parser/misc.s          |  96 ++++----
 .../MC/EraVM/asm-parser/mnemonic-errors.s     | 145 +++++++-----
 llvm/test/MC/EraVM/asm-parser/near-calls.s    |  29 +--
 llvm/test/MC/EraVM/asm-parser/near-returns.s  |  96 ++++----
 .../asm-parser/ptr-instructions-errors.s      | 112 ++++-----
 .../MC/EraVM/asm-parser/ptr-instructions.s    | 224 +++++++++---------
 llvm/test/MC/EraVM/asm-parser/sp-changes.s    | 105 ++++----
 llvm/test/MC/EraVM/asm-parser/storage.s       |  32 +--
 llvm/test/MC/EraVM/asm-parser/uma.s           | 128 +++++-----
 llvm/test/MC/EraVM/decoding/events.txt        |   8 +-
 llvm/test/MC/EraVM/decoding/far-calls.txt     |  24 +-
 llvm/test/MC/EraVM/decoding/misc.txt          |  26 +-
 llvm/test/MC/EraVM/decoding/near-calls.txt    |   2 +-
 llvm/test/MC/EraVM/decoding/nop.txt           |  50 ++--
 .../MC/EraVM/decoding/ptr-instructions.txt    |  96 ++++----
 llvm/test/MC/EraVM/decoding/returns.txt       |  16 +-
 llvm/test/MC/EraVM/decoding/sp-changes.txt    |  16 +-
 llvm/test/MC/EraVM/decoding/storage.txt       |   8 +-
 llvm/test/MC/EraVM/decoding/uma.txt           |  36 +--
 llvm/test/MC/EraVM/encoding/data.ll           |   4 +-
 llvm/test/MC/EraVM/encoding/events.s          |  16 +-
 llvm/test/MC/EraVM/encoding/far-calls.s       |  48 ++--
 llvm/test/MC/EraVM/encoding/misc.s            |  49 ++--
 llvm/test/MC/EraVM/encoding/named-constants.s |  16 +-
 llvm/test/MC/EraVM/encoding/near-calls.s      |  14 +-
 .../test/MC/EraVM/encoding/ptr-instructions.s | 192 +++++++--------
 llvm/test/MC/EraVM/encoding/returns.s         |  32 +--
 llvm/test/MC/EraVM/encoding/sp-changes.s      |  32 +--
 llvm/test/MC/EraVM/encoding/storage.s         |  16 +-
 llvm/test/MC/EraVM/encoding/uma.s             |  80 +++----
 .../Inputs/eravm-basic.ll.expected            |   4 +-
 89 files changed, 1736 insertions(+), 1647 deletions(-)

diff --git a/lld/test/ELF/eravm-code-reloc.s b/lld/test/ELF/eravm-code-reloc.s
index 5f55544cf1d5..474a94cdd06f 100644
--- a/lld/test/ELF/eravm-code-reloc.s
+++ b/lld/test/ELF/eravm-code-reloc.s
@@ -66,24 +66,24 @@ foo_local:
   .type caller_g,@function
   .globl caller_g
 caller_g:
-  near_call r1, @foo, @handler
-  far_call  r3, r4, @foo
+  call r1, @foo, @handler
+  callf  r3, r4, @foo
   add   @.OUTLINED_FUNCTION_RET0, r0, stack-[1]
   jump  @foo_local
 .OUTLINED_FUNCTION_RET0:
   jump @label
-  ret.ok.to_label    r1, @label
-  ret.revert.to_label r1, @label
-  ret.panic.to_label @label
+  retl r1, @label
+  revl r1, @label
+  pncl @label
   .globl label
 label:
   jump code[@jump_table + 1]
   ret
 ; INPUT-LABEL: <caller_g>:
-; INPUT-NEXT:  00 00 00 00 00 01 04 0f        near_call       r1, 0, 0
+; INPUT-NEXT:  00 00 00 00 00 01 04 0f        call       r1, 0, 0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      handler
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      foo
-; INPUT-NEXT:  00 00 00 00 00 43 04 21        far_call        r3, r4, 0
+; INPUT-NEXT:  00 00 00 00 00 43 04 21        callf        r3, r4, 0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      foo
 ; INPUT-NEXT:  00 01 00 00 00 00 00 3d add 0, r0, stack-[1 + r0]
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8 .text+0x40
@@ -91,11 +91,11 @@ label:
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8  .text+0x18
 ; INPUT-NEXT:  00 00 00 00 00 00 01 3d        jump    0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      label
-; INPUT-NEXT:  00 00 00 00 00 01 04 2e        ret.ok.to_label r1, 0
+; INPUT-NEXT:  00 00 00 00 00 01 04 2e        retl 0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      label
-; INPUT-NEXT:  00 00 00 00 00 01 04 30        ret.revert.to_label     r1, 0
+; INPUT-NEXT:  00 00 00 00 00 01 04 30        revl 0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      label
-; INPUT-NEXT:  00 00 00 00 00 00 04 32        ret.panic.to_label      0
+; INPUT-NEXT:  00 00 00 00 00 00 04 32        pncl      0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      label
 ; INPUT-LABEL: <label>:
 ; INPUT-NEXT:  00 00 00 01 00 00 01 3e        jump    code[1]
@@ -103,14 +103,14 @@ label:
 ; INPUT-NEXT:  00 00 00 00 00 01 04 2d        ret
 
 ; OUTPUT-LABEL: <caller_g>:
-; OUTPUT-NEXT:  00 12 00 13 00 01 04 0f        near_call       r1, 19, 18
-; OUTPUT-NEXT:  00 00 00 13 00 43 04 21        far_call        r3, r4, 19
+; OUTPUT-NEXT:  00 12 00 13 00 01 04 0f        call       r1, 19, 18
+; OUTPUT-NEXT:  00 00 00 13 00 43 04 21        callf        r3, r4, 19
 ; OUTPUT-NEXT:  00 01 00 18 00 00 00 3d        add     24, r0, stack-[1 + r0]
 ; OUTPUT-NEXT:  00 00 00 13 00 00 01 3d        jump    19
 ; OUTPUT-NEXT:  00 00 00 1c 00 00 01 3d        jump    28
-; OUTPUT-NEXT:  00 00 00 1c 00 01 04 2e        ret.ok.to_label r1, 28
-; OUTPUT-NEXT:  00 00 00 1c 00 01 04 30        ret.revert.to_label     r1, 28
-; OUTPUT-NEXT:  00 00 00 1c 00 00 04 32        ret.panic.to_label      28
+; OUTPUT-NEXT:  00 00 00 1c 00 01 04 2e        retl    28
+; OUTPUT-NEXT:  00 00 00 1c 00 01 04 30        revl    28
+; OUTPUT-NEXT:  00 00 00 1c 00 00 04 32        pncl    28
 ; OUTPUT-LABEL: <label>:
 ; OUTPUT-NEXT:  00 00 00 02 00 00 01 3e        jump    code[2]
 ; OUTPUT-NEXT:  00 00 00 00 00 01 04 2d        ret
@@ -119,30 +119,30 @@ label:
   .type caller_l,@function
   .globl caller_l
 caller_l:
-  near_call r1, @foo_local, @handler_local
-  far_call  r3, r4, @foo_local
+  call r1, @foo_local, @handler_local
+  callf  r3, r4, @foo_local
   jump @label_local
-  ret.ok.to_label    r1, @label_local
-  ret.revert.to_label r1, @label_local
-  ret.panic.to_label @label_local
+  retl r1, @label_local
+  revl r1, @label_local
+  pncl @label_local
   .local label_local
 label_local:
   jump code[@jump_table_local + 1]
   ret
 
 ; INPUT-LABEL: <caller_l>:
-; INPUT-NEXT:  00 00 00 00 00 01 04 0f        near_call       r1, 0, 0
+; INPUT-NEXT:  00 00 00 00 00 01 04 0f        call       r1, 0, 0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      .text+0x10
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      .text+0x18
-; INPUT-NEXT:  00 00 00 00 00 43 04 21        far_call        r3, r4, 0
+; INPUT-NEXT:  00 00 00 00 00 43 04 21        callf        r3, r4, 0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      .text+0x18
 ; INPUT-NEXT:  00 00 00 00 00 00 01 3d        jump    0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      .text+0xa0
-; INPUT-NEXT:  00 00 00 00 00 01 04 2e        ret.ok.to_label r1, 0
+; INPUT-NEXT:  00 00 00 00 00 01 04 2e        retl    0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      .text+0xa0
-; INPUT-NEXT:  00 00 00 00 00 01 04 30        ret.revert.to_label     r1, 0
+; INPUT-NEXT:  00 00 00 00 00 01 04 30        revl    0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      .text+0xa0
-; INPUT-NEXT:  00 00 00 00 00 00 04 32        ret.panic.to_label     0
+; INPUT-NEXT:  00 00 00 00 00 00 04 32        pncl     0
 ; INPUT-NEXT:                 R_ERAVM_16_SCALE_8      .text+0xa0
 ; INPUT-LABEL: <label_local>:
 ; INPUT-NEXT:  00 00 00 01 00 00 01 3e        jump    code[1]
@@ -150,12 +150,12 @@ label_local:
 ; INPUT-NEXT:  00 00 00 00 00 01 04 2d        ret
 
 ; OUTPUT-LABEL: <caller_l>:
-; OUTPUT-NEXT:  00 12 00 13 00 01 04 0f        near_call       r1, 19, 18
-; OUTPUT-NEXT:  00 00 00 13 00 43 04 21        far_call        r3, r4, 19
+; OUTPUT-NEXT:  00 12 00 13 00 01 04 0f        call    r1, 19, 18
+; OUTPUT-NEXT:  00 00 00 13 00 43 04 21        callf   r3, r4, 19
 ; OUTPUT-NEXT:  00 00 00 24 00 00 01 3d        jump    36
-; OUTPUT-NEXT:  00 00 00 24 00 01 04 2e        ret.ok.to_label r1, 36
-; OUTPUT-NEXT:  00 00 00 24 00 01 04 30        ret.revert.to_label     r1, 36
-; OUTPUT-NEXT:  00 00 00 24 00 00 04 32        ret.panic.to_label      36
+; OUTPUT-NEXT:  00 00 00 24 00 01 04 2e        retl    36
+; OUTPUT-NEXT:  00 00 00 24 00 01 04 30        revl    36
+; OUTPUT-NEXT:  00 00 00 24 00 00 04 32        pncl    36
 ; OUTPUT-LABEL: <label_local>:
 ; OUTPUT-NEXT:  00 00 00 02 00 00 01 3e        jump    code[2]
 ; OUTPUT-NEXT:  00 00 00 00 00 01 04 2d        ret
diff --git a/llvm/lib/Target/EraVM/AsmParser/EraVMAsmParser.cpp b/llvm/lib/Target/EraVM/AsmParser/EraVMAsmParser.cpp
index a9cd50056bf1..35cc695fa31b 100644
--- a/llvm/lib/Target/EraVM/AsmParser/EraVMAsmParser.cpp
+++ b/llvm/lib/Target/EraVM/AsmParser/EraVMAsmParser.cpp
@@ -72,6 +72,8 @@ class EraVMAsmParser : public MCTargetAsmParser {
   OperandMatchResultTy tryParseStackOperand(OperandVector &Operands);
   OperandMatchResultTy tryParseCodeOperand(OperandVector &Operands);
 
+  bool parseAdjSP(OperandVector &Operands);
+
   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                         SMLoc NameLoc, OperandVector &Operands) override;
 
@@ -682,6 +684,36 @@ EraVMAsmParser::tryParseCodeOperand(OperandVector &Operands) {
   return MatchOperand_Success;
 }
 
+bool EraVMAsmParser::parseAdjSP(OperandVector &Operands) {
+  SMLoc S, E;
+  MCRegister Reg;
+  int Addend = 0;
+
+  while (!parseOptionalToken(AsmToken::EndOfStatement)) {
+    switch (getTok().getKind()) {
+    default:
+      return TokError("unexpected token");
+    case AsmToken::Identifier:
+      if (tryParseRegister(Reg, S, E))
+        return Error(getTok().getLoc(), "cannot parse register");
+      Operands.push_back(EraVMOperand::CreateReg(Reg, S, E));
+      break;
+    case AsmToken::Plus:
+      Operands.push_back(EraVMOperand::CreateToken("+", getTok().getLoc()));
+      Lex(); // eat "+" token
+      break;
+    case AsmToken::Integer:
+      Addend = getTok().getIntVal();
+      S = getTok().getLoc();
+      E = getTok().getEndLoc();
+      Operands.push_back(EraVMOperand::CreateImm(createConstant(Addend), S, E));
+      Lex(); // eat integer token
+      break;
+    }
+  }
+  return false;
+}
+
 bool EraVMAsmParser::ParseInstruction(ParseInstructionInfo &Info,
                                       StringRef Name, SMLoc NameLoc,
                                       OperandVector &Operands) {
@@ -690,6 +722,10 @@ bool EraVMAsmParser::ParseInstruction(ParseInstructionInfo &Info,
 
   StringRef Mnemonic = static_cast<EraVMOperand &>(*Operands[0]).getToken();
   applyMnemonicAliases(Mnemonic, getAvailableFeatures(), /*VariantID=*/0);
+
+  if (Mnemonic == "incsp" || Mnemonic == "decsp")
+    return parseAdjSP(Operands);
+
   auto ParseOne = [this, Mnemonic, &Operands]() {
     return parseOperand(Mnemonic, Operands);
   };
diff --git a/llvm/lib/Target/EraVM/EraVMInstrFormats.td b/llvm/lib/Target/EraVM/EraVMInstrFormats.td
index 50fce1e9b2a4..ef44cdcf4776 100644
--- a/llvm/lib/Target/EraVM/EraVMInstrFormats.td
+++ b/llvm/lib/Target/EraVM/EraVMInstrFormats.td
@@ -767,8 +767,8 @@ class IFarCall<EraVMOpcode opcode,
 
   string Modifiers =
       !cond(!eq({is_static, is_shard}, {0, 0}): "",
-            !eq({is_static, is_shard}, {1, 0}): ".static",
-            !eq({is_static, is_shard}, {0, 1}): ".shard",
+            !eq({is_static, is_shard}, {1, 0}): ".st",
+            !eq({is_static, is_shard}, {0, 1}): ".sh",
             !eq({is_static, is_shard}, {1, 1}): ".st.sh",
             true: ".INVALID");
   let AsmString = !strconcat(opcode.Name, Modifiers, "${cc}", "\t", asmstr);
diff --git a/llvm/lib/Target/EraVM/EraVMInstrInfo.td b/llvm/lib/Target/EraVM/EraVMInstrInfo.td
index 7dff49a1200d..010f34a256e8 100644
--- a/llvm/lib/Target/EraVM/EraVMInstrInfo.td
+++ b/llvm/lib/Target/EraVM/EraVMInstrInfo.td
@@ -401,9 +401,15 @@ def NOPsrs : Isr_s<OpNoOp, NoSwap, PreserveFlags, []>;
 
 def : Pat<(EraVMadd_to_sp GR256:$reg), (NOPrrs R0, R0, R0, $reg, 0, 0)>;
 
-def : InstAlias<"nop${cc}\t${dst0}", (NOPrrs R0, R0, stackout:$dst0, pred:$cc)>;
-def : InstAlias<"nop${cc}\t${src0}", (NOPsrr R0, stackin:$src0, R0, pred:$cc)>;
-def : InstAlias<"nop${cc}",          (NOPrrr R0, R0, R0, pred:$cc)>;
+def : InstAlias<"incsp${cc}\t${reg}",        (NOPrrs R0, R0, R0, GR256:$reg, 0, pred:$cc)>;
+def : InstAlias<"incsp${cc}\t${imm}",        (NOPrrs R0, R0, R0, R0, i16imm:$imm, pred:$cc)>;
+def : InstAlias<"incsp${cc}\t${reg}+${imm}", (NOPrrs R0, R0, R0, GR256:$reg, i16imm:$imm, pred:$cc)>;
+
+def : InstAlias<"decsp${cc}\t${reg}",        (NOPsrr R0, R0, GR256:$reg, 0, R0, pred:$cc)>;
+def : InstAlias<"decsp${cc}\t${imm}",        (NOPsrr R0, R0, R0, i16imm:$imm, R0, pred:$cc)>;
+def : InstAlias<"decsp${cc}\t${reg}+${imm}", (NOPsrr R0, R0, GR256:$reg, i16imm:$imm, R0, pred:$cc)>;
+
+def : InstAlias<"nop${cc}",                  (NOPrrr R0, R0, R0, pred:$cc)>;
 
 // Note that while technically commutative arithmetic instructions are not swappable,
 // it is not a problem as there will be no corresponding instruction defined with SwapOperand = 1
@@ -945,13 +951,10 @@ def THROW : Pseudo<(outs), (ins GR256:$rs0, pred:$cc), [(EraVMthrow GR256:$rs0)]
             PseudoInstExpansion<(REVERTr GR256:$rs0, pred:$cc)>;
 
 def : InstAlias<"ret${cc}", (RETr R1, pred:$cc)>;
-def : InstAlias<"revert${cc}", (REVERTr R1, pred:$cc)>;
+def : InstAlias<"rev${cc}", (REVERTr R1, pred:$cc)>;
 
-// TODO Make these aliases preferred for printing after switching to the new syntax.
-let EmitPriority = 0 in {
-def : InstAlias<"ret.ok.to_label${cc} $dest", (RETrl R1, jmptarget:$dest, pred:$cc)>;
-def : InstAlias<"ret.revert.to_label${cc} $dest", (REVERTrl R1, jmptarget:$dest, pred:$cc)>;
-}
+def : InstAlias<"retl${cc} $dest", (RETrl R1, jmptarget:$dest, pred:$cc)>;
+def : InstAlias<"revl${cc} $dest", (REVERTrl R1, jmptarget:$dest, pred:$cc)>;
 
 def : Pat<(EraVMreturn GR256:$rs0), (RETrl GR256:$rs0, (default_far_return 0))>;
 def : Pat<(EraVMrevert GR256:$rs0), (REVERTrl GR256:$rs0, (default_far_revert 0))>;
@@ -1034,7 +1037,7 @@ let Defs = [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, Fl
 
   // Unfortunately, we cannot encode @DEFAULT_UNWIND_DEST here, so we have to alias to pseudo
   def NEAR_CALL_default_unwind : AsmParserPseudo<(outs), (ins GR256:$in1, jmptarget:$callee),
-                                                 "near_call", "${in1} ${callee}">;
+                                                 "call", "${in1} ${callee}">;
 
   defm FAR_CALL      : FarCallInst<OpFarcall>;
   defm DELEGATE_CALL : FarCallInst<OpDelegate>;
@@ -1049,7 +1052,7 @@ foreach Op = [OpFarcall, OpDelegate, OpMimic] in {
                       !strconcat(Op.Name, ".st.sh")>;
 }
 
-def : InstAlias<"near_call${cc} ${callee}",
+def : InstAlias<"call${cc} ${callee}",
                 (NEAR_CALL_default_unwind R0, jmptarget:$callee, pred:$cc)>;
 
 def : Pat<(EraVMfarcall bb:$unwind), (FAR_CALLrrl R1, R2, bb:$unwind)>;
diff --git a/llvm/lib/Target/EraVM/EraVMOpcodes.td b/llvm/lib/Target/EraVM/EraVMOpcodes.td
index 4a8f589b12ff..0c3fdc0fb325 100644
--- a/llvm/lib/Target/EraVM/EraVMOpcodes.td
+++ b/llvm/lib/Target/EraVM/EraVMOpcodes.td
@@ -145,61 +145,64 @@ def OpShl  : EraVMOpcode<"shl",  463, ArithNCommEncoding>;
 def OpShr  : EraVMOpcode<"shr",  559, ArithNCommEncoding>;
 def OpRol  : EraVMOpcode<"rol",  655, ArithNCommEncoding>;
 def OpRor  : EraVMOpcode<"ror",  751, ArithNCommEncoding>;
-def OpPtrAdd    : EraVMOpcode<"ptr.add",    847, ArithPtrEncoding>;
-def OpPtrSub    : EraVMOpcode<"ptr.sub",    895, ArithPtrEncoding>;
-def OpPtrPack   : EraVMOpcode<"ptr.pack",   943, ArithPtrEncoding>;
-def OpPtrShrink : EraVMOpcode<"ptr.shrink", 991, ArithPtrEncoding>;
-def OpCall      : EraVMOpcode<"near_call",  1039, DirectEncoding>;
-
-def OpContextThis              : EraVMOpcode<"context.this",             1040, DirectEncoding>;
-def OpContextCaller            : EraVMOpcode<"context.caller",           1041, DirectEncoding>;
-def OpContextCodeAddress       : EraVMOpcode<"context.code_source",      1042, DirectEncoding>;
-def OpContextMeta              : EraVMOpcode<"context.meta",             1043, DirectEncoding>;
-def OpContextErgsLeft          : EraVMOpcode<"context.gas_left",         1044, DirectEncoding>;
-def OpContextSp                : EraVMOpcode<"context.sp",               1045, DirectEncoding>;
-def OpContextGetContextU128    : EraVMOpcode<"context.get_context_u128", 1046, DirectEncoding>;
-def OpContextSetContextU128    : EraVMOpcode<"context.set_context_u128", 1047, DirectEncoding>;
-def OpContextSetErgsPerPubdataByte   : EraVMOpcode<"context.set_gas_per_pubdata",    1048, DirectEncoding>;
-def OpContextIncrementTxNumber : EraVMOpcode<"context.inc_tx_num",       1049, DirectEncoding>;
-
-def OpSload     : EraVMOpcode<"sload",      1050, DirectEncoding>;
-def OpSstore    : EraVMOpcode<"sstore",     1051, DirectEncoding>;
-
-def OpLogToL1         : EraVMOpcode<"to_l1",       1052, DirectEncoding>; // is_first ⇒ 1052 + is_first
-def OpLogToL1Initial  : EraVMOpcode<"to_l1.first", 1053, DirectEncoding>;
-def OpLogEvent        : EraVMOpcode<"event",       1054, DirectEncoding>; // is_first ⇒ 1054 + is_first
-def OpLogEventInitial : EraVMOpcode<"event.first", 1055, DirectEncoding>;
-def OpLogPrecompile   : EraVMOpcode<"precompile",  1056, DirectEncoding>;
-
-def OpFarcall  : EraVMOpcode<"far_call",     1057, FarCallEncoding>; // is_shard is_static ⇒ 1057 + 2 × is_static + is_shard
-def OpDelegate : EraVMOpcode<"far_call.delegate", 1061, FarCallEncoding>; // is_shard is_static ⇒ 1061 + 2 × is_static + is_shard
-def OpMimic    : EraVMOpcode<"far_call.mimic",    1065, FarCallEncoding>; // is_shard is_static ⇒ 1065 + 2 × is_static + is_shard
-
-def OpRet           : EraVMOpcode<"ret.ok",              1069, DirectEncoding>; // to_label ⇒ 1069 + to_label
-def OpRetToLabel    : EraVMOpcode<"ret.ok.to_label",     1070, DirectEncoding>;
-def OpRevert        : EraVMOpcode<"ret.revert",          1071, DirectEncoding>; // to_label ⇒ 1071 + to_label
-def OpRevertToLabel : EraVMOpcode<"ret.revert.to_label", 1072, DirectEncoding>;
-def OpPanic         : EraVMOpcode<"panic",               1073, DirectEncoding>; // to_label ⇒ 1073 + to_label
-def OpPanicToLabel  : EraVMOpcode<"ret.panic.to_label",  1074, DirectEncoding>;
-
-def OpLoadHeap        : EraVMOpcode<"ld.1",     1075, HeapOpEncoding>; // src inc ⇒ 1075 + 10 × src + inc
-def OpLoadHeapInc     : EraVMOpcode<"ld.1.inc", 1076, HeapOpEncoding>;
-def OpStoreHeap       : EraVMOpcode<"st.1",     1077, HeapOpEncoding>; // src inc ⇒ 1077 + 10 × src + inc
-def OpStoreHeapInc    : EraVMOpcode<"st.1.inc", 1078, HeapOpEncoding>;
-
-def OpLoadAuxHeap     : EraVMOpcode<"ld.2",     1079, HeapOpEncoding>; // src inc ⇒ 1079 + 10 × src + inc
-def OpLoadAuxHeapInc  : EraVMOpcode<"ld.2.inc", 1080, HeapOpEncoding>;
-def OpStoreAuxHeap    : EraVMOpcode<"st.2",     1081, HeapOpEncoding>; // src inc ⇒ 1081 + 10 × src + inc
-def OpStoreAuxHeapInc : EraVMOpcode<"st.2.inc", 1082, HeapOpEncoding>;
+
+def OpPtrAdd    : EraVMOpcode<"addp",  847, ArithPtrEncoding>;
+def OpPtrSub    : EraVMOpcode<"subp",  895, ArithPtrEncoding>;
+def OpPtrPack   : EraVMOpcode<"pack",  943, ArithPtrEncoding>;
+def OpPtrShrink : EraVMOpcode<"shrnk", 991, ArithPtrEncoding>;
+def OpCall      : EraVMOpcode<"call",  1039, DirectEncoding>;
+
+def OpContextThis              : EraVMOpcode<"this", 1040, DirectEncoding>;
+def OpContextCaller            : EraVMOpcode<"par",  1041, DirectEncoding>;
+def OpContextCodeAddress       : EraVMOpcode<"code", 1042, DirectEncoding>;
+def OpContextMeta              : EraVMOpcode<"meta", 1043, DirectEncoding>;
+def OpContextErgsLeft          : EraVMOpcode<"ergs", 1044, DirectEncoding>;
+def OpContextSp                : EraVMOpcode<"sp",   1045, DirectEncoding>;
+def OpContextGetContextU128    : EraVMOpcode<"ldvl", 1046, DirectEncoding>;
+def OpContextSetContextU128    : EraVMOpcode<"stvl", 1047, DirectEncoding>;
+def OpContextIncrementTxNumber : EraVMOpcode<"inctx", 1049, DirectEncoding>;
+
+// Removed in VM 1.5.0
+def OpContextSetErgsPerPubdataByte : EraVMOpcode<"stpub", 1048, DirectEncoding>;
+
+def OpSload     : EraVMOpcode<"lds", 1050, DirectEncoding>;
+def OpSstore    : EraVMOpcode<"sts", 1051, DirectEncoding>;
+
+def OpLogToL1         : EraVMOpcode<"logL1",   1052, DirectEncoding>; // is_initializer ⇒ 1052 + is_initializer
+def OpLogToL1Initial  : EraVMOpcode<"logL1.i", 1053, DirectEncoding>;
+def OpLogEvent        : EraVMOpcode<"log",     1054, DirectEncoding>; // is_initializer ⇒ 1054 + is_initializer
+def OpLogEventInitial : EraVMOpcode<"log.i",   1055, DirectEncoding>;
+def OpLogPrecompile   : EraVMOpcode<"callp",   1056, DirectEncoding>;
+
+def OpFarcall  : EraVMOpcode<"callf", 1057, FarCallEncoding>; // is_shard is_static ⇒ 1057 + 2 × is_static + is_shard
+def OpDelegate : EraVMOpcode<"calld", 1061, FarCallEncoding>; // is_shard is_static ⇒ 1061 + 2 × is_static + is_shard
+def OpMimic    : EraVMOpcode<"callm", 1065, FarCallEncoding>; // is_shard is_static ⇒ 1065 + 2 × is_static + is_shard
+
+def OpRet           : EraVMOpcode<"ret",  1069, DirectEncoding>; // to_label ⇒ 1069 + to_label
+def OpRetToLabel    : EraVMOpcode<"retl", 1070, DirectEncoding>;
+def OpRevert        : EraVMOpcode<"rev",  1071, DirectEncoding>; // to_label ⇒ 1071 + to_label
+def OpRevertToLabel : EraVMOpcode<"revl", 1072, DirectEncoding>;
+def OpPanic         : EraVMOpcode<"pnc",  1073, DirectEncoding>; // to_label ⇒ 1073 + to_label
+def OpPanicToLabel  : EraVMOpcode<"pncl", 1074, DirectEncoding>;
+
+def OpLoadHeap        : EraVMOpcode<"ldm.h",   1075, HeapOpEncoding>; // src inc ⇒ 1075 + 10 × src + inc
+def OpLoadHeapInc     : EraVMOpcode<"ldmi.h",  1076, HeapOpEncoding>;
+def OpStoreHeap       : EraVMOpcode<"stm.h",   1077, HeapOpEncoding>; // src inc ⇒ 1077 + 10 × src + inc
+def OpStoreHeapInc    : EraVMOpcode<"stmi.h",  1078, HeapOpEncoding>;
+
+def OpLoadAuxHeap     : EraVMOpcode<"ldm.ah",  1079, HeapOpEncoding>; // src inc ⇒ 1079 + 10 × src + inc
+def OpLoadAuxHeapInc  : EraVMOpcode<"ldmi.ah", 1080, HeapOpEncoding>;
+def OpStoreAuxHeap    : EraVMOpcode<"stm.ah",  1081, HeapOpEncoding>; // src inc ⇒ 1081 + 10 × src + inc
+def OpStoreAuxHeapInc : EraVMOpcode<"stmi.ah", 1082, HeapOpEncoding>;
 
 def OpStaticRead        : EraVMOpcode<"ldm.st",  1096, StaticOpEncoding>; // src inc ⇒ 1096 + 2 × src + inc
 def OpStaticReadInc     : EraVMOpcode<"ldmi.st", 1097, StaticOpEncoding>;
 def OpStaticWrite       : EraVMOpcode<"stm.st",  1100, StaticOpEncoding>; // src inc ⇒ 1100 + 2 × src + inc
 def OpStaticWriteInc    : EraVMOpcode<"stmi.st", 1101, StaticOpEncoding>;
 
-def OpLoadPtr      : EraVMOpcode<"ld",     1083, DirectEncoding>; // inc ⇒ 1083 + inc
-def OpLoadPtrInc   : EraVMOpcode<"ld.inc", 1084, DirectEncoding>;
+def OpLoadPtr      : EraVMOpcode<"ldp",  1083, DirectEncoding>; // inc ⇒ 1083 + inc
+def OpLoadPtrInc   : EraVMOpcode<"ldpi", 1084, DirectEncoding>;
 
-def OpDecommit       : EraVMOpcode<"log.decommit", 1093, DirectEncoding>;
-def OpTransientLoad  : EraVMOpcode<"tload",    1094, DirectEncoding>;
-def OpTransientStore : EraVMOpcode<"tstore",   1095, DirectEncoding>;
+def OpDecommit       : EraVMOpcode<"dcmt", 1093, DirectEncoding>;
+def OpTransientLoad  : EraVMOpcode<"ldt",  1094, DirectEncoding>;
+def OpTransientStore : EraVMOpcode<"stt",  1095, DirectEncoding>;
diff --git a/llvm/lib/Target/EraVM/MCTargetDesc/EraVMInstPrinter.cpp b/llvm/lib/Target/EraVM/MCTargetDesc/EraVMInstPrinter.cpp
index 24fedfee8a02..e7076b11550e 100644
--- a/llvm/lib/Target/EraVM/MCTargetDesc/EraVMInstPrinter.cpp
+++ b/llvm/lib/Target/EraVM/MCTargetDesc/EraVMInstPrinter.cpp
@@ -37,7 +37,7 @@ void EraVMInstPrinter::printInst(const MCInst *MI, uint64_t Address,
   if (Opcode == EraVM::NEAR_CALL_default_unwind) {
     const MCOperand &Reg = MI->getOperand(0);
 
-    O << "\tnear_call";
+    O << "\tcall";
     printCCOperand(MI, 2, O);
     O << '\t';
     if (Reg.getReg() != EraVM::R0) {
@@ -51,6 +51,29 @@ void EraVMInstPrinter::printInst(const MCInst *MI, uint64_t Address,
     return;
   }
 
+  if (Opcode == EraVM::NOPrrs || Opcode == EraVM::NOPsrr) {
+    // TODO Refactor the internal encoding of stack operand in the backend and
+    //      remove this fixup.
+    MCInst NormalizedMI = *MI;
+    unsigned StackOpIdx = Opcode == EraVM::NOPrrs ? 2 : 1;
+
+    MCOperand &MarkerOp = NormalizedMI.getOperand(StackOpIdx);
+    MCOperand &BaseOp = NormalizedMI.getOperand(StackOpIdx + 1);
+    MCOperand &AddendOp = NormalizedMI.getOperand(StackOpIdx + 2);
+
+    if (MarkerOp.isReg() && MarkerOp.getReg() == EraVM::R0 && BaseOp.isImm()) {
+      // (stackop R0, 0, -addend) -> (stackop R0, R0, addend)
+      assert(BaseOp.getImm() == 0 && "Unexpected marker immediate operand");
+      BaseOp = MCOperand::createReg(EraVM::R0);
+      AddendOp.setImm(-AddendOp.getImm());
+    }
+
+    if (!printAliasInstr(&NormalizedMI, Address, O))
+      printInstruction(&NormalizedMI, Address, O);
+    printAnnotation(O, Annot);
+    return;
+  }
+
   if (!printAliasInstr(MI, Address, O))
     printInstruction(MI, Address, O);
   printAnnotation(O, Annot);
diff --git a/llvm/test/CodeGen/EraVM/adjsp.ll b/llvm/test/CodeGen/EraVM/adjsp.ll
index 7b7e1d305393..59b19611ac5f 100644
--- a/llvm/test/CodeGen/EraVM/adjsp.ll
+++ b/llvm/test/CodeGen/EraVM/adjsp.ll
@@ -4,7 +4,7 @@ target triple = "eravm"
 
 ; CHECK-LABEL: array_ldst_to_parameter
 define void @array_ldst_to_parameter([10 x i256]* %array, i256 %val) {
-  ; CHECK: nop stack+=[10 + r0]
+  ; CHECK: incsp 10
   %starr = alloca [10 x i256]
   %idx = getelementptr inbounds [10 x i256], [10 x i256]* %starr, i256 0, i256 6
   %1 = load i256, i256* %idx
@@ -42,8 +42,8 @@ join:                                             ; preds = %entry
 define i256* @caller() {
   %alloc = alloca i256
   %alloc2 = alloca i256
-; CHECK: context.sp r1
-; CHECK: context.sp r2
+; CHECK: sp r1
+; CHECK: sp r2
 ; CHECK: sub.s 3, r2, r2
 ; CHECK: shl.s 5, r2, r2
 ; CHECK: add r2, r0, stack[1 + r1]
diff --git a/llvm/test/CodeGen/EraVM/apint-assert.ll b/llvm/test/CodeGen/EraVM/apint-assert.ll
index 627c65078be4..cc9d3661a96a 100644
--- a/llvm/test/CodeGen/EraVM/apint-assert.ll
+++ b/llvm/test/CodeGen/EraVM/apint-assert.ll
@@ -6,7 +6,7 @@ target triple = "eravm"
 ; CHECK-LABEL: test
 define i256 @test(i256 %0) {
 entry:
-; CHECK: st.1	r1, r2
+; CHECK: stm.h	r1, r2
   %1 = add i256 %0, 18446744073709551615
   %2 = inttoptr i256 %1 to ptr addrspace(1)
   store i8 0, ptr addrspace(1) %2, align 1
diff --git a/llvm/test/CodeGen/EraVM/array.ll b/llvm/test/CodeGen/EraVM/array.ll
index 5e570732a7ec..f5a924f6eed3 100644
--- a/llvm/test/CodeGen/EraVM/array.ll
+++ b/llvm/test/CodeGen/EraVM/array.ll
@@ -71,8 +71,8 @@ define void @stack_register_addressing_storing([10 x i256]* %array, i256 %idx, i
 
 ; CHECK-LABEL: alloca_reg_storing
 define void @alloca_reg_storing(i256 %idx, i256 %val) {
-  ; CHECK:  nop     stack+=[10 + r0]
-  ; CHECK-NEXT:  context.sp r3
+  ; CHECK:  incsp     10
+  ; CHECK-NEXT:  sp r3
   ; CHECK-NEXT:  add     r3, r1, r1
   ; CHECK-NEXT:  sub.s   10, r1, r1
   ; CHECK-NEXT:  add     r2, r0, stack[r1]
@@ -87,7 +87,7 @@ define void @alloca_reg_storing(i256 %idx, i256 %val) {
 
 ; CHECK-LABEL: alloca_const_storing
 define void @alloca_const_storing(i256 %idx, i256 %val) {
-  ; CHECK:  nop     stack+=[10 + r0]
+  ; CHECK:  incsp     10
   ; CHECK:  add     r2, r0, stack-[5]
   %array = alloca [10 x i256], align 32
   %idx_slot = getelementptr inbounds [10 x i256], [10 x i256]* %array, i256 0, i256 5
@@ -108,8 +108,8 @@ define i256 @stack_register_addressing_loading([10 x i256]* %array, i256 %idx) {
 
 ; CHECK-LABEL: alloca_reg_loading
 define i256 @alloca_reg_loading(i256 %idx, i256 %val) {
-  ; CHECK:  nop     stack+=[10 + r0]
-  ; CHECK-NEXT:  context.sp r2
+  ; CHECK:  incsp     10
+  ; CHECK-NEXT:  sp r2
   ; CHECK-NEXT:  add     r2, r1, r1
   ; CHECK-NEXT:  sub.s   10, r1, r1
   ; CHECK-NEXT:  add     stack[r1], r0, r1
@@ -124,7 +124,7 @@ define i256 @alloca_reg_loading(i256 %idx, i256 %val) {
 
 ; CHECK-LABEL: alloca_const_loading
 define i256 @alloca_const_loading(i256 %val) {
-  ; CHECK:  nop     stack+=[10 + r0]
+  ; CHECK:  incsp     10
   ; CHECK:  add     stack-[5], r0, r1
   %array = alloca [10 x i256], align 32
   %idx_slot = getelementptr inbounds [10 x i256], [10 x i256]* %array, i256 0, i256 5
@@ -174,11 +174,11 @@ define i256 @arg_ptr_loading2(i256* %array, i256 %idx) {
 
 ; CHECK-LABEL: stack_array_passing
 define void @stack_array_passing() {
-  ; CHECK:  nop     stack+=[10 + r0]
-  ; CHECK:  context.sp      r[[REG3:[0-9]+]]
+  ; CHECK:  incsp     10
+  ; CHECK:  sp      r[[REG3:[0-9]+]]
   ; CHECK:  sub.s   10, r[[REG3]], r[[REG4:[0-9]+]]
   ; CHECK:  shl.s    5, r[[REG4]], r1
-  ; CHECK:  near_call       r0, @array_arg, @DEFAULT_UNWIND
+  ; CHECK:  call       r0, @array_arg, @DEFAULT_UNWIND
   %array = alloca [10 x i256], align 32
   call void @array_arg([10 x i256]* %array)
   ret void
@@ -186,8 +186,8 @@ define void @stack_array_passing() {
 
 ; CHECK-LABEL: stack_pointer_passing
 define void @stack_pointer_passing() {
-  ; CHECK:  nop     stack+=[10 + r0]
-  ; CHECK:  context.sp      r[[REG5:[0-9]+]]
+  ; CHECK:  incsp     10
+  ; CHECK:  sp      r[[REG5:[0-9]+]]
   ; CHECK:  sub.s   10, r[[REG5]], r[[REG5]]
   ; CHECK:  shl.s    5, r[[REG5]], r[[REG5]]
   ; CHECK:  add     160, r[[REG5]], r1
@@ -199,8 +199,8 @@ define void @stack_pointer_passing() {
 
 ; CHECK-LABEL: stack_pointer_passing2
 define void @stack_pointer_passing2() {
-  ; CHECK: nop     stack+=[10 + r0]
-  ; CHECK: context.sp      r[[REG6:[0-9]+]]
+  ; CHECK: incsp     10
+  ; CHECK: sp      r[[REG6:[0-9]+]]
   ; CHECK: sub.s   10, r[[REG6]], r[[REG6]]
   ; CHECK: shl.s    5, r[[REG6]], r1
   %array = alloca [10 x i256], align 32
diff --git a/llvm/test/CodeGen/EraVM/as3_nullptr_bug.ll b/llvm/test/CodeGen/EraVM/as3_nullptr_bug.ll
index 3f356d52f9a3..a6e96536a572 100644
--- a/llvm/test/CodeGen/EraVM/as3_nullptr_bug.ll
+++ b/llvm/test/CodeGen/EraVM/as3_nullptr_bug.ll
@@ -6,7 +6,7 @@ target triple = "eravm-unknown-unknown"
 define i256 @__entry() local_unnamed_addr #0 {
 entry:
   ; address space 3 pointers are not numeric, but as an exception it's ok to materialize nullptr from 0.
-  ; CHECK: ld r0, r1
+  ; CHECK: ldp r0, r1
   %calldata_value = load i256, ptr addrspace(3) null, align 32
   %comparison_result = icmp ugt i256 %calldata_value, 340282366920938463463374607431768211455
   %return_value = select i1 %comparison_result, i256 16, i256 0
diff --git a/llvm/test/CodeGen/EraVM/bytes2cells.ll b/llvm/test/CodeGen/EraVM/bytes2cells.ll
index 823cae9e40ab..fc401a052999 100644
--- a/llvm/test/CodeGen/EraVM/bytes2cells.ll
+++ b/llvm/test/CodeGen/EraVM/bytes2cells.ll
@@ -39,10 +39,10 @@ declare void @foo(ptr %val);
 ; passing stack pointer in cells as argument, without unnecessary scaling
 ; CHECK-LABEL: call_foo
 define void @call_foo() nounwind {
-; CHECK: context.sp [[REG:r[0-9]+]]
+; CHECK: sp [[REG:r[0-9]+]]
 ; CHECK: sub.s 1, [[REG]], [[REG2:r[0-9]+]]
 ; CHECK-NOT: shr.s
-; CHECK: near_call
+; CHECK: call
   %p = alloca i256
   call void @foo(ptr %p)
   ret void
diff --git a/llvm/test/CodeGen/EraVM/calling-convensions.ll b/llvm/test/CodeGen/EraVM/calling-convensions.ll
index 08f5f11d9f0b..8ad083b0c4f0 100644
--- a/llvm/test/CodeGen/EraVM/calling-convensions.ll
+++ b/llvm/test/CodeGen/EraVM/calling-convensions.ll
@@ -7,7 +7,7 @@ target triple = "eravm"
 
 ; CHECK-LABEL: call1.i256
 define i256 @call1.i256(i256 %a1) nounwind {
-; CHECK: near_call r0, @onearg, @DEFAULT_UNWIND
+; CHECK: call r0, @onearg, @DEFAULT_UNWIND
   %1 = call i256 @onearg(i256 %a1)
   ret i256 %1
 }
@@ -16,14 +16,14 @@ define i256 @call1.i256(i256 %a1) nounwind {
 define i256 @call1.i256abi(i256 %a1, i256 %abi_data) nounwind {
   %ptr = bitcast i256(i256)* @onearg to i256*
 ; CHECK: add r2, r0, r15
-; CHECK: near_call r15, @onearg, @DEFAULT_UNWIND
+; CHECK: call r15, @onearg, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 %abi_data, i256 %a1)
   ret i256 %1
 }
 
 ; CHECK-LABEL: call1.i256p
 define i256* @call1.i256p(i256 %a1) nounwind {
-; CHECK: near_call r0, @onearg.i256p, @DEFAULT_UNWIND
+; CHECK: call r0, @onearg.i256p, @DEFAULT_UNWIND
   %1 = call i256* @onearg.i256p(i256 %a1)
   ret i256* %1
 }
@@ -31,7 +31,7 @@ define i256* @call1.i256p(i256 %a1) nounwind {
 ; CHECK-LABEL: call1.i256pabi
 define i256* @call1.i256pabi(i256 %a1, i256 %abi_data) nounwind {
 ; CHECK: add r2, r0, r15
-; CHECK: near_call r15, @onearg.i256p, @DEFAULT_UNWIND
+; CHECK: call r15, @onearg.i256p, @DEFAULT_UNWIND
   %1 = call i256 (i256*, i256, ...) @llvm.eravm.nearcall(i256* bitcast (i256*(i256)* @onearg.i256p to i256*), i256 %abi_data, i256 %a1)
   %2 = inttoptr i256 %1 to i256*
   ret i256* %2
@@ -39,7 +39,7 @@ define i256* @call1.i256pabi(i256 %a1, i256 %abi_data) nounwind {
 
 ; CHECK-LABEL: call1.void
 define void @call1.void(i256 %a1) nounwind {
-; CHECK: near_call r0, @onearg.void, @DEFAULT_UNWIND
+; CHECK: call r0, @onearg.void, @DEFAULT_UNWIND
   call void @onearg.void(i256 %a1)
   ret void
 }
@@ -48,14 +48,14 @@ define void @call1.void(i256 %a1) nounwind {
 define void @call1.i256voidabi(i256 %a1, i256 %abi_data) nounwind {
   %ptr = bitcast void(i256)* @onearg.void to i256*
 ; CHECK: add r2, r0, r15
-; CHECK: near_call r15, @onearg.void, @DEFAULT_UNWIND
+; CHECK: call r15, @onearg.void, @DEFAULT_UNWIND
   call i256 (i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 %abi_data, i256 %a1)
   ret void
 }
 
 ; CHECK-LABEL: invoke1.i256
 define i256 @invoke1.i256(i256 %a1) personality i256()* @__personality {
-; CHECK: near_call r0, @onearg, @.BB6_2
+; CHECK: call r0, @onearg, @.BB6_2
   %res = invoke i256 @onearg(i256 %a1) to label %success unwind label %failure
 success:
 ; CHECK: ret
@@ -71,7 +71,7 @@ failure:
 define i256 @invoke1.i256abi(i256 %a1, i256 %abi_data) personality i256()* @__personality {
   %ptr = bitcast i256(i256)* @onearg to i256*
 ; CHECK: add r2, r0, r15
-; CHECK: near_call r15, @onearg, @.BB7_2
+; CHECK: call r15, @onearg, @.BB7_2
   %res = invoke i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 %abi_data, i256 %a1) to label %success unwind label %failure
 success:
 ; CHECK: ret
@@ -85,7 +85,7 @@ failure:
 
 ; CHECK-LABEL: caller2
 define i256 @caller2(i256 %a1, i256 %a2) nounwind {
-; CHECK: near_call r0, @twoarg, @DEFAULT_UNWIND
+; CHECK: call r0, @twoarg, @DEFAULT_UNWIND
   %1 = call i256 @twoarg(i256 %a1, i256 %a2)
   ret i256 %1
 }
@@ -94,7 +94,7 @@ define i256 @caller2(i256 %a1, i256 %a2) nounwind {
 define i256 @caller2.abi(i256 %a1, i256 %a2, i256 %abi) nounwind {
   %ptr = bitcast i256(i256, i256)* @twoarg to i256*
 ; CHECK: add r3, r0, r15
-; CHECK: near_call r15, @twoarg, @DEFAULT_UNWIND
+; CHECK: call r15, @twoarg, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 %abi, i256 %a1, i256 %a2)
   ret i256 %1
 }
@@ -104,7 +104,7 @@ define i256 @caller2.swp(i256 %a1, i256 %a2) nounwind {
 ; CHECK: add	r1, r0, r3
 ; CHECK: add	r2, r0, r1
 ; CHECK: add	r3, r0, r2
-; CHECK: near_call r0, @twoarg, @DEFAULT_UNWIND
+; CHECK: call r0, @twoarg, @DEFAULT_UNWIND
   %1 = call i256 @twoarg(i256 %a2, i256 %a1)
   ret i256 %1
 }
@@ -127,7 +127,7 @@ define i256 @caller3.abi(i256 %a1, i256 %a2, i256 %a3, i256 %abi) nounwind {
 
 ; CHECK-LABEL: caller_argtypes
 define i256 @caller_argtypes(i1 %a1, i8 %a2, i16 %a3, i32 %a4, i64 %a5, i128 %a6) nounwind {
-  ; CHECK: nop stack+=[6 + r0]
+  ; CHECK: incsp 6
   ; CHECK: add r6, r0, stack-[6]
   ; CHECK: add r5, r0, stack-[5]
   ; CHECK: add r4, r0, stack-[4]
@@ -142,47 +142,47 @@ define i256 @caller_argtypes(i1 %a1, i8 %a2, i16 %a3, i32 %a4, i64 %a5, i128 %a6
   %ptr64 = bitcast i256(i64)* @i64.arg to i256*
   %ptr128 = bitcast i256(i128)* @i128.arg to i256*
 
-	; CHECK: near_call r0, @i1.arg, @DEFAULT_UNWIND
+	; CHECK: call r0, @i1.arg, @DEFAULT_UNWIND
   %1 = call i256 @i1.arg(i1 %a1)
 	; CHECK: add stack-[2], r0, r1
-	; CHECK: near_call r0, @i8.arg, @DEFAULT_UNWIND
+	; CHECK: call r0, @i8.arg, @DEFAULT_UNWIND
   %2 = call i256 @i8.arg(i8 %a2)
 	; CHECK: add stack-[3], r0, r1
-	; CHECK: near_call r0, @i16.arg, @DEFAULT_UNWIND
+	; CHECK: call r0, @i16.arg, @DEFAULT_UNWIND
   %3 = call i256 @i16.arg(i16 %a3)
 	; CHECK: add stack-[4], r0, r1
-	; CHECK: near_call r0, @i32.arg, @DEFAULT_UNWIND
+	; CHECK: call r0, @i32.arg, @DEFAULT_UNWIND
   %4 = call i256 @i32.arg(i32 %a4)
 	; CHECK: add stack-[5], r0, r1
-	; CHECK: near_call r0, @i64.arg, @DEFAULT_UNWIND
+	; CHECK: call r0, @i64.arg, @DEFAULT_UNWIND
   %5 = call i256 @i64.arg(i64 %a5)
 	; CHECK: add stack-[6], r0, r1
-	; CHECK: near_call r0, @i128.arg, @DEFAULT_UNWIND
+	; CHECK: call r0, @i128.arg, @DEFAULT_UNWIND
   %6 = call i256 @i128.arg(i128 %a6)
 
 	; CHECK: add 42, r0, r15
 	; CHECK: add stack-[1], r0, r1
-	; CHECK: near_call r15, @i1.arg, @DEFAULT_UNWIND
+	; CHECK: call r15, @i1.arg, @DEFAULT_UNWIND
   %7 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr1, i256 42, i1 %a1)
 	; CHECK: add stack-[2], r0, r1
 	; CHECK: add 42, r0, r15
-	; CHECK: near_call r15, @i8.arg, @DEFAULT_UNWIND
+	; CHECK: call r15, @i8.arg, @DEFAULT_UNWIND
   %8 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr8, i256 42, i8 %a2)
 	; CHECK: add stack-[3], r0, r1
 	; CHECK: add 42, r0, r15
-	; CHECK: near_call r15, @i16.arg, @DEFAULT_UNWIND
+	; CHECK: call r15, @i16.arg, @DEFAULT_UNWIND
   %9 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr16, i256 42, i16 %a3)
 	; CHECK: add stack-[4], r0, r1
 	; CHECK: add 42, r0, r15
-	; CHECK: near_call r15, @i32.arg, @DEFAULT_UNWIND
+	; CHECK: call r15, @i32.arg, @DEFAULT_UNWIND
   %10 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr32, i256 42, i32 %a4)
 	; CHECK: add stack-[5], r0, r1
 	; CHECK: add 42, r0, r15
-	; CHECK: near_call r15, @i64.arg, @DEFAULT_UNWIND
+	; CHECK: call r15, @i64.arg, @DEFAULT_UNWIND
   %11 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr64, i256 42, i64 %a5)
 	; CHECK: add stack-[6], r0, r1
 	; CHECK: add 42, r0, r15
-	; CHECK: near_call r15, @i128.arg, @DEFAULT_UNWIND
+	; CHECK: call r15, @i128.arg, @DEFAULT_UNWIND
   %12 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr128, i256 42, i128 %a6)
 
   ret i256 %12
@@ -190,7 +190,7 @@ define i256 @caller_argtypes(i1 %a1, i8 %a2, i16 %a3, i32 %a4, i64 %a5, i128 %a6
 
 ; CHECK: @caller_i1.ret
 define i256 @caller_i1.ret(i256 %a1) nounwind {
-; CHECK: near_call r0, @i1.ret, @DEFAULT_UNWIND
+; CHECK: call r0, @i1.ret, @DEFAULT_UNWIND
   %1 = call i1 @i1.ret(i256 %a1)
 ; CHECK-NOT: and 1, r1, r1
   %2 = zext i1 %1 to i256
@@ -200,14 +200,14 @@ define i256 @caller_i1.ret(i256 %a1) nounwind {
 ; CHECK: @caller_i1.retabi
 define i256 @caller_i1.retabi(i256 %a1) nounwind {
   %ptr = bitcast i1(i256)* @i1.ret to i256*
-; CHECK: near_call r15, @i1.ret, @DEFAULT_UNWIND
+; CHECK: call r15, @i1.ret, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 %a1)
   ret i256 %1
 }
 
 ; CHECK: @caller_i8.ret
 define i256 @caller_i8.ret(i256 %a1) nounwind {
-; CHECK: near_call r0, @i8.ret, @DEFAULT_UNWIND
+; CHECK: call r0, @i8.ret, @DEFAULT_UNWIND
   %1 = call i8 @i8.ret(i256 %a1)
 ; CHECK-NOT: and 255, r1, r1
   %2 = zext i8 %1 to i256
@@ -217,14 +217,14 @@ define i256 @caller_i8.ret(i256 %a1) nounwind {
 ; CHECK: @caller_i8.retabi
 define i256 @caller_i8.retabi(i256 %a1) nounwind {
   %ptr = bitcast i8(i256)* @i8.ret to i256*
-; CHECK: near_call r15, @i8.ret, @DEFAULT_UNWIND
+; CHECK: call r15, @i8.ret, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 %a1)
   ret i256 %1
 }
 
 ; CHECK: @caller_i16.ret
 define i256 @caller_i16.ret(i256 %a1) nounwind {
-; CHECK: near_call r0, @i16.ret, @DEFAULT_UNWIND
+; CHECK: call r0, @i16.ret, @DEFAULT_UNWIND
   %1 = call i16 @i16.ret(i256 %a1)
 ; CHECK-NOT: and 65535, r1, r1
   %2 = zext i16 %1 to i256
@@ -234,14 +234,14 @@ define i256 @caller_i16.ret(i256 %a1) nounwind {
 ; CHECK: @caller_i16.retabi
 define i256 @caller_i16.retabi(i256 %a1) nounwind {
   %ptr = bitcast i16(i256)* @i16.ret to i256*
-; CHECK: near_call r15, @i16.ret, @DEFAULT_UNWIND
+; CHECK: call r15, @i16.ret, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 %a1)
   ret i256 %1
 }
 
 ; CHECK: @caller_i32.ret
 define i256 @caller_i32.ret(i256 %a1) nounwind {
-; CHECK: near_call r0, @i32.ret, @DEFAULT_UNWIND
+; CHECK: call r0, @i32.ret, @DEFAULT_UNWIND
   %1 = call i32 @i32.ret(i256 %a1)
   %2 = zext i32 %1 to i256
   ret i256 %2
@@ -250,14 +250,14 @@ define i256 @caller_i32.ret(i256 %a1) nounwind {
 ; CHECK: @caller_i32.retabi
 define i256 @caller_i32.retabi(i256 %a1) nounwind {
   %ptr = bitcast i32(i256)* @i32.ret to i256*
-; CHECK: near_call r15, @i32.ret, @DEFAULT_UNWIND
+; CHECK: call r15, @i32.ret, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 %a1)
   ret i256 %1
 }
 
 ; CHECK: @caller_i64.ret
 define i256 @caller_i64.ret(i256 %a1) nounwind {
-; CHECK: near_call r0, @i64.ret, @DEFAULT_UNWIND
+; CHECK: call r0, @i64.ret, @DEFAULT_UNWIND
   %1 = call i64 @i64.ret(i256 %a1)
   %2 = zext i64 %1 to i256
   ret i256 %2
@@ -266,14 +266,14 @@ define i256 @caller_i64.ret(i256 %a1) nounwind {
 ; CHECK: @caller_i64.retabi
 define i256 @caller_i64.retabi(i256 %a1) nounwind {
   %ptr = bitcast i64(i256)* @i64.ret to i256*
-; CHECK: near_call r15, @i64.ret, @DEFAULT_UNWIND
+; CHECK: call r15, @i64.ret, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 %a1)
   ret i256 %1
 }
 
 ; CHECK: @caller_i128.ret
 define i256 @caller_i128.ret(i256 %a1) nounwind {
-; CHECK: near_call r0, @i128.ret
+; CHECK: call r0, @i128.ret
   %1 = call i128 @i128.ret(i256 %a1)
   %2 = zext i128 %1 to i256
   ret i256 %2
@@ -282,14 +282,14 @@ define i256 @caller_i128.ret(i256 %a1) nounwind {
 ; CHECK: @caller_i128.retabi
 define i256 @caller_i128.retabi(i256 %a1) nounwind {
   %ptr = bitcast i128(i256)* @i128.ret to i256*
-; CHECK: near_call r15, @i128.ret, @DEFAULT_UNWIND
+; CHECK: call r15, @i128.ret, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 %a1)
   ret i256 %1
 }
 
 ; CHECK-LABEL: call.onestack
 define i256 @call.onestack() nounwind {
-; CHECK: context.sp r1
+; CHECK: sp r1
 ; CHECK: add 0, r0, stack[r1]
 ; CHECK: add r0, r0, r1
 ; CHECK: add r0, r0, r2
@@ -305,7 +305,7 @@ define i256 @call.onestack() nounwind {
 ; CHECK: add r0, r0, r12
 ; CHECK: add r0, r0, r13
 ; CHECK: add r0, r0, r14
-; CHECK: near_call r0, @onestack
+; CHECK: call r0, @onestack
   %1 = call i256 @onestack(i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0)
   ret i256 %1
 }
@@ -314,7 +314,7 @@ define i256 @call.onestack() nounwind {
 ; CHECK-LABEL: call.onestackabi
 define i256 @call.onestackabi() nounwind {
   %ptr = bitcast i256(i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256)* @onestack to i256*
-; CHECK: context.sp r1
+; CHECK: sp r1
 ; CHECK: add 0, r0, stack[r1]
 ; CHECK: add 42, r0, r15
 ; CHECK: add r0, r0, r2
@@ -330,7 +330,7 @@ define i256 @call.onestackabi() nounwind {
 ; CHECK: add r0, r0, r12
 ; CHECK: add r0, r0, r13
 ; CHECK: add r0, r0, r14
-; CHECK: near_call r15, @onestack, @DEFAULT_UNWIND
+; CHECK: call r15, @onestack, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0)
   ret i256 %1
 }
@@ -338,7 +338,7 @@ define i256 @call.onestackabi() nounwind {
 ; CHECK-LABEL: call.twostackabi
 define i256 @call.twostackabi() nounwind {
   %ptr = bitcast i256(i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256)* @twostack to i256*
-; CHECK: context.sp      r1
+; CHECK: sp r1
 ; CHECK: add 2, r0, stack[1 + r1]
 ; CHECK: add 1, r0, stack[r1]
 ; CHECK: add 42, r0, r15
@@ -355,7 +355,7 @@ define i256 @call.twostackabi() nounwind {
 ; CHECK: add r0, r0, r12
 ; CHECK: add r0, r0, r13
 ; CHECK: add r0, r0, r14
-; CHECK: near_call r15, @twostack, @DEFAULT_UNWIND
+; CHECK: call r15, @twostack, @DEFAULT_UNWIND
   %1 = call i256(i256*, i256, ...) @llvm.eravm.nearcall(i256* %ptr, i256 42, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 0, i256 1, i256 2)
   ret i256 %1
 }
@@ -386,11 +386,11 @@ define i256 @sum17(i256 %a1, i256 %a2, i256 %a3, i256 %a4, i256 %a5, i256 %a6, i
 
 ; CHECK-LABEL: checkcc
 define void @checkcc(i256 %arg) nounwind {
-; CHECK: near_call r0, @ccc, @DEFAULT_UNWIND
+; CHECK: call r0, @ccc, @DEFAULT_UNWIND
   call void @ccc(i256 %arg)
-; CHECK: near_call r0, @fastcc, @DEFAULT_UNWIND
+; CHECK: call r0, @fastcc, @DEFAULT_UNWIND
   call void @fastcc(i256 %arg)
-; CHECK: near_call r0, @coldcc, @DEFAULT_UNWIND
+; CHECK: call r0, @coldcc, @DEFAULT_UNWIND
   call void @coldcc(i256 %arg)
   ret void
 }
@@ -428,14 +428,14 @@ define i256 @callee_small_argtypes(i1 %a1, i2 %a2, i8 %a8, i16 %a16, i32 %a32, i
 ; CHECK-LABEL: fat.ptr.arg
 define void @fat.ptr.arg(i256 addrspace(3)* %ptr) {
   %slot = alloca i256 addrspace(3)*
-  ; CHECK: ptr.add r1, r0, stack-[1]
+  ; CHECK: addp r1, r0, stack-[1]
   store i256 addrspace(3)* %ptr, i256 addrspace(3)** %slot
   ret void
 }
 
 ; CHECK-LABEL: fat.ptr.call
 define void @fat.ptr.call(i256 %a1, i256 addrspace(3)* %ptr) {
-  ; CHECK: ptr.add r2, r0, r1
+  ; CHECK: addp r2, r0, r1
   call void @fat.ptr.arg(i256 addrspace(3)* %ptr)
   ret void
 }
@@ -453,7 +453,7 @@ define {i256, i256} @tworet(i256 %x1, i256 %x2, i256 %x3, i256 %x4) {
 
 ; CHECK-LABEL: tworet.call
 define i256 @tworet.call() {
-  ; CHECK: near_call r0, @tworet, @DEFAULT_UNWIND
+  ; CHECK: call r0, @tworet, @DEFAULT_UNWIND
   %res = call {i256, i256} @tworet(i256 0, i256 1, i256 2, i256 3)
   %x1 = extractvalue {i256, i256} %res, 0
   %x2 = extractvalue {i256, i256} %res, 1
@@ -465,7 +465,7 @@ define i256 @tworet.call() {
 ; CHECK-LABEL: call1.i256pabi.opaque
 define i256* @call1.i256pabi.opaque(i256 %a1, i256 %abi_data) nounwind {
 ; CHECK: add r2, r0, r15
-; CHECK: near_call r15, @onearg.i256p, @DEFAULT_UNWIND
+; CHECK: call r15, @onearg.i256p, @DEFAULT_UNWIND
   %1 = call i256 (ptr, i256, ...) @llvm.eravm.nearcall(ptr @onearg.i256p, i256 %abi_data, i256 %a1)
   %2 = inttoptr i256 %1 to i256*
   ret i256* %2
@@ -474,7 +474,7 @@ define i256* @call1.i256pabi.opaque(i256 %a1, i256 %abi_data) nounwind {
 ; CHECK-LABEL: toomanyret
 define {i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256, i256} @toomanyret(i256 %arg1) {
   ; CHECK: add r2, r0, r1
-  ; CHECK: near_call       r0, @onearg, @DEFAULT_UNWIND
+  ; CHECK: call       r0, @onearg, @DEFAULT_UNWIND
   %x = call i256 @onearg(i256 %arg1)
   unreachable
 }
diff --git a/llvm/test/CodeGen/EraVM/compound.ll b/llvm/test/CodeGen/EraVM/compound.ll
index 206e23cc2f42..6e3450f27596 100644
--- a/llvm/test/CodeGen/EraVM/compound.ll
+++ b/llvm/test/CodeGen/EraVM/compound.ll
@@ -32,7 +32,7 @@ define i256 @frame_compound_idx(i256 %val) {
 define i256 @frame_compound(i256 %index, i256 %val) {
   %1 = alloca [5 x i256]
   %2 = getelementptr inbounds [5 x i256], [5 x i256]* %1, i256 0, i256 %index
-; CHECK: context.sp r3
+; CHECK: sp r3
 ; CHECK: add r3, r1, r1
 ; CHECK: sub.s 6, r1, r1
 ; CHECK: add r1, r0, stack-[1]
diff --git a/llvm/test/CodeGen/EraVM/context-remat.ll b/llvm/test/CodeGen/EraVM/context-remat.ll
index 782765b183eb..9cd552018ff4 100644
--- a/llvm/test/CodeGen/EraVM/context-remat.ll
+++ b/llvm/test/CodeGen/EraVM/context-remat.ll
@@ -9,9 +9,9 @@ declare void @use(i256)
 define i256 @test_this() {
 ; CHECK-LABEL: test_this:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    context.this r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
-; CHECK-NEXT:    context.this r1
+; CHECK-NEXT:    this r1
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    this r1
 ; CHECK-NEXT:    ret
 entry:
   %ret = call i256 @llvm.eravm.this()
@@ -22,9 +22,9 @@ entry:
 define i256 @test_caller() {
 ; CHECK-LABEL: test_caller:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    context.caller r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
-; CHECK-NEXT:    context.caller r1
+; CHECK-NEXT:    par r1
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    par r1
 ; CHECK-NEXT:    ret
 entry:
   %ret = call i256 @llvm.eravm.caller()
@@ -35,9 +35,9 @@ entry:
 define i256 @test_codesource() {
 ; CHECK-LABEL: test_codesource:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    context.code_source r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
-; CHECK-NEXT:    context.code_source r1
+; CHECK-NEXT:    code r1
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    code r1
 ; CHECK-NEXT:    ret
 entry:
   %ret = call i256 @llvm.eravm.codesource()
@@ -48,9 +48,9 @@ entry:
 define i256 @test_getu128() {
 ; CHECK-LABEL: test_getu128:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    context.get_context_u128 r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
-; CHECK-NEXT:    context.get_context_u128 r1
+; CHECK-NEXT:    ldvl r1
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    ldvl r1
 ; CHECK-NEXT:    ret
 entry:
   %ret = call i256 @llvm.eravm.getu128()
diff --git a/llvm/test/CodeGen/EraVM/cse-sub-cmp.ll b/llvm/test/CodeGen/EraVM/cse-sub-cmp.ll
index 269c8efcebaa..6d672c32fd61 100644
--- a/llvm/test/CodeGen/EraVM/cse-sub-cmp.ll
+++ b/llvm/test/CodeGen/EraVM/cse-sub-cmp.ll
@@ -85,11 +85,11 @@ bb2:
 define i256 @test_with_call(i256 %a, i256 %b) {
 ; CHECK-LABEL: test_with_call:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r1, r2, stack-[1]
 ; CHECK-NEXT:    add 10, r0, r1
 ; CHECK-NEXT:    add.lt 15, r0, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
   %cmp = icmp ult i256 %a, %b
@@ -103,10 +103,10 @@ define i256 @test_with_call(i256 %a, i256 %b) {
 define i256 @test_with_call_not(i256 %a) {
 ; CHECK-LABEL: test_with_call_not:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r1, r0, stack-[1] ; 32-byte Folded Spill
 ; CHECK-NEXT:    sub.s 10, r1, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    sub.s! 10, r1, r0
 ; CHECK-NEXT:    add 10, r0, r1
@@ -126,7 +126,7 @@ define i256 @test_elim_identical_cmps(i256 %a, ptr addrspace(1) %ptr) {
 ; CHECK-NEXT:    add 10, r0, r3
 ; CHECK-NEXT:    add.lt 15, r0, r3
 ; CHECK-NEXT:    sub r3, r1, r1
-; CHECK-NEXT:    st.1 r2, r1
+; CHECK-NEXT:    stm.h r2, r1
 ; CHECK-NEXT:    add 15, r0, r1
 ; CHECK-NEXT:    add.lt 10, r0, r1
 ; CHECK-NEXT:    ret
@@ -142,14 +142,14 @@ define i256 @test_elim_identical_cmps(i256 %a, ptr addrspace(1) %ptr) {
 define i256 @test_dont_elim_identical_cmps(i256 %a, ptr addrspace(1) %ptr) {
 ; CHECK-LABEL: test_dont_elim_identical_cmps:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r1, r0, stack-[1] ; 32-byte Folded Spill
 ; CHECK-NEXT:    sub.s! 10, r1, r0
 ; CHECK-NEXT:    add 10, r0, r3
 ; CHECK-NEXT:    add.lt 15, r0, r3
 ; CHECK-NEXT:    sub r3, r1, r1
-; CHECK-NEXT:    st.1 r2, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    stm.h r2, r1
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    sub.s! 10, r1, r0
 ; CHECK-NEXT:    add 15, r0, r1
diff --git a/llvm/test/CodeGen/EraVM/cxa_throw.ll b/llvm/test/CodeGen/EraVM/cxa_throw.ll
index 133233fd3315..40253e025cc2 100644
--- a/llvm/test/CodeGen/EraVM/cxa_throw.ll
+++ b/llvm/test/CodeGen/EraVM/cxa_throw.ll
@@ -16,7 +16,7 @@ catch:                                            ; preds = %entry
   %landing = landingpad { i8*, i32 }
           catch i8* null
   ; CHECK: add r0, r0, r1
-  ; CHECK: revert
+  ; CHECK: rev
   call void @__cxa_throw(i8* null, i8* null, i8* null)
   unreachable
 
@@ -37,7 +37,7 @@ entry:
 
 throw:                                            ; preds = %entry
   ; CHECK: add r0, r0, r1
-  ; CHECK: revert
+  ; CHECK: rev
   call void @__cxa_throw(i8* null, i8* null, i8* null)
   unreachable
 
diff --git a/llvm/test/CodeGen/EraVM/def-spill.ll b/llvm/test/CodeGen/EraVM/def-spill.ll
index f1fe152e6d73..e5610443e9ee 100644
--- a/llvm/test/CodeGen/EraVM/def-spill.ll
+++ b/llvm/test/CodeGen/EraVM/def-spill.ll
@@ -334,7 +334,7 @@ define i256 @spill_shrs(i256 %a) nounwind {
 
 ; CHECK-LABEL: spill_ptraddr
 define i8 addrspace(3)* @spill_ptraddr(i8 addrspace(3)* %a, i256 %b) nounwind {
-  ; CHECK: ptr.add r1, r2, stack-[1]
+  ; CHECK: addp r1, r2, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %a, i256 %b)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %x, i256 %c)
@@ -343,7 +343,7 @@ define i8 addrspace(3)* @spill_ptraddr(i8 addrspace(3)* %a, i256 %b) nounwind {
 
 ; CHECK-LABEL: spill_ptraddi
 define i8 addrspace(3)* @spill_ptraddi(i8 addrspace(3)* %a) nounwind {
-  ; CHECK: ptr.add.s 42, r1, stack-[1]
+  ; CHECK: addp.s 42, r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %a, i256 42)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %x, i256 %c)
@@ -352,7 +352,7 @@ define i8 addrspace(3)* @spill_ptraddi(i8 addrspace(3)* %a) nounwind {
 
 ; CHECK-LABEL: spill_ptraddc
 define i8 addrspace(3)* @spill_ptraddc(i8 addrspace(3)* %a) nounwind {
-  ; CHECK: ptr.add.s code[@CPI{{[0-9]+}}_0], r1, stack-[1]
+  ; CHECK: addp.s code[@CPI{{[0-9]+}}_0], r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %a, i256 4200000000000000)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %x, i256 %c)
@@ -363,7 +363,7 @@ define i8 addrspace(3)* @spill_ptraddc(i8 addrspace(3)* %a) nounwind {
 define i8 addrspace(3)* @spill_ptradds(i8 addrspace(3)* %a) nounwind {
   %slot = alloca i256
   %b = load i256, i256* %slot
-  ; CHECK: ptr.add.s stack-[2], r1, stack-[1]
+  ; CHECK: addp.s stack-[2], r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %a, i256 %b)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %x, i256 %c)
@@ -372,7 +372,7 @@ define i8 addrspace(3)* @spill_ptradds(i8 addrspace(3)* %a) nounwind {
 
 ; CHECK-LABEL: spill_ptrpackr
 define i8 addrspace(3)* @spill_ptrpackr(i8 addrspace(3)* %a, i256 %b) nounwind {
-  ; CHECK: ptr.pack r1, r2, stack-[1]
+  ; CHECK: pack r1, r2, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %a, i256 %b)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %x, i256 %c)
@@ -381,7 +381,7 @@ define i8 addrspace(3)* @spill_ptrpackr(i8 addrspace(3)* %a, i256 %b) nounwind {
 
 ; CHECK-LABEL: spill_ptrpacki
 define i8 addrspace(3)* @spill_ptrpacki(i8 addrspace(3)* %a) nounwind {
-  ; CHECK: ptr.pack.s 42, r1, stack-[1]
+  ; CHECK: pack.s 42, r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %a, i256 42)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %x, i256 %c)
@@ -390,7 +390,7 @@ define i8 addrspace(3)* @spill_ptrpacki(i8 addrspace(3)* %a) nounwind {
 
 ; CHECK-LABEL: spill_ptrpackc
 define i8 addrspace(3)* @spill_ptrpackc(i8 addrspace(3)* %a) nounwind {
-  ; CHECK: ptr.pack.s code[@CPI{{[0-9]+}}_0], r1, stack-[1]
+  ; CHECK: pack.s code[@CPI{{[0-9]+}}_0], r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %a, i256 4200000000000000)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %x, i256 %c)
@@ -401,7 +401,7 @@ define i8 addrspace(3)* @spill_ptrpackc(i8 addrspace(3)* %a) nounwind {
 define i8 addrspace(3)* @spill_ptrpacks(i8 addrspace(3)* %a) nounwind {
   %slot = alloca i256
   %b = load i256, i256* %slot
-  ; CHECK: ptr.pack.s stack-[2], r1, stack-[1]
+  ; CHECK: pack.s stack-[2], r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %a, i256 %b)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %x, i256 %c)
@@ -410,7 +410,7 @@ define i8 addrspace(3)* @spill_ptrpacks(i8 addrspace(3)* %a) nounwind {
 
 ; CHECK-LABEL: spill_ptrshrinkr
 define i8 addrspace(3)* @spill_ptrshrinkr(i8 addrspace(3)* %a, i256 %b) nounwind {
-  ; CHECK: ptr.shrink r1, r2, stack-[1]
+  ; CHECK: shrnk r1, r2, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %a, i256 %b)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %x, i256 %c)
@@ -419,7 +419,7 @@ define i8 addrspace(3)* @spill_ptrshrinkr(i8 addrspace(3)* %a, i256 %b) nounwind
 
 ; CHECK-LABEL: spill_ptrshrinki
 define i8 addrspace(3)* @spill_ptrshrinki(i8 addrspace(3)* %a) nounwind {
-  ; CHECK: ptr.shrink.s 42, r1, stack-[1]
+  ; CHECK: shrnk.s 42, r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %a, i256 42)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %x, i256 %c)
@@ -428,7 +428,7 @@ define i8 addrspace(3)* @spill_ptrshrinki(i8 addrspace(3)* %a) nounwind {
 
 ; CHECK-LABEL: spill_ptrshrinkc
 define i8 addrspace(3)* @spill_ptrshrinkc(i8 addrspace(3)* %a) nounwind {
-  ; CHECK: ptr.shrink.s code[@CPI{{[0-9]+}}_0], r1, stack-[1]
+  ; CHECK: shrnk.s code[@CPI{{[0-9]+}}_0], r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %a, i256 4200000000000000)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %x, i256 %c)
@@ -439,7 +439,7 @@ define i8 addrspace(3)* @spill_ptrshrinkc(i8 addrspace(3)* %a) nounwind {
 define i8 addrspace(3)* @spill_ptrshrinks(i8 addrspace(3)* %a) nounwind {
   %slot = alloca i256
   %b = load i256, i256* %slot
-  ; CHECK: ptr.shrink.s stack-[2], r1, stack-[1]
+  ; CHECK: shrnk.s stack-[2], r1, stack-[1]
   %x = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %a, i256 %b)
   %c = call i256 @foo()
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %x, i256 %c)
diff --git a/llvm/test/CodeGen/EraVM/dollar-id-unparentesized.ll b/llvm/test/CodeGen/EraVM/dollar-id-unparentesized.ll
index c515f2e7ffc2..757e773d91a3 100644
--- a/llvm/test/CodeGen/EraVM/dollar-id-unparentesized.ll
+++ b/llvm/test/CodeGen/EraVM/dollar-id-unparentesized.ll
@@ -12,17 +12,17 @@ declare void @"_."()
 
 ; CHECK-LABEL: test
 define void @test() {
-; CHECK: near_call r0, @$_, @DEFAULT_UNWIND
+; CHECK: call r0, @$_, @DEFAULT_UNWIND
   call void @"$_"()
-; CHECK: near_call r0, @_$_, @DEFAULT_UNWIND
+; CHECK: call r0, @_$_, @DEFAULT_UNWIND
   call void @"_$_"()
-; CHECK: near_call r0, @_$, @DEFAULT_UNWIND
+; CHECK: call r0, @_$, @DEFAULT_UNWIND
   call void @"_$"()
-; CHECK: near_call r0, @._, @DEFAULT_UNWIND
+; CHECK: call r0, @._, @DEFAULT_UNWIND
   call void @"._"()
-; CHECK: near_call r0, @_._, @DEFAULT_UNWIND
+; CHECK: call r0, @_._, @DEFAULT_UNWIND
   call void @"_._"()
-; CHECK: near_call r0, @_., @DEFAULT_UNWIND
+; CHECK: call r0, @_., @DEFAULT_UNWIND
   call void @"_."()
   ret void
 }
diff --git a/llvm/test/CodeGen/EraVM/exception-handling.ll b/llvm/test/CodeGen/EraVM/exception-handling.ll
index cd6f05218f47..932eaf747b13 100644
--- a/llvm/test/CodeGen/EraVM/exception-handling.ll
+++ b/llvm/test/CodeGen/EraVM/exception-handling.ll
@@ -4,11 +4,11 @@ target triple = "eravm"
 
 ; CHECK-LABEL: test
 ; CHECK: add r2, r0, stack-[1]
-; CHECK:  near_call r0, @foo, @.BB0_2
+; CHECK:  call r0, @foo, @.BB0_2
 ; CHECK: ret
 ; CHECK: .BB0_2:
 ; CHECK: add stack-[1], r0, r1
-; CHECK: revert
+; CHECK: rev
 define void @test(i32 %a, i256 %throwval) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @foo(i32 %a)
@@ -23,11 +23,11 @@ try.cont:
 
 ; CHECK-LABEL: test2
 ; CHECK: add r2, r0, stack-[3]
-; CHECK: near_call r0, @foo16, @.BB1_2
+; CHECK: call r0, @foo16, @.BB1_2
 ; CHECK: ret
 ; CHECK: .BB1_2:
 ; CHECK: add stack-[3], r0, r1
-; CHECK: revert
+; CHECK: rev
 define void @test2(i32 %a, i256 %throwval) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @foo16(i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 %a, i32 0, i32 0)
@@ -41,11 +41,11 @@ try.cont:
 }
 
 ; CHECK-LABEL: test3
-; CHECK: near_call r0, @foo16, @.BB2_3
+; CHECK: call r0, @foo16, @.BB2_3
 ; CHECK: ret
 ; CHECK: .BB2_3:
 ; CHECK: add stack-[3], r0, r1
-; CHECK: revert
+; CHECK: rev
 define void @test3(i32 %a, i256 %throwval) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %cmp = icmp ugt i32 %a, 42
@@ -63,7 +63,7 @@ try.cont:
 }
 
 ; CHECK-LABEL: test4
-; CHECK: near_call r0, @foo16, @.BB3_3
+; CHECK: call r0, @foo16, @.BB3_3
 ; CHECK: .BB3_3:
 ; CHECK: add     r1, r2, r1
 ; CHECK: ret
diff --git a/llvm/test/CodeGen/EraVM/farcall-spill.ll b/llvm/test/CodeGen/EraVM/farcall-spill.ll
index a1e19d91902d..ab4e01437dab 100644
--- a/llvm/test/CodeGen/EraVM/farcall-spill.ll
+++ b/llvm/test/CodeGen/EraVM/farcall-spill.ll
@@ -9,11 +9,11 @@ target triple = "eravm"
 define void @test1() personality i32 ()* @__personality {
   %fptr = invoke i8 addrspace(3)* @__farcall_int(i256 0, i256 1, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
     to label %ok unwind label %fail
-  ; CHECK: far_call	r1, r2, @.BB0_2
-  ; CHECK: ptr.add r1, r0, stack-[1]
+  ; CHECK: callf	r1, r2, @.BB0_2
+  ; CHECK: addp r1, r0, stack-[1]
 ok:
   call void @spill()
-  ; CHECK: ptr.add stack-[1], r0, r1
+  ; CHECK: addp stack-[1], r0, r1
   store i8 addrspace(3)* %fptr, i8 addrspace(3)** @ptr
   ret void
 fail:
@@ -27,18 +27,18 @@ define void @test2(i1 %cond) personality i32 ()* @__personality {
 staticcall:
   %fptrs = invoke i8 addrspace(3)* @__staticcall_int(i256 0, i256 1, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
     to label %ok unwind label %fail
-  ; CHECK: far_call.static r1, r2, @.BB1_4
+  ; CHECK: callf.st r1, r2, @.BB1_4
   ; CHECK: jump @.BB1_3
 delegatecall:
   %fptrd = invoke i8 addrspace(3)* @__delegatecall_int(i256 0, i256 1, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
     to label %ok unwind label %fail
-  ; CHECK: far_call.delegate r1, r2, @.BB1_4
+  ; CHECK: calld r1, r2, @.BB1_4
 ok:
   %fptr = phi i8 addrspace(3)* [%fptrs, %staticcall], [%fptrd, %delegatecall]
   ; CHECK: .BB1_3:
-  ; CHECK: ptr.add r1, r0, stack-[1]
+  ; CHECK: addp r1, r0, stack-[1]
   call void @spill()
-  ; CHECK: ptr.add stack-[1], r0, r1
+  ; CHECK: addp stack-[1], r0, r1
   store i8 addrspace(3)* %fptr, i8 addrspace(3)** @ptr
   ret void
 fail:
diff --git a/llvm/test/CodeGen/EraVM/fold-add-to-select.ll b/llvm/test/CodeGen/EraVM/fold-add-to-select.ll
index cdde446d32d4..5c9cf253223f 100644
--- a/llvm/test/CodeGen/EraVM/fold-add-to-select.ll
+++ b/llvm/test/CodeGen/EraVM/fold-add-to-select.ll
@@ -190,7 +190,7 @@ define i256 @test_reg4_dont_fold_cond_of(i256 %a, i256 %b) {
 define i256 @test_stack1(i256 %a) {
 ; CHECK-LABEL: test_stack1:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub.s! 5, r1, r0
 ; CHECK-NEXT:    add.lt stack-[1], r1, r1
 ; CHECK-NEXT:    ret
@@ -205,7 +205,7 @@ define i256 @test_stack1(i256 %a) {
 define i256 @test_stack2(i256 %a) {
 ; CHECK-LABEL: test_stack2:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub.s! 5, r1, r0
 ; CHECK-NEXT:    add.ge stack-[1], r1, r1
 ; CHECK-NEXT:    ret
diff --git a/llvm/test/CodeGen/EraVM/fold-similar-instructions.ll b/llvm/test/CodeGen/EraVM/fold-similar-instructions.ll
index 3a1aaa7124a3..9d12d9b259c8 100644
--- a/llvm/test/CodeGen/EraVM/fold-similar-instructions.ll
+++ b/llvm/test/CodeGen/EraVM/fold-similar-instructions.ll
@@ -256,7 +256,7 @@ define i256 @test_reg2(i256 %a, i256 %b, i1 %cond) {
 define i256 @test_stack1(i256 %a, i1 %cond) {
 ; CHECK-LABEL: test_stack1:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub.s! stack-[1], r1, r3
 ; CHECK-NEXT:    add.lt r3, r0, r1
 ; CHECK-NEXT:    sub! r2, r0, r0
@@ -274,7 +274,7 @@ define i256 @test_stack1(i256 %a, i1 %cond) {
 define i256 @test_stack2(i256 %a, i1 %cond) {
 ; CHECK-LABEL: test_stack2:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! stack-[1], r1, r3
 ; CHECK-NEXT:    add.lt r3, r0, r1
 ; CHECK-NEXT:    sub! r2, r0, r0
diff --git a/llvm/test/CodeGen/EraVM/frame_memory.ll b/llvm/test/CodeGen/EraVM/frame_memory.ll
index d5205b67cced..7100adffdfd2 100644
--- a/llvm/test/CodeGen/EraVM/frame_memory.ll
+++ b/llvm/test/CodeGen/EraVM/frame_memory.ll
@@ -28,11 +28,11 @@ define void @store_to_frame_select(i256 %par, i1 %flag) nounwind {
   %2 = alloca i256
   %3 = select i1 %flag, i256* %1, i256*%2
 ; get pointer to %1
-; CHECK: context.sp r3
+; CHECK: sp r3
 ; CHECK: sub.s 1, r3, r3
 ; CHECK: shl.s 5, r3, r3
 ; get pointer to %2
-; CHECK: context.sp r4
+; CHECK: sp r4
 ; CHECK: sub.s 2, r4, r4
 ; CHECK: shl.s 5, r4, r4
 ; the select part
diff --git a/llvm/test/CodeGen/EraVM/gasleft-no-sink.ll b/llvm/test/CodeGen/EraVM/gasleft-no-sink.ll
index d98281803667..4f45c7136c97 100644
--- a/llvm/test/CodeGen/EraVM/gasleft-no-sink.ll
+++ b/llvm/test/CodeGen/EraVM/gasleft-no-sink.ll
@@ -8,13 +8,13 @@ define i256 @no_sink(i1 %cond) {
 ; CHECK:        sub! r1, r0, r0
 ; CHECK-NEXT:   jump.eq @.BB0_2
 ; CHECK:        add 2, r0, r1
-; CHECK-NEXT:   st.2 3, r1
-; CHECK-NEXT:   context.gas_left r1
+; CHECK-NEXT:   stm.ah 3, r1
+; CHECK-NEXT:   ergs r1
 ; CHECK-NEXT:   ret
 ; CHECK:       .BB0_2:
 ; CHECK:        add 2, r0, r1
-; CHECK-NEXT:   st.1 2, r1
-; CHECK-NEXT:   context.gas_left r1
+; CHECK-NEXT:   stm.h 2, r1
+; CHECK-NEXT:   ergs r1
 ; CHECK-NEXT:   ret
 ;
 entry:
diff --git a/llvm/test/CodeGen/EraVM/globals.ll b/llvm/test/CodeGen/EraVM/globals.ll
index 184ff2578d5e..0ef9eb0d4d10 100644
--- a/llvm/test/CodeGen/EraVM/globals.ll
+++ b/llvm/test/CodeGen/EraVM/globals.ll
@@ -72,14 +72,14 @@ define void @store.toarray(i256 %val, i256 %i) nounwind {
 
 ; CHECK-LABEL: load.as3
 define i8 addrspace(3)* @load.as3() nounwind {
-  ; CHECK: ptr.add stack[@as3_ptr], r0, r1
+  ; CHECK: addp stack[@as3_ptr], r0, r1
   %res = load i8 addrspace(3)*, i8 addrspace(3)** @as3_ptr
   ret i8 addrspace(3)* %res
 }
 
 ; CHECK-LABEL: store.as3
 define void @store.as3(i8 addrspace(3)* %val) nounwind {
-  ; CHECK: ptr.add r1, r0, stack[@as3_ptr]
+  ; CHECK: addp r1, r0, stack[@as3_ptr]
   store i8 addrspace(3)* %val, i8 addrspace(3)** @as3_ptr
   ret void
 }
diff --git a/llvm/test/CodeGen/EraVM/hoist-flag-setting.ll b/llvm/test/CodeGen/EraVM/hoist-flag-setting.ll
index 452e7a13a7cc..962eba30370a 100644
--- a/llvm/test/CodeGen/EraVM/hoist-flag-setting.ll
+++ b/llvm/test/CodeGen/EraVM/hoist-flag-setting.ll
@@ -102,7 +102,7 @@ define void @test_hoist_inc(i256 addrspace(1)* %dst, i256 %end) {
 ; CHECK-LABEL: test_hoist_inc
 ; CHECK:      .BB3_1:
 ; CHECK:        sub! r1, r2, r0
-; CHECK-NEXT:   st.1.inc r1, r3, r1
+; CHECK-NEXT:   stmi.h r1, r3, r1
 ; CHECK-NEXT:   jump.ne @.BB3_1
 
 entry:
diff --git a/llvm/test/CodeGen/EraVM/immediate-remat.ll b/llvm/test/CodeGen/EraVM/immediate-remat.ll
index bacf70caff03..21ec1bedf017 100644
--- a/llvm/test/CodeGen/EraVM/immediate-remat.ll
+++ b/llvm/test/CodeGen/EraVM/immediate-remat.ll
@@ -10,7 +10,7 @@ define i256 @test_small_imm_pos() {
 ; CHECK-LABEL: test_small_imm_pos:
 ; CHECK:       ; %bb.0: ; %entry
 ; CHECK-NEXT:    add 12345, r0, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add 12345, r0, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -22,7 +22,7 @@ define i256 @test_small_imm_neg() {
 ; CHECK-LABEL: test_small_imm_neg:
 ; CHECK:       ; %bb.0: ; %entry
 ; CHECK-NEXT:    sub.s 12345, r0, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    sub.s 12345, r0, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -34,7 +34,7 @@ define i256 @test_large_imm_pos() {
 ; CHECK-LABEL: test_large_imm_pos:
 ; CHECK:       ; %bb.0: ; %entry
 ; CHECK-NEXT:    add code[@CPI2_0], r0, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add code[@CPI2_0], r0, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -46,7 +46,7 @@ define i256 @test_large_imm_neg() {
 ; CHECK-LABEL: test_large_imm_neg:
 ; CHECK:       ; %bb.0: ; %entry
 ; CHECK-NEXT:    add code[@CPI3_0], r0, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add code[@CPI3_0], r0, r1
 ; CHECK-NEXT:    ret
 entry:
diff --git a/llvm/test/CodeGen/EraVM/indexed-memops.ll b/llvm/test/CodeGen/EraVM/indexed-memops.ll
index 3585179f40df..11c928cbbf4c 100644
--- a/llvm/test/CodeGen/EraVM/indexed-memops.ll
+++ b/llvm/test/CodeGen/EraVM/indexed-memops.ll
@@ -12,8 +12,8 @@ define void @loop1(i256 addrspace(1)* %dest, i256 addrspace(1)* %src, i256 %size
 ; CHECK-NEXT:    add r1, r3, r3
 ; CHECK-NEXT:  .BB0_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r2, r4, r2
-; CHECK-NEXT:    st.1.inc r1, r4, r1
+; CHECK-NEXT:    ldmi.h r2, r4, r2
+; CHECK-NEXT:    stmi.h r1, r4, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB0_1
 ; CHECK-NEXT:  ; %bb.2: ; %memcpy-split
@@ -46,8 +46,8 @@ define void @loop2(i256 addrspace(1)* %dest, i256 addrspace(1)* %src, i256 %size
 ; CHECK-NEXT:    add 320, r2, r2
 ; CHECK-NEXT:  .BB1_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r2, r4, r2
-; CHECK-NEXT:    st.1.inc r1, r4, r1
+; CHECK-NEXT:    ldmi.h r2, r4, r2
+; CHECK-NEXT:    stmi.h r1, r4, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB1_1
 ; CHECK-NEXT:  ; %bb.2: ; %memcpy-split
@@ -81,8 +81,8 @@ define void @loop3(i256 addrspace(1)* %dest, i256 addrspace(1)* %src, i256 %size
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    shl.s 5, r2, r5
 ; CHECK-NEXT:    add r1, r5, r5
-; CHECK-NEXT:    ld.1.inc r4, r6, r4
-; CHECK-NEXT:    st.1 r5, r6
+; CHECK-NEXT:    ldmi.h r4, r6, r4
+; CHECK-NEXT:    stm.h r5, r6
 ; CHECK-NEXT:    add 2, r2, r2
 ; CHECK-NEXT:    sub! r2, r3, r0
 ; CHECK-NEXT:    jump.lt @.BB2_1
@@ -115,8 +115,8 @@ define void @loop4([10 x i256] addrspace(1)* %dest, [10 x i256] addrspace(1)* %s
 ; CHECK-NEXT:    add r0, r0, r4
 ; CHECK-NEXT:  .BB3_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r2, r5, r2
-; CHECK-NEXT:    st.1.inc r1, r5, r1
+; CHECK-NEXT:    ldmi.h r2, r5, r2
+; CHECK-NEXT:    stmi.h r1, r5, r1
 ; CHECK-NEXT:    add 1, r4, r4
 ; CHECK-NEXT:    sub! r4, r3, r0
 ; CHECK-NEXT:    jump.lt @.BB3_1
@@ -146,8 +146,8 @@ define void @loop5([10 x i256] addrspace(1)* %dest, [10 x i256] addrspace(1)* %s
 ; CHECK-NEXT:    add r0, r0, r4
 ; CHECK-NEXT:  .BB4_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r2, r5, r2
-; CHECK-NEXT:    st.1.inc r1, r5, r1
+; CHECK-NEXT:    ldmi.h r2, r5, r2
+; CHECK-NEXT:    stmi.h r1, r5, r1
 ; CHECK-NEXT:    add 1, r4, r4
 ; CHECK-NEXT:    sub! r4, r3, r0
 ; CHECK-NEXT:    jump.lt @.BB4_1
@@ -178,8 +178,8 @@ define void @loop6(i256 addrspace(1)* %dest, i256 addrspace(3)* %src, i256 %size
 ; CHECK-NEXT:    add r1, r3, r3
 ; CHECK-NEXT:  .BB5_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.inc r2, r4, r2
-; CHECK-NEXT:    st.1.inc r1, r4, r1
+; CHECK-NEXT:    ldpi r2, r4, r2
+; CHECK-NEXT:    stmi.h r1, r4, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB5_1
 ; CHECK-NEXT:  ; %bb.2: ; %memcpy-split
diff --git a/llvm/test/CodeGen/EraVM/intrinsic.ll b/llvm/test/CodeGen/EraVM/intrinsic.ll
index b4eeef6d0b51..7c6f22e6e7e9 100644
--- a/llvm/test/CodeGen/EraVM/intrinsic.ll
+++ b/llvm/test/CodeGen/EraVM/intrinsic.ll
@@ -11,86 +11,86 @@ declare i32 @__personality()
 ; CHECK-LABEL: stacksave
 define i8* @stacksave() {
   %res = call i8* @llvm.stacksave()
-; CHECK: context.sp r1
+; CHECK: sp r1
   ret i8* %res
 }
 
 ; CHECK-LABEL: stackrestore
 define void @stackrestore(i8* %ptr) noinline optnone {
-; CHECK: context.sp r2
+; CHECK: sp r2
 ; CHECK-NEXT: sub r1, r2, r1
-; CHECK-NEXT: nop stack+=[0 + r1]
+; CHECK-NEXT: incsp r1
   call void @llvm.stackrestore(i8* %ptr)
   ret void
 }
 
 ; CHECK-LABEL: thisr
 define i256 @thisr() {
-; CHECK: context.this r1
+; CHECK: this r1
   %res = call i256 @llvm.eravm.this()
   ret i256 %res
 }
 
 ; CHECK-LABEL: callerr
 define i256 @callerr() {
-; CHECK: context.caller r1
+; CHECK: par r1
   %res = call i256 @llvm.eravm.caller()
   ret i256 %res
 }
 
 ; CHECK-LABEL: codesourcer
 define i256 @codesourcer() {
-; CHECK: context.code_source r1
+; CHECK: code r1
   %res = call i256 @llvm.eravm.codesource()
   ret i256 %res
 }
 
 ; CHECK-LABEL: metar
 define i256 @metar() {
-; CHECK: context.meta r1
+; CHECK: meta r1
   %res = call i256 @llvm.eravm.meta()
   ret i256 %res
 }
 
 ; CHECK-LABEL: gasleftr
 define i256 @gasleftr() {
-; CHECK: context.gas_left r1
+; CHECK: ergs r1
   %res = call i256 @llvm.eravm.gasleft()
   ret i256 %res
 }
 
 ; CHECK-LABEL: getu128
 define i256 @getu128() {
-; CHECK: context.get_context_u128 r1
+; CHECK: ldvl r1
   %res = call i256 @llvm.eravm.getu128()
   ret i256 %res
 }
 
 ; CHECK-LABEL: setu128
 define void @setu128(i256 %val) {
-; CHECK: context.set_context_u128 r1
+; CHECK: stvl r1
   call void @llvm.eravm.setu128(i256 %val)
   ret void
 }
 
 ; CHECK-LABEL: inctx
 define void @inctx() {
-; CHECK: context.inc_tx_num
+; CHECK: inctx
   call void @llvm.eravm.inctx()
   ret void
 }
 
 ; CHECK-LABEL: setprice
 define void @setprice(i256 %p) {
-; CHECK: context.set_gas_per_pubdata
+; CHECK: stpub
   call void @llvm.eravm.setpubdataprice(i256 %p)
   ret void
 }
 
 ; CHECK-LABEL: tol1_r
 define void @tol1_r(i256 %key, i256 %val) {
-; CHECK: to_l1 r1, r2
-; CHECK: to_l1.first r1, r2
+; CHECK: logL1 r1, r2
+; CHECK: logL1.i r1, r2
   call void @llvm.eravm.tol1(i256 %key, i256 %val, i256 0)
   call void @llvm.eravm.tol1(i256 %key, i256 %val, i256 1)
   ret void
@@ -98,8 +98,8 @@ define void @tol1_r(i256 %key, i256 %val) {
 
 ; CHECK-LABEL: event_r
 define void @event_r(i256 %key, i256 %val) {
-; CHECK: event r1, r2
-; CHECK: event.first r1, r2
+; CHECK: log r1, r2
+; CHECK: log.i r1, r2
   call void @llvm.eravm.event(i256 %key, i256 %val, i256 0)
   call void @llvm.eravm.event(i256 %key, i256 %val, i256 1)
   ret void
@@ -107,21 +107,21 @@ define void @event_r(i256 %key, i256 %val) {
 
 ; CHECK-LABEL: precompile_rr
 define i256 @precompile_rr(i256 %key, i256 %ergs) {
-; CHECK: precompile r1, r2
+; CHECK: callp r1, r2
   %res = call i256 @llvm.eravm.precompile(i256 %key, i256 %ergs)
   ret i256 %res
 }
 
 ; CHECK-LABEL: decommit_rr
 define i8 addrspace(3)* @decommit_rr(i256 %key, i256 %ergs) {
-; CHECK: log.decommit r1, r2
+; CHECK: dcmt r1, r2
   %res = call i8 addrspace(3)* @llvm.eravm.decommit(i256 %key, i256 %ergs)
   ret i8 addrspace(3)* %res
 }
 
 ; CHECK-LABEL: throw
 define void @throw(i256 %val) {
-; CHECK: revert
+; CHECK: rev
   call void @llvm.eravm.throw(i256 %val)
   ret void
 }
@@ -129,7 +129,7 @@ define void @throw(i256 %val) {
 ; CHECK-LABEL: far_return
 define void @far_return(i256 %x, i256 %val) {
 ; CHECK: add r2, r0, r1
-; CHECK: ret.ok.to_label r1, @DEFAULT_FAR_RETURN
+; CHECK: retl @DEFAULT_FAR_RETURN
   call void @llvm.eravm.return(i256 %val)
   unreachable
 }
@@ -137,23 +137,23 @@ define void @far_return(i256 %x, i256 %val) {
 ; CHECK-LABEL: far_revert
 define void @far_revert(i256 %x, i256 %val) {
 ; CHECK: add r2, r0, r1
-; CHECK: ret.revert.to_label r1, @DEFAULT_FAR_REVERT
+; CHECK: revl @DEFAULT_FAR_REVERT
   call void @llvm.eravm.revert(i256 %val)
   unreachable
 }
 
 ; CHECK-LABEL: return_ptr
 define void @return_ptr(i256 %unused, i8 addrspace(3)* %addr) {
-; CHECK: ptr.add r2, r0, r1
-; CHECK: ret.ok.to_label r1, @DEFAULT_FAR_RETURN
+; CHECK: addp r2, r0, r1
+; CHECK: retl @DEFAULT_FAR_RETURN
   call void @llvm.eravm.return.ptr(i8 addrspace(3)* %addr)
   unreachable
 }
 
 ; CHECK-LABEL: revert_ptr
 define void @revert_ptr(i256 %unused, i8 addrspace(3)* %addr) {
-; CHECK: ptr.add r2, r0, r1
-; CHECK: ret.revert.to_label r1, @DEFAULT_FAR_REVERT
+; CHECK: addp r2, r0, r1
+; CHECK: revl @DEFAULT_FAR_REVERT
   call void @llvm.eravm.revert.ptr(i8 addrspace(3)* %addr)
   unreachable
 }
@@ -205,7 +205,7 @@ define i256 @ifgtii() {
 
 ; CHECK-LABEL: invoke.farcall
 define {i8 addrspace(3)*, i1} @invoke.farcall() noinline {
-  ; CHECK: near_call r0, @__farcall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__farcall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__farcall(i256 0, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -213,7 +213,7 @@ define {i8 addrspace(3)*, i1} @invoke.farcall() noinline {
 
 ; CHECK-LABEL: invoke.staticcall
 define {i8 addrspace(3)*, i1} @invoke.staticcall() noinline {
-  ; CHECK: near_call r0, @__staticcall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__staticcall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__staticcall(i256 0, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -221,7 +221,7 @@ define {i8 addrspace(3)*, i1} @invoke.staticcall() noinline {
 
 ; CHECK-LABEL: invoke.delegatecall
 define {i8 addrspace(3)*, i1} @invoke.delegatecall() noinline {
-  ; CHECK: near_call r0, @__delegatecall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__delegatecall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__delegatecall(i256 0, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -229,7 +229,7 @@ define {i8 addrspace(3)*, i1} @invoke.delegatecall() noinline {
 
 ; CHECK-LABEL: invoke.mimiccall
 define {i8 addrspace(3)*, i1} @invoke.mimiccall() noinline {
-  ; CHECK: near_call r0, @__mimiccall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__mimiccall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__mimiccall(i256 0, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 42)
   ret {i8 addrspace(3)*, i1} %res
@@ -237,7 +237,7 @@ define {i8 addrspace(3)*, i1} @invoke.mimiccall() noinline {
 
 ; CHECK-LABEL: invoke.system_call
 define {i8 addrspace(3)*, i1} @invoke.system_call() noinline {
-  ; CHECK: near_call r0, @__farcall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__farcall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__farcall(i256 0, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -245,7 +245,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_call() noinline {
 
 ; CHECK-LABEL: invoke.system_staticcall
 define {i8 addrspace(3)*, i1} @invoke.system_staticcall() noinline {
-  ; CHECK: near_call r0, @__staticcall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__staticcall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__staticcall(i256 0, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -253,7 +253,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_staticcall() noinline {
 
 ; CHECK-LABEL: invoke.system_delegatecall
 define {i8 addrspace(3)*, i1} @invoke.system_delegatecall() noinline {
-  ; CHECK: near_call r0, @__delegatecall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__delegatecall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__delegatecall(i256 0, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -261,7 +261,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_delegatecall() noinline {
 
 ; CHECK-LABEL: invoke.system_mimiccall
 define {i8 addrspace(3)*, i1} @invoke.system_mimiccall() noinline {
-  ; CHECK: near_call r0, @__mimiccall, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__mimiccall, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__mimiccall(i256 0, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 4)
   ret {i8 addrspace(3)*, i1} %res
@@ -269,7 +269,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_mimiccall() noinline {
 
 ; CHECK-LABEL: invoke.farcall_byref
 define {i8 addrspace(3)*, i1} @invoke.farcall_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__farcall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__farcall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__farcall_byref(i8 addrspace(3)* %a1, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -277,7 +277,7 @@ define {i8 addrspace(3)*, i1} @invoke.farcall_byref(i8 addrspace(3)* %a1) noinli
 
 ; CHECK-LABEL: invoke.staticcall_byref
 define {i8 addrspace(3)*, i1} @invoke.staticcall_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__staticcall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__staticcall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__staticcall_byref(i8 addrspace(3)* %a1, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -285,7 +285,7 @@ define {i8 addrspace(3)*, i1} @invoke.staticcall_byref(i8 addrspace(3)* %a1) noi
 
 ; CHECK-LABEL: invoke.delegatecall_byref
 define {i8 addrspace(3)*, i1} @invoke.delegatecall_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__delegatecall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__delegatecall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__delegatecall_byref(i8 addrspace(3)* %a1, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -293,7 +293,7 @@ define {i8 addrspace(3)*, i1} @invoke.delegatecall_byref(i8 addrspace(3)* %a1) n
 
 ; CHECK-LABEL: invoke.mimiccall_byref
 define {i8 addrspace(3)*, i1} @invoke.mimiccall_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__mimiccall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__mimiccall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__mimiccall_byref(i8 addrspace(3)* %a1, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 42)
   ret {i8 addrspace(3)*, i1} %res
@@ -301,7 +301,7 @@ define {i8 addrspace(3)*, i1} @invoke.mimiccall_byref(i8 addrspace(3)* %a1) noin
 
 ; CHECK-LABEL: invoke.system_call_byref
 define {i8 addrspace(3)*, i1} @invoke.system_call_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__farcall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__farcall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__farcall_byref(i8 addrspace(3)* %a1, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -309,7 +309,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_call_byref(i8 addrspace(3)* %a1) no
 
 ; CHECK-LABEL: invoke.system_staticcall_byref
 define {i8 addrspace(3)*, i1} @invoke.system_staticcall_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__staticcall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__staticcall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__staticcall_byref(i8 addrspace(3)* %a1, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -317,7 +317,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_staticcall_byref(i8 addrspace(3)* %
 
 ; CHECK-LABEL: invoke.system_delegatecall_byref
 define {i8 addrspace(3)*, i1} @invoke.system_delegatecall_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__delegatecall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__delegatecall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__delegatecall_byref(i8 addrspace(3)* %a1, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef)
   ret {i8 addrspace(3)*, i1} %res
@@ -325,7 +325,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_delegatecall_byref(i8 addrspace(3)*
 
 ; CHECK-LABEL: invoke.system_mimiccall_byref
 define {i8 addrspace(3)*, i1} @invoke.system_mimiccall_byref(i8 addrspace(3)* %a1) noinline {
-  ; CHECK: near_call r0, @__mimiccall_byref, @DEFAULT_UNWIND
+  ; CHECK: call r0, @__mimiccall_byref, @DEFAULT_UNWIND
   ; CHECK-NEXT: ret
   %res = call {i8 addrspace(3)*, i1} @__mimiccall_byref(i8 addrspace(3)* %a1, i256 1, i256 2, i256 3, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 4)
   ret {i8 addrspace(3)*, i1} %res
@@ -334,7 +334,7 @@ define {i8 addrspace(3)*, i1} @invoke.system_mimiccall_byref(i8 addrspace(3)* %a
 ; CHECK-LABEL: __farcall
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
-; CHECK: far_call r1, r2
+; CHECK: callf r1, r2
 ; CHECK: add 1, r0, r2
 ; CHECK: ret
 ; CHECK: add r0, r0, r2
@@ -342,41 +342,41 @@ define {i8 addrspace(3)*, i1} @invoke.system_mimiccall_byref(i8 addrspace(3)* %a
 ; CHECK-LABEL: __staticcall
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
-; CHECK: far_call.static r1, r2
+; CHECK: callf.st r1, r2
 
 ; CHECK-LABEL: __delegatecall
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
-; CHECK: far_call.delegate r1, r2
+; CHECK: calld r1, r2
 
 ; CHECK-LABEL: __mimiccall
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
 ; CHECK-NOT: r3
 ; CHECK: add r13, r0, r15
-; CHECK: far_call.mimic r1, r2
+; CHECK: callm r1, r2
 
 ; CHECK-LABEL: __farcall_byref
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
-; CHECK: far_call r1, r2
+; CHECK: callf r1, r2
 
 ; CHECK-LABEL: __staticcall_byref
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
-; CHECK: far_call.static r1, r2
+; CHECK: callf.st r1, r2
 
 ; CHECK-LABEL: __delegatecall_byref
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
-; CHECK: far_call.delegate r1, r2
+; CHECK: calld r1, r2
 
 ; CHECK-LABEL: __mimiccall_byref
 ; CHECK-NOT: r1
 ; CHECK-NOT: r2
 ; CHECK-NOT: r3
 ; CHECK: add r13, r0, r15
-; CHECK: far_call.mimic r1, r2
+; CHECK: callm r1, r2
 
 declare i8* @llvm.stacksave()
 declare void @llvm.stackrestore(i8*)
diff --git a/llvm/test/CodeGen/EraVM/large_offset.ll b/llvm/test/CodeGen/EraVM/large_offset.ll
index f77eb6227ad9..3c0c01abf928 100644
--- a/llvm/test/CodeGen/EraVM/large_offset.ll
+++ b/llvm/test/CodeGen/EraVM/large_offset.ll
@@ -9,7 +9,7 @@ declare i32 @__personality()
 ; Function Attrs: null_pointer_is_valid
 define ptr addrspace(3) @test256bit() #0 personality ptr @__personality {
 entry:
-  ; CHECK: ptr.add.s
+  ; CHECK: addp.s
   %val = getelementptr i8, ptr addrspace(3) undef, i256 3334353453452342342354355544445321191012012
   ret ptr addrspace(3) %val
 }
@@ -18,7 +18,7 @@ entry:
 ; Function Attrs: null_pointer_is_valid
 define ptr addrspace(3) @test128bit() #0 personality ptr @__personality {
 entry:
-  ; CHECK: ptr.add.s
+  ; CHECK: addp.s
   %val = getelementptr i8, ptr addrspace(3) undef, i128 170141183460469231731687303715884105727
   ret ptr addrspace(3) %val
 }
diff --git a/llvm/test/CodeGen/EraVM/machinesink-inst-with-cp-operand.ll b/llvm/test/CodeGen/EraVM/machinesink-inst-with-cp-operand.ll
index 8bfe1db9eb21..e4c7b2f4387b 100644
--- a/llvm/test/CodeGen/EraVM/machinesink-inst-with-cp-operand.ll
+++ b/llvm/test/CodeGen/EraVM/machinesink-inst-with-cp-operand.ll
@@ -13,12 +13,12 @@ define i256 @test(i256 %in, i1 %cond) {
 ; CHECK-NEXT:    jump.eq @.BB0_2
 ; CHECK-NEXT:  ; %bb.1: ; %bb1
 ; CHECK-NEXT:    and code[@CPI0_0], r1, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB0_2: ; %bb2
 ; CHECK-NEXT:    add 5, r0, r1
-; CHECK-NEXT:    near_call r0, @use, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @use, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add 1, r0, r1
 ; CHECK-NEXT:    ret
 entry:
diff --git a/llvm/test/CodeGen/EraVM/memcpy-expansion-asm.ll b/llvm/test/CodeGen/EraVM/memcpy-expansion-asm.ll
index 393e9b097091..a1944702c943 100644
--- a/llvm/test/CodeGen/EraVM/memcpy-expansion-asm.ll
+++ b/llvm/test/CodeGen/EraVM/memcpy-expansion-asm.ll
@@ -15,28 +15,28 @@ define void @expand_unknown_p1_p3(ptr addrspace(1) %dest, ptr addrspace(3) %src,
 ; CHECK-NEXT:    add r1, r4, r3
 ; CHECK-NEXT:    jump.eq @.BB0_3
 ; CHECK-NEXT:  ; %bb.1: ; %load-store-loop-preheader
-; CHECK-NEXT:    ptr.add r2, r0, r6
+; CHECK-NEXT:    addp r2, r0, r6
 ; CHECK-NEXT:  .BB0_2: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.inc r6, r7, r6
-; CHECK-NEXT:    st.1.inc r1, r7, r1
+; CHECK-NEXT:    ldpi r6, r7, r6
+; CHECK-NEXT:    stmi.h r1, r7, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB0_2
 ; CHECK-NEXT:  .BB0_3: ; %memcpy-residual-cond
 ; CHECK-NEXT:    sub! r5, r0, r0
 ; CHECK-NEXT:    jump.eq @.BB0_5
 ; CHECK-NEXT:  ; %bb.4: ; %memcpy-residual
-; CHECK-NEXT:    ptr.add r2, r4, r1
+; CHECK-NEXT:    addp r2, r4, r1
 ; CHECK-NEXT:    shl.s 3, r5, r2
-; CHECK-NEXT:    ld.1 r3, r4
+; CHECK-NEXT:    ldm.h r3, r4
 ; CHECK-NEXT:    shl r4, r2, r4
 ; CHECK-NEXT:    shr r4, r2, r4
-; CHECK-NEXT:    ld r1, r1
+; CHECK-NEXT:    ldp r1, r1
 ; CHECK-NEXT:    sub 256, r2, r2
 ; CHECK-NEXT:    shr r1, r2, r1
 ; CHECK-NEXT:    shl r1, r2, r1
 ; CHECK-NEXT:    or r1, r4, r1
-; CHECK-NEXT:    st.1 r3, r1
+; CHECK-NEXT:    stm.h r3, r1
 ; CHECK-NEXT:  .BB0_5: ; %memcpy-split
 ; CHECK-NEXT:    ret
 entry:
@@ -55,8 +55,8 @@ define void @expand_unknown_p1_p1(ptr addrspace(1) %dest, ptr addrspace(1) %src,
 ; CHECK-NEXT:    add r2, r0, r6
 ; CHECK-NEXT:  .BB1_2: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r6, r7, r6
-; CHECK-NEXT:    st.1.inc r1, r7, r1
+; CHECK-NEXT:    ldmi.h r6, r7, r6
+; CHECK-NEXT:    stmi.h r1, r7, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB1_2
 ; CHECK-NEXT:  .BB1_3: ; %memcpy-residual-cond
@@ -65,15 +65,15 @@ define void @expand_unknown_p1_p1(ptr addrspace(1) %dest, ptr addrspace(1) %src,
 ; CHECK-NEXT:  ; %bb.4: ; %memcpy-residual
 ; CHECK-NEXT:    add r2, r4, r1
 ; CHECK-NEXT:    shl.s 3, r5, r2
-; CHECK-NEXT:    ld.1 r3, r4
+; CHECK-NEXT:    ldm.h r3, r4
 ; CHECK-NEXT:    shl r4, r2, r4
 ; CHECK-NEXT:    shr r4, r2, r4
-; CHECK-NEXT:    ld.1 r1, r1
+; CHECK-NEXT:    ldm.h r1, r1
 ; CHECK-NEXT:    sub 256, r2, r2
 ; CHECK-NEXT:    shr r1, r2, r1
 ; CHECK-NEXT:    shl r1, r2, r1
 ; CHECK-NEXT:    or r1, r4, r1
-; CHECK-NEXT:    st.1 r3, r1
+; CHECK-NEXT:    stm.h r3, r1
 ; CHECK-NEXT:  .BB1_5: ; %memcpy-split
 ; CHECK-NEXT:    ret
 entry:
@@ -84,14 +84,14 @@ entry:
 define void @expand_known_p1_p3_loop_iter1(ptr addrspace(1) %dest, ptr addrspace(3) %src) {
 ; CHECK-LABEL: expand_known_p1_p3_loop_iter1:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    ld.inc r2, r2, r3
-; CHECK-NEXT:    st.1.inc r1, r2, r1
-; CHECK-NEXT:    ld.1 r1, r2
+; CHECK-NEXT:    ldpi r2, r2, r3
+; CHECK-NEXT:    stmi.h r1, r2, r1
+; CHECK-NEXT:    ldm.h r1, r2
 ; CHECK-NEXT:    and code[@CPI2_0], r2, r2
-; CHECK-NEXT:    ld r3, r3
+; CHECK-NEXT:    ldp r3, r3
 ; CHECK-NEXT:    and code[@CPI2_1], r3, r3
 ; CHECK-NEXT:    or r3, r2, r2
-; CHECK-NEXT:    st.1 r1, r2
+; CHECK-NEXT:    stm.h r1, r2
 ; CHECK-NEXT:    ret
 entry:
   call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) %dest, ptr addrspace(3) %src, i256 42, i1 false)
@@ -101,14 +101,14 @@ entry:
 define void @expand_known_p1_p1_loop_iter1(ptr addrspace(1) %dest, ptr addrspace(1) %src) {
 ; CHECK-LABEL: expand_known_p1_p1_loop_iter1:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    ld.1.inc r2, r2, r3
-; CHECK-NEXT:    st.1.inc r1, r2, r1
-; CHECK-NEXT:    ld.1 r1, r2
+; CHECK-NEXT:    ldmi.h r2, r2, r3
+; CHECK-NEXT:    stmi.h r1, r2, r1
+; CHECK-NEXT:    ldm.h r1, r2
 ; CHECK-NEXT:    and code[@CPI3_0], r2, r2
-; CHECK-NEXT:    ld.1 r3, r3
+; CHECK-NEXT:    ldm.h r3, r3
 ; CHECK-NEXT:    and code[@CPI3_1], r3, r3
 ; CHECK-NEXT:    or r3, r2, r2
-; CHECK-NEXT:    st.1 r1, r2
+; CHECK-NEXT:    stm.h r1, r2
 ; CHECK-NEXT:    ret
 entry:
   call void @llvm.memcpy.p1.p1.i256(ptr addrspace(1) %dest, ptr addrspace(1) %src, i256 42, i1 false)
@@ -119,21 +119,21 @@ define void @expand_known_p1_p3_loop_iter2(ptr addrspace(1) %dest, ptr addrspace
 ; CHECK-LABEL: expand_known_p1_p3_loop_iter2:
 ; CHECK:       ; %bb.0: ; %entry
 ; CHECK-NEXT:    add 64, r1, r3
-; CHECK-NEXT:    ptr.add r2, r0, r4
+; CHECK-NEXT:    addp r2, r0, r4
 ; CHECK-NEXT:  .BB4_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.inc r4, r5, r4
-; CHECK-NEXT:    st.1.inc r1, r5, r1
+; CHECK-NEXT:    ldpi r4, r5, r4
+; CHECK-NEXT:    stmi.h r1, r5, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB4_1
 ; CHECK-NEXT:  ; %bb.2: ; %memcpy-split
-; CHECK-NEXT:    ld.1 r3, r1
+; CHECK-NEXT:    ldm.h r3, r1
 ; CHECK-NEXT:    and code[@CPI4_0], r1, r1
-; CHECK-NEXT:    ptr.add.s 64, r2, r2
-; CHECK-NEXT:    ld r2, r2
+; CHECK-NEXT:    addp.s 64, r2, r2
+; CHECK-NEXT:    ldp r2, r2
 ; CHECK-NEXT:    and code[@CPI4_1], r2, r2
 ; CHECK-NEXT:    or r2, r1, r1
-; CHECK-NEXT:    st.1 r3, r1
+; CHECK-NEXT:    stm.h r3, r1
 ; CHECK-NEXT:    ret
 entry:
   call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) %dest, ptr addrspace(3) %src, i256 84, i1 false)
@@ -147,18 +147,18 @@ define void @expand_known_p1_p1_loop_iter2(ptr addrspace(1) %dest, ptr addrspace
 ; CHECK-NEXT:    add r2, r0, r4
 ; CHECK-NEXT:  .BB5_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r4, r5, r4
-; CHECK-NEXT:    st.1.inc r1, r5, r1
+; CHECK-NEXT:    ldmi.h r4, r5, r4
+; CHECK-NEXT:    stmi.h r1, r5, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB5_1
 ; CHECK-NEXT:  ; %bb.2: ; %memcpy-split
-; CHECK-NEXT:    ld.1 r3, r1
+; CHECK-NEXT:    ldm.h r3, r1
 ; CHECK-NEXT:    and code[@CPI5_0], r1, r1
 ; CHECK-NEXT:    add 64, r2, r2
-; CHECK-NEXT:    ld.1 r2, r2
+; CHECK-NEXT:    ldm.h r2, r2
 ; CHECK-NEXT:    and code[@CPI5_1], r2, r2
 ; CHECK-NEXT:    or r2, r1, r1
-; CHECK-NEXT:    st.1 r3, r1
+; CHECK-NEXT:    stm.h r3, r1
 ; CHECK-NEXT:    ret
 entry:
   call void @llvm.memcpy.p1.p1.i256(ptr addrspace(1) %dest, ptr addrspace(1) %src, i256 84, i1 false)
diff --git a/llvm/test/CodeGen/EraVM/memintrinsics.ll b/llvm/test/CodeGen/EraVM/memintrinsics.ll
index d714cc5dc8b7..9dfb36da703c 100644
--- a/llvm/test/CodeGen/EraVM/memintrinsics.ll
+++ b/llvm/test/CodeGen/EraVM/memintrinsics.ll
@@ -34,18 +34,18 @@ define fastcc void @huge_copysize1(i256 addrspace(1)* %dest, i256 addrspace(1)*
 ; CHECK-NEXT:    add r2, r0, r4
 ; CHECK-NEXT:  .BB1_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r4, r5, r4
-; CHECK-NEXT:    st.1.inc r1, r5, r1
+; CHECK-NEXT:    ldmi.h r4, r5, r4
+; CHECK-NEXT:    stmi.h r1, r5, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB1_1
 ; CHECK-NEXT:  ; %bb.2: ; %memcpy-split
-; CHECK-NEXT:    ld.1 r3, r1
+; CHECK-NEXT:    ldm.h r3, r1
 ; CHECK-NEXT:    and code[@CPI1_1], r1, r1
 ; CHECK-NEXT:    sub.s code[@CPI1_0], r2, r2
-; CHECK-NEXT:    ld.1 r2, r2
+; CHECK-NEXT:    ldm.h r2, r2
 ; CHECK-NEXT:    and code[@CPI1_2], r2, r2
 ; CHECK-NEXT:    or r2, r1, r1
-; CHECK-NEXT:    st.1 r3, r1
+; CHECK-NEXT:    stm.h r3, r1
 ; CHECK-NEXT:    ret
   call void @llvm.memcpy.p1i256.p1i256.i256(i256 addrspace(1)* %dest, i256 addrspace(1)* %src, i256 81129638414606681695789005144065, i1 false)
   ret void
@@ -58,18 +58,18 @@ define fastcc void @huge_copysize2(i256 addrspace(2)* %dest, i256 addrspace(2)*
 ; CHECK-NEXT:    add r2, r0, r4
 ; CHECK-NEXT:  .BB2_1: ; %load-store-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.2.inc r4, r5, r4
-; CHECK-NEXT:    st.2.inc r1, r5, r1
+; CHECK-NEXT:    ldmi.ah r4, r5, r4
+; CHECK-NEXT:    stmi.ah r1, r5, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB2_1
 ; CHECK-NEXT:  ; %bb.2: ; %memcpy-split
-; CHECK-NEXT:    ld.2 r3, r1
+; CHECK-NEXT:    ldm.ah r3, r1
 ; CHECK-NEXT:    and code[@CPI2_1], r1, r1
 ; CHECK-NEXT:    sub.s code[@CPI2_0], r2, r2
-; CHECK-NEXT:    ld.2 r2, r2
+; CHECK-NEXT:    ldm.ah r2, r2
 ; CHECK-NEXT:    and code[@CPI2_2], r2, r2
 ; CHECK-NEXT:    or r2, r1, r1
-; CHECK-NEXT:    st.2 r3, r1
+; CHECK-NEXT:    stm.ah r3, r1
 ; CHECK-NEXT:    ret
   call void @llvm.memcpy.p2i256.p2i256.i256(i256 addrspace(2)* %dest, i256 addrspace(2)* %src, i256 81129638414606681695789005144065, i1 false)
   ret void
diff --git a/llvm/test/CodeGen/EraVM/memmove-expansion-asm.ll b/llvm/test/CodeGen/EraVM/memmove-expansion-asm.ll
index 9b87ea081dbe..59704f5d8396 100644
--- a/llvm/test/CodeGen/EraVM/memmove-expansion-asm.ll
+++ b/llvm/test/CodeGen/EraVM/memmove-expansion-asm.ll
@@ -26,8 +26,8 @@ define i256 @expand_unknown(ptr addrspace(1) %dst, ptr addrspace(1) %src, i256 %
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    add r5, r4, r7
 ; CHECK-NEXT:    add r6, r4, r8
-; CHECK-NEXT:    ld.1 r8, r8
-; CHECK-NEXT:    st.1 r7, r8
+; CHECK-NEXT:    ldm.h r8, r8
+; CHECK-NEXT:    stm.h r7, r8
 ; CHECK-NEXT:    sub.s! 32, r4, r4
 ; CHECK-NEXT:    jump.ne @.BB0_3
 ; CHECK-NEXT:  .BB0_4: ; %copy-backwards-residual-cond
@@ -44,8 +44,8 @@ define i256 @expand_unknown(ptr addrspace(1) %dst, ptr addrspace(1) %src, i256 %
 ; CHECK-NEXT:    add r2, r0, r6
 ; CHECK-NEXT:  .BB0_7: ; %copy-forward-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r6, r7, r6
-; CHECK-NEXT:    st.1.inc r1, r7, r1
+; CHECK-NEXT:    ldmi.h r6, r7, r6
+; CHECK-NEXT:    stmi.h r1, r7, r1
 ; CHECK-NEXT:    sub! r1, r5, r0
 ; CHECK-NEXT:    jump.ne @.BB0_7
 ; CHECK-NEXT:  .BB0_8: ; %copy-forward-residual-cond
@@ -56,15 +56,15 @@ define i256 @expand_unknown(ptr addrspace(1) %dst, ptr addrspace(1) %src, i256 %
 ; CHECK-NEXT:    add r5, r0, r1
 ; CHECK-NEXT:  .BB0_10: ; %memmove-residual
 ; CHECK-NEXT:    shl.s 3, r3, r3
-; CHECK-NEXT:    ld.1 r1, r4
+; CHECK-NEXT:    ldm.h r1, r4
 ; CHECK-NEXT:    shl r4, r3, r4
 ; CHECK-NEXT:    shr r4, r3, r4
-; CHECK-NEXT:    ld.1 r2, r2
+; CHECK-NEXT:    ldm.h r2, r2
 ; CHECK-NEXT:    sub 256, r3, r3
 ; CHECK-NEXT:    shr r2, r3, r2
 ; CHECK-NEXT:    shl r2, r3, r2
 ; CHECK-NEXT:    or r2, r4, r2
-; CHECK-NEXT:    st.1 r1, r2
+; CHECK-NEXT:    stm.h r1, r2
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -79,18 +79,18 @@ define i256 @expand_known_backward() {
 ; CHECK-NEXT:  .BB1_1: ; %copy-backwards-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    add 9, r1, r2
-; CHECK-NEXT:    ld.1 r2, r2
+; CHECK-NEXT:    ldm.h r2, r2
 ; CHECK-NEXT:    add 99, r1, r3
-; CHECK-NEXT:    st.1 r3, r2
+; CHECK-NEXT:    stm.h r3, r2
 ; CHECK-NEXT:    sub.s! 32, r1, r1
 ; CHECK-NEXT:    jump.ne @.BB1_1
 ; CHECK-NEXT:  ; %bb.2: ; %copy-backwards-residual-cond
-; CHECK-NEXT:    ld.1 10, r2
+; CHECK-NEXT:    ldm.h 10, r2
 ; CHECK-NEXT:    and code[@CPI1_0], r2, r1
-; CHECK-NEXT:    ld.1 100, r2
+; CHECK-NEXT:    ldm.h 100, r2
 ; CHECK-NEXT:    and 255, r2, r2
 ; CHECK-NEXT:    or r1, r2, r1
-; CHECK-NEXT:    st.1 100, r1
+; CHECK-NEXT:    stm.h 100, r1
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -106,19 +106,19 @@ define i256 @expand_known_loop_iter1(ptr addrspace(1) %dst, ptr addrspace(1) %sr
 ; CHECK-NEXT:  ; %bb.1: ; %copy-backwards
 ; CHECK-NEXT:    add 10, r1, r3
 ; CHECK-NEXT:    add 10, r2, r4
-; CHECK-NEXT:    ld.1 r4, r4
-; CHECK-NEXT:    st.1 r3, r4
+; CHECK-NEXT:    ldm.h r4, r4
+; CHECK-NEXT:    stm.h r3, r4
 ; CHECK-NEXT:    jump @.BB2_3
 ; CHECK-NEXT:  .BB2_2: ; %copy-forward
-; CHECK-NEXT:    ld.1.inc r2, r3, r2
-; CHECK-NEXT:    st.1.inc r1, r3, r1
+; CHECK-NEXT:    ldmi.h r2, r3, r2
+; CHECK-NEXT:    stmi.h r1, r3, r1
 ; CHECK-NEXT:  .BB2_3: ; %memmove-residual
-; CHECK-NEXT:    ld.1 r1, r3
+; CHECK-NEXT:    ldm.h r1, r3
 ; CHECK-NEXT:    and code[@CPI2_0], r3, r3
-; CHECK-NEXT:    ld.1 r2, r2
+; CHECK-NEXT:    ldm.h r2, r2
 ; CHECK-NEXT:    and code[@CPI2_1], r2, r2
 ; CHECK-NEXT:    or r2, r3, r2
-; CHECK-NEXT:    st.1 r1, r2
+; CHECK-NEXT:    stm.h r1, r2
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -139,8 +139,8 @@ define i256 @expand_known_loop_iter2(ptr addrspace(1) %dst, ptr addrspace(1) %sr
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    add r4, r3, r6
 ; CHECK-NEXT:    add r5, r3, r7
-; CHECK-NEXT:    ld.1 r7, r7
-; CHECK-NEXT:    st.1 r6, r7
+; CHECK-NEXT:    ldm.h r7, r7
+; CHECK-NEXT:    stm.h r6, r7
 ; CHECK-NEXT:    sub.s! 32, r3, r3
 ; CHECK-NEXT:    jump.ne @.BB3_2
 ; CHECK-NEXT:  ; %bb.3:
@@ -151,19 +151,19 @@ define i256 @expand_known_loop_iter2(ptr addrspace(1) %dst, ptr addrspace(1) %sr
 ; CHECK-NEXT:    add r2, r0, r4
 ; CHECK-NEXT:  .BB3_5: ; %copy-forward-loop
 ; CHECK-NEXT:    ; =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ld.1.inc r4, r5, r4
-; CHECK-NEXT:    st.1.inc r1, r5, r1
+; CHECK-NEXT:    ldmi.h r4, r5, r4
+; CHECK-NEXT:    stmi.h r1, r5, r1
 ; CHECK-NEXT:    sub! r1, r3, r0
 ; CHECK-NEXT:    jump.ne @.BB3_5
 ; CHECK-NEXT:  ; %bb.6: ; %copy-forward-residual-cond
 ; CHECK-NEXT:    add 64, r2, r2
 ; CHECK-NEXT:  .BB3_7: ; %memmove-residual
-; CHECK-NEXT:    ld.1 r3, r1
+; CHECK-NEXT:    ldm.h r3, r1
 ; CHECK-NEXT:    and code[@CPI3_0], r1, r1
-; CHECK-NEXT:    ld.1 r2, r2
+; CHECK-NEXT:    ldm.h r2, r2
 ; CHECK-NEXT:    and code[@CPI3_1], r2, r2
 ; CHECK-NEXT:    or r2, r1, r1
-; CHECK-NEXT:    st.1 r3, r1
+; CHECK-NEXT:    stm.h r3, r1
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    ret
 entry:
diff --git a/llvm/test/CodeGen/EraVM/overflow-branch.ll b/llvm/test/CodeGen/EraVM/overflow-branch.ll
index 6fe3cc1d5993..b1d16986d5bb 100644
--- a/llvm/test/CodeGen/EraVM/overflow-branch.ll
+++ b/llvm/test/CodeGen/EraVM/overflow-branch.ll
@@ -16,10 +16,10 @@ define void @uaddo_branch_1(i256 %x, i256 %y) {
 ; CHECK-NEXT:    add! r1, r2, r0
 ; CHECK-NEXT:    jump.lt @.BB0_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB0_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 entry:
   %res1 = call {i256, i1} @llvm.uadd.with.overflow.i256(i256 %x, i256 %y)
@@ -44,10 +44,10 @@ define void @uadd_branch_2(i256 %x, i256 %y) {
 ; CHECK-NEXT:    add! r1, r2, r0
 ; CHECK-NEXT:    jump.lt @.BB1_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB1_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 entry:
   %res1 = call {i256, i1} @llvm.uadd.with.overflow.i256(i256 %x, i256 %y)
@@ -69,16 +69,16 @@ exit:
 define i256 @uadd_branch_3(i256 %x, i256 %y) {
 ; CHECK-LABEL: uadd_branch_3:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r1, r2, stack-[1]
 ; CHECK-NEXT:    add! r1, r2, r0
 ; CHECK-NEXT:    jump.lt @.BB2_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB2_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 entry:
@@ -102,7 +102,7 @@ exit:
 define i256 @uadd_branch_complicated(i256 %a, i256 %b, i256 %c, i256 %x, i256 %y) {
 ; CHECK-LABEL: uadd_branch_complicated:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r4, r5, r6
 ; CHECK-NEXT:    sub! r1, r2, r0
 ; CHECK-NEXT:    add.lt r3, r0, r6
@@ -110,11 +110,11 @@ define i256 @uadd_branch_complicated(i256 %a, i256 %b, i256 %c, i256 %x, i256 %y
 ; CHECK-NEXT:    add! r4, r5, r0
 ; CHECK-NEXT:    jump.lt @.BB3_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB3_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 entry:
@@ -143,10 +143,10 @@ define void @usub_branch_1(i256 %x, i256 %y) {
 ; CHECK-NEXT:    sub! r1, r2, r0
 ; CHECK-NEXT:    jump.lt @.BB4_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB4_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 entry:
   %res1 = call {i256, i1} @llvm.usub.with.overflow.i256(i256 %x, i256 %y)
@@ -171,10 +171,10 @@ define void @usub_branch_2(i256 %x, i256 %y) {
 ; CHECK-NEXT:    sub! r1, r2, r0
 ; CHECK-NEXT:    jump.lt @.BB5_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB5_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 entry:
   %res1 = call {i256, i1} @llvm.usub.with.overflow.i256(i256 %x, i256 %y)
@@ -196,15 +196,15 @@ exit:
 define i256 @usub_branch_3(i256 %x, i256 %y) {
 ; CHECK-LABEL: usub_branch_3:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r1, r2, stack-[1]
 ; CHECK-NEXT:    jump.lt @.BB6_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB6_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 entry:
@@ -231,10 +231,10 @@ define void @umul_branch_1(i256 %x, i256 %y) {
 ; CHECK-NEXT:    mul! r1, r2, r0, r0
 ; CHECK-NEXT:    jump.lt @.BB7_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB7_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 entry:
   %res1 = call {i256, i1} @llvm.umul.with.overflow.i256(i256 %x, i256 %y)
@@ -259,10 +259,10 @@ define void @umul_branch_2(i256 %x, i256 %y) {
 ; CHECK-NEXT:    mul! r1, r2, r0, r0
 ; CHECK-NEXT:    jump.lt @.BB8_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB8_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 entry:
   %res1 = call {i256, i1} @llvm.umul.with.overflow.i256(i256 %x, i256 %y)
@@ -284,16 +284,16 @@ exit:
 define i256 @umul_branch_3(i256 %x, i256 %y) {
 ; CHECK-LABEL: umul_branch_3:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    mul r1, r2, stack-[1], r0
 ; CHECK-NEXT:    mul! r1, r2, r0, r0
 ; CHECK-NEXT:    jump.lt @.BB9_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB9_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    add stack-[1], r0, r1 ; 32-byte Folded Reload
 ; CHECK-NEXT:    ret
 entry:
diff --git a/llvm/test/CodeGen/EraVM/overflow-neg.ll b/llvm/test/CodeGen/EraVM/overflow-neg.ll
index ebe21aa2cfa1..650001b475bb 100644
--- a/llvm/test/CodeGen/EraVM/overflow-neg.ll
+++ b/llvm/test/CodeGen/EraVM/overflow-neg.ll
@@ -35,10 +35,10 @@ define void @add_branch_neg_1(i256 %x, i256 %y) {
 ; CHECK-NEXT:    add! r3, r2, r0
 ; CHECK-NEXT:    jump.lt @.BB1_2
 ; CHECK-NEXT:  ; %bb.1: ; %no_overflow_detected
-; CHECK-NEXT:    near_call r0, @has_no_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_no_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .BB1_2: ; %overflow_detected
-; CHECK-NEXT:    near_call r0, @has_overflow, @DEFAULT_UNWIND
+; CHECK-NEXT:    call r0, @has_overflow, @DEFAULT_UNWIND
 ; CHECK-NEXT:    ret
 entry:
   %res1 = call {i256, i1} @llvm.uadd.with.overflow.i256(i256 %x, i256 %y)
diff --git a/llvm/test/CodeGen/EraVM/overflow.ll b/llvm/test/CodeGen/EraVM/overflow.ll
index dfdd0e32a288..77e4eba3df58 100644
--- a/llvm/test/CodeGen/EraVM/overflow.ll
+++ b/llvm/test/CodeGen/EraVM/overflow.ll
@@ -129,7 +129,7 @@ entry:
 define i256 @add_test_srr(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_srr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
 ; CHECK-NEXT:    ret
@@ -203,7 +203,7 @@ entry:
 define i256 @add_test_sir(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_sir:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -354,7 +354,7 @@ entry:
 define i256 @add_test_scr(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_scr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -372,7 +372,7 @@ entry:
 define i256 @add_test_scr_cp(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_scr_cp:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add code[@CPI23_0], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -389,7 +389,7 @@ entry:
 define i256 @add_test_rsr(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_rsr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r2
 ; CHECK-NEXT:    add.lt r1, r0, r2
@@ -407,7 +407,7 @@ entry:
 define i256 @add_test_isr(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_isr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt 42, r0, r1
@@ -424,7 +424,7 @@ entry:
 define i256 @add_test_csr(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_csr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt code[@val], r0, r1
@@ -442,7 +442,7 @@ entry:
 define i256 @add_test_csr_cp(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_csr_cp:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt code[@CPI27_0], r0, r1
@@ -459,7 +459,7 @@ entry:
 define i256 @add_test_ssr(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_ssr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[2], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -478,7 +478,7 @@ entry:
 define i256 @add_test_rrs(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_rrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add.lt r1, r0, r2
 ; CHECK-NEXT:    add r2, r0, stack-[1]
@@ -496,7 +496,7 @@ entry:
 define i256 @add_test_irs(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_irs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r2, r0, r1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add.lt 42, r0, r1
@@ -514,7 +514,7 @@ entry:
 define i256 @add_test_crs(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_crs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r2, r0, r1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add.lt code[@val], r0, r1
@@ -533,7 +533,7 @@ entry:
 define i256 @add_test_srs(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_srs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add r2, r0, r1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -553,7 +553,7 @@ entry:
 define i256 @add_test_ris(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_ris:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, r2
 ; CHECK-NEXT:    add.lt r1, r0, r2
@@ -572,7 +572,7 @@ entry:
 define i256 @add_test_iis(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_iis:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, r1
 ; CHECK-NEXT:    add.lt 17, r0, r1
@@ -590,7 +590,7 @@ entry:
 define i256 @add_test_cis(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_cis:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, r1
 ; CHECK-NEXT:    add.lt code[@val], r0, r1
@@ -609,7 +609,7 @@ entry:
 define i256 @add_test_sis(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_sis:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -629,7 +629,7 @@ entry:
 define i256 @add_test_rcs(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_rcs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, r2
 ; CHECK-NEXT:    add.lt r1, r0, r2
@@ -649,7 +649,7 @@ entry:
 define i256 @add_test_ics(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_ics:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, r1
 ; CHECK-NEXT:    add.lt 42, r0, r1
@@ -668,7 +668,7 @@ entry:
 define i256 @add_test_ccs(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_ccs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, r1
 ; CHECK-NEXT:    add.lt code[@val2], r0, r1
@@ -688,7 +688,7 @@ entry:
 define i256 @add_test_scs(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_scs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -709,7 +709,7 @@ entry:
 define i256 @add_test_rss(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_rss:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r2
 ; CHECK-NEXT:    add.lt r1, r0, r2
@@ -730,7 +730,7 @@ entry:
 define i256 @add_test_iss(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_iss:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt 42, r0, r1
@@ -750,7 +750,7 @@ entry:
 define i256 @add_test_css(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_css:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt code[@val], r0, r1
@@ -771,7 +771,7 @@ entry:
 define i256 @add_test_sss(i256 %a, i256 %b, i256 %x, i256 %y) {
 ; CHECK-LABEL: add_test_sss:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[3 + r0]
+; CHECK-NEXT:    incsp 3
 ; CHECK-NEXT:    add! r3, r4, r0
 ; CHECK-NEXT:    add stack-[2], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
diff --git a/llvm/test/CodeGen/EraVM/pointer.ll b/llvm/test/CodeGen/EraVM/pointer.ll
index d6fdd722214f..a6c8d1f5ba8c 100644
--- a/llvm/test/CodeGen/EraVM/pointer.ll
+++ b/llvm/test/CodeGen/EraVM/pointer.ll
@@ -9,7 +9,7 @@ target triple = "eravm"
 
 ; CHECK-LABEL: ptr_add_i8
 define i8 @ptr_add_i8(i8 addrspace(3) * %ptr) #0 {
-  ; CHECK: ptr.add.s 5, r1, r1
+  ; CHECK: addp.s 5, r1, r1
   %ptr2 = getelementptr inbounds i8, i8 addrspace (3) * %ptr, i256 5
   %v = load i8, i8 addrspace(3)* %ptr2
   ret i8 %v
@@ -17,7 +17,7 @@ define i8 @ptr_add_i8(i8 addrspace(3) * %ptr) #0 {
 
 ; CHECK-LABEL: ptr_add_i16
 define i16 @ptr_add_i16(i16 addrspace(3) * %ptr) #0 {
-  ; CHECK: ptr.add.s 10, r1, r1
+  ; CHECK: addp.s 10, r1, r1
   %ptr2 = getelementptr inbounds i16, i16 addrspace (3) * %ptr, i256 5
   %v = load i16, i16 addrspace(3)* %ptr2
   ret i16 %v
@@ -25,7 +25,7 @@ define i16 @ptr_add_i16(i16 addrspace(3) * %ptr) #0 {
 
 ; CHECK-LABEL: ptr_add_i32
 define i32 @ptr_add_i32(i32 addrspace(3) *  %ptr) #0 {
-  ; CHECK: ptr.add.s 20, r1, r1
+  ; CHECK: addp.s 20, r1, r1
   %ptr2 = getelementptr inbounds i32, i32 addrspace (3) * %ptr, i256 5
   %v = load i32, i32 addrspace(3)* %ptr2
   ret i32 %v
@@ -33,7 +33,7 @@ define i32 @ptr_add_i32(i32 addrspace(3) *  %ptr) #0 {
 
 ; CHECK-LABEL: ptr_add_i64
 define i64 @ptr_add_i64(i64 addrspace(3) * %ptr) #0 {
-  ; CHECK: ptr.add.s 40, r1, r1
+  ; CHECK: addp.s 40, r1, r1
   %ptr2 = getelementptr inbounds i64, i64 addrspace (3) * %ptr, i256 5
   %v = load i64, i64 addrspace(3)* %ptr2
   ret i64 %v
@@ -41,7 +41,7 @@ define i64 @ptr_add_i64(i64 addrspace(3) * %ptr) #0 {
 
 ; CHECK-LABEL: ptr_add_i256
 define i256 @ptr_add_i256(i256 addrspace(3) *  %ptr) #0 {
-  ; CHECK: ptr.add.s 160, r1, r1
+  ; CHECK: addp.s 160, r1, r1
   %ptr2 = getelementptr inbounds i256, i256 addrspace (3) * %ptr, i256 5
   %v = load i256, i256 addrspace(3)* %ptr2
   ret i256 %v
@@ -52,7 +52,7 @@ define i256 @ptr_add_i256(i256 addrspace(3) *  %ptr) #0 {
 ; CHECK-LABEL: ptr_add_i8_2
 define i8 @ptr_add_i8_2(i8 addrspace(3) *  %ptr, i256 %idx) #0 {
   ; CHECK-NOT: shl
-  ; CHECK: ptr.add r1, r{{[0-9]+}}, r1
+  ; CHECK: addp r1, r{{[0-9]+}}, r1
   %ptr2 = getelementptr inbounds i8, i8 addrspace (3) * %ptr, i256 %idx
   %v = load i8, i8 addrspace(3)* %ptr2
   ret i8 %v
@@ -61,7 +61,7 @@ define i8 @ptr_add_i8_2(i8 addrspace(3) *  %ptr, i256 %idx) #0 {
 ; CHECK-LABEL: ptr_add_i16_2
 define i16 @ptr_add_i16_2(i16 addrspace(3) * %ptr, i256 %idx) #0 {
   ; CHECK: shl.s 1, r2, r2
-  ; CHECK: ptr.add r1, r{{[0-9]+}}, r1
+  ; CHECK: addp r1, r{{[0-9]+}}, r1
   %ptr2 = getelementptr inbounds i16, i16 addrspace (3) * %ptr, i256 %idx
   %v = load i16, i16 addrspace(3)* %ptr2
   ret i16 %v
@@ -70,7 +70,7 @@ define i16 @ptr_add_i16_2(i16 addrspace(3) * %ptr, i256 %idx) #0 {
 ; CHECK-LABEL: ptr_add_i32_2
 define i32 @ptr_add_i32_2(i32 addrspace(3) * %ptr, i256 %idx) #0 {
   ; CHECK: shl.s 2, r2, r2
-  ; CHECK: ptr.add r1, r{{[0-9]+}}, r1
+  ; CHECK: addp r1, r{{[0-9]+}}, r1
   %ptr2 = getelementptr inbounds i32, i32 addrspace (3) * %ptr, i256 %idx
   %v = load i32, i32 addrspace(3)* %ptr2
   ret i32 %v
@@ -79,7 +79,7 @@ define i32 @ptr_add_i32_2(i32 addrspace(3) * %ptr, i256 %idx) #0 {
 ; CHECK-LABEL: ptr_add_i64_2
 define i64 @ptr_add_i64_2(i64 addrspace(3) * %ptr, i256 %idx) #0 {
   ; CHECK: shl.s 3, r2, r2
-  ; CHECK: ptr.add r1, r{{[0-9]+}}, r1
+  ; CHECK: addp r1, r{{[0-9]+}}, r1
   %ptr2 = getelementptr inbounds i64, i64 addrspace (3) * %ptr, i256 %idx
   %v = load i64, i64 addrspace(3)* %ptr2
   ret i64 %v
@@ -88,7 +88,7 @@ define i64 @ptr_add_i64_2(i64 addrspace(3) * %ptr, i256 %idx) #0 {
 ; CHECK-LABEL: ptr_add_i256_2
 define i256 @ptr_add_i256_2(i256 addrspace(3) * %ptr, i256 %idx) #0 {
   ; CHECK: shl.s 5, r2, r2
-  ; CHECK: ptr.add r1, r{{[0-9]+}}, r1
+  ; CHECK: addp r1, r{{[0-9]+}}, r1
   %ptr2 = getelementptr inbounds i256, i256 addrspace (3) * %ptr, i256 %idx
   %v = load i256, i256 addrspace(3)* %ptr2
   ret i256 %v
@@ -96,14 +96,14 @@ define i256 @ptr_add_i256_2(i256 addrspace(3) * %ptr, i256 %idx) #0 {
 
 ; CHECK-LABEL: ptr_pack
 define i8 addrspace(3) * @ptr_pack(i8 addrspace(3) * %ptr) #0 {
-  ; CHECK: ptr.pack.s 1024, r1, r1
+  ; CHECK: pack.s 1024, r1, r1
   %ptr2 = call i8 addrspace(3) *(i8 addrspace(3) *, i256) @llvm.eravm.ptr.pack(i8 addrspace(3) * %ptr, i256 1024);
   ret i8 addrspace(3) * %ptr2;
 }
 
 ; CHECK-LABEL: ptr_pack_variable_index
 define i8 addrspace(3) * @ptr_pack_variable_index(i8 addrspace(3) * %ptr, i256 %idx) #0 {
-  ; CHECK: ptr.pack r1, r2
+  ; CHECK: pack r1, r2
   %ptr2 = call i8 addrspace(3) *(i8 addrspace(3) *, i256) @llvm.eravm.ptr.pack(i8 addrspace(3) * %ptr, i256 %idx);
   ret i8 addrspace(3) * %ptr2;
 }
diff --git a/llvm/test/CodeGen/EraVM/ptradd.ll b/llvm/test/CodeGen/EraVM/ptradd.ll
index f112534e4d17..e8fc84a14023 100644
--- a/llvm/test/CodeGen/EraVM/ptradd.ll
+++ b/llvm/test/CodeGen/EraVM/ptradd.ll
@@ -8,14 +8,14 @@ target triple = "eravm"
 
 ; CHECK-LABEL: ptraddrrr
 define i8 addrspace(3)* @ptraddrrr(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
-; CHECK: ptr.add r1, r2, r1
+; CHECK: addp r1, r2, r1
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 %rs2
   ret i8 addrspace(3)* %res1
 }
 
 ; CHECK-LABEL: ptraddrir
 define i8 addrspace(3)* @ptraddrir(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.add.s 42, r1, r1
+; CHECK: addp.s 42, r1, r1
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 42
   ret i8 addrspace(3)* %res1
 }
@@ -23,7 +23,7 @@ define i8 addrspace(3)* @ptraddrir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddrsr
 define i8 addrspace(3)* @ptraddrsr(i8 addrspace(3)* %rs1) nounwind {
   %valptr = alloca i256
-; CHECK: ptr.add.s stack-[1], r1, r1
+; CHECK: addp.s stack-[1], r1, r1
   %val = load i256, i256* %valptr
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 %val
   ret i8 addrspace(3)* %res1
@@ -31,7 +31,7 @@ define i8 addrspace(3)* @ptraddrsr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptraddrcr
 define i8 addrspace(3)* @ptraddrcr(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.add.s code[@val], r1, r1
+; CHECK: addp.s code[@val], r1, r1
   %val = load i256, i256 addrspace(4)* @val
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 %val
   ret i8 addrspace(3)* %res1
@@ -39,7 +39,7 @@ define i8 addrspace(3)* @ptraddrcr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptraddgrr
 define i8 addrspace(3)* @ptraddgrr(i256 %rs2) nounwind {
-; CHECK: ptr.add stack[@ptr], r1, r1
+; CHECK: addp stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %rs2
   ret i8 addrspace(3)* %res1
@@ -48,7 +48,7 @@ define i8 addrspace(3)* @ptraddgrr(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptraddgir
 define i8 addrspace(3)* @ptraddgir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add 42, r0, r1
-; CHECK: ptr.add stack[@ptr], r1, r1
+; CHECK: addp stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 42
   ret i8 addrspace(3)* %res1
@@ -57,7 +57,7 @@ define i8 addrspace(3)* @ptraddgir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddgsr
 define i8 addrspace(3)* @ptraddgsr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add stack-[1], r0, r1
-; CHECK: ptr.add stack[@ptr], r1, r1
+; CHECK: addp stack[@ptr], r1, r1
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -68,7 +68,7 @@ define i8 addrspace(3)* @ptraddgsr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddgcr
 define i8 addrspace(3)* @ptraddgcr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add code[@val], r0, r1
-; CHECK: ptr.add stack[@ptr], r1, r1
+; CHECK: addp stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %val
@@ -77,7 +77,7 @@ define i8 addrspace(3)* @ptraddgcr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptraddsrr
 define i8 addrspace(3)* @ptraddsrr(i256 %rs2) nounwind {
-; CHECK: ptr.add stack-[1], r1, r1
+; CHECK: addp stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %rs2
@@ -87,7 +87,7 @@ define i8 addrspace(3)* @ptraddsrr(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptraddsir
 define i8 addrspace(3)* @ptraddsir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add 42, r0, r1
-; CHECK: ptr.add stack-[1], r1, r1
+; CHECK: addp stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 42
@@ -97,7 +97,7 @@ define i8 addrspace(3)* @ptraddsir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddssr
 define i8 addrspace(3)* @ptraddssr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add stack-[2], r0, r1
-; CHECK: ptr.add stack-[1], r1, r1
+; CHECK: addp stack-[1], r1, r1
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -109,7 +109,7 @@ define i8 addrspace(3)* @ptraddssr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddscr
 define i8 addrspace(3)* @ptraddscr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add code[@val], r0, r1
-; CHECK: ptr.add stack-[1], r1, r1
+; CHECK: addp stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
@@ -120,7 +120,7 @@ define i8 addrspace(3)* @ptraddscr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddrrs
 define void @ptraddrrs(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.add r1, r2, stack-[1]
+; CHECK: addp r1, r2, stack-[1]
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 %rs2
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
   ret void
@@ -129,7 +129,7 @@ define void @ptraddrrs(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
 ; CHECK-LABEL: ptraddris
 define void @ptraddris(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.add.s 42, r1, stack-[1]
+; CHECK: addp.s 42, r1, stack-[1]
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 42
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
   ret void
@@ -139,7 +139,7 @@ define void @ptraddris(i8 addrspace(3)* %rs1) nounwind {
 define void @ptraddrss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   %valptr = alloca i256
-; CHECK: ptr.add.s stack-[1], r1, stack-[2]
+; CHECK: addp.s stack-[1], r1, stack-[2]
   %val = load i256, i256* %valptr
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 %val
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -149,7 +149,7 @@ define void @ptraddrss(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddrcs
 define void @ptraddrcs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.add.s code[@val], r1, stack-[1]
+; CHECK: addp.s code[@val], r1, stack-[1]
   %val = load i256, i256 addrspace(4)* @val
   %res1 = getelementptr i8, i8 addrspace(3)* %rs1, i256 %val
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -159,7 +159,7 @@ define void @ptraddrcs(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddgrs
 define void @ptraddgrs(i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.add stack[@ptr], r1, stack-[1]
+; CHECK: addp stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %rs2
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -170,7 +170,7 @@ define void @ptraddgrs(i256 %rs2) nounwind {
 define void @ptraddgis(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.add stack[@ptr], r1, stack-[1]
+  ; CHECK: addp stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 42
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -181,7 +181,7 @@ define void @ptraddgis(i8 addrspace(3)* %rs1) nounwind {
 define void @ptraddgss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
 ; CHECK: add stack-[1], r0, r1
-; CHECK: ptr.add stack[@ptr], r1, stack-[2]
+; CHECK: addp stack[@ptr], r1, stack-[2]
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -194,7 +194,7 @@ define void @ptraddgss(i8 addrspace(3)* %rs1) nounwind {
 define void @ptraddgcs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.add stack[@ptr], r1, stack-[1]
+  ; CHECK: addp stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %val
@@ -205,7 +205,7 @@ define void @ptraddgcs(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddsrs
 define void @ptraddsrs(i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.add stack-[1], r1, stack-[2]
+; CHECK: addp stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %rs2
@@ -217,7 +217,7 @@ define void @ptraddsrs(i256 %rs2) nounwind {
 define void @ptraddsis(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.add stack-[1], r1, stack-[2]
+  ; CHECK: addp stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 42
@@ -229,7 +229,7 @@ define void @ptraddsis(i8 addrspace(3)* %rs1) nounwind {
 define void @ptraddsss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add stack-[2], r0, r1
-  ; CHECK: ptr.add stack-[1], r1, stack-[3]
+  ; CHECK: addp stack-[1], r1, stack-[3]
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -243,7 +243,7 @@ define void @ptraddsss(i8 addrspace(3)* %rs1) nounwind {
 define void @ptraddscs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.add stack-[1], r1, stack-[2]
+  ; CHECK: addp stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
@@ -254,7 +254,7 @@ define void @ptraddscs(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptraddgrg
 define void @ptraddgrg(i256 %rs2) nounwind {
-; CHECK: ptr.add stack[@ptr], r1, stack[@ptr]
+; CHECK: addp stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %rs2
   store i8 addrspace(3)* %res1, i8 addrspace(3)** @ptr
@@ -264,7 +264,7 @@ define void @ptraddgrg(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptraddgig
 define void @ptraddgig(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.add stack[@ptr], r1, stack[@ptr]
+  ; CHECK: addp stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 42
   store i8 addrspace(3)* %res1, i8 addrspace(3)** @ptr
@@ -274,7 +274,7 @@ define void @ptraddgig(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddgsg
 define void @ptraddgsg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add stack-[1], r0, r1
-  ; CHECK: ptr.add stack[@ptr], r1, stack[@ptr]
+  ; CHECK: addp stack[@ptr], r1, stack[@ptr]
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -286,7 +286,7 @@ define void @ptraddgsg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddgcg
 define void @ptraddgcg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add code[@val], r0, r1
-; CHECK: ptr.add stack[@ptr], r1, stack[@ptr]
+; CHECK: addp stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %val
@@ -296,7 +296,7 @@ define void @ptraddgcg(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptraddsrg
 define void @ptraddsrg(i256 %rs2) nounwind {
-; CHECK: ptr.add stack-[1], r1, stack[@ptr]
+; CHECK: addp stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 %rs2
@@ -307,7 +307,7 @@ define void @ptraddsrg(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptraddsig
 define void @ptraddsig(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.add stack-[1], r1, stack[@ptr]
+  ; CHECK: addp stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = getelementptr i8, i8 addrspace(3)* %ptr, i256 42
@@ -318,7 +318,7 @@ define void @ptraddsig(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddssg
 define void @ptraddssg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add stack-[2], r0, r1
-  ; CHECK: ptr.add stack-[1], r1, stack[@ptr]
+  ; CHECK: addp stack-[1], r1, stack[@ptr]
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -331,7 +331,7 @@ define void @ptraddssg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptraddscg
 define void @ptraddscg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.add stack-[1], r1, stack[@ptr]
+  ; CHECK: addp stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
diff --git a/llvm/test/CodeGen/EraVM/ptrpack.ll b/llvm/test/CodeGen/EraVM/ptrpack.ll
index a298735356b0..76e8dc771f58 100644
--- a/llvm/test/CodeGen/EraVM/ptrpack.ll
+++ b/llvm/test/CodeGen/EraVM/ptrpack.ll
@@ -8,14 +8,14 @@ target triple = "eravm"
 
 ; CHECK-LABEL: ptrpackrrr
 define i8 addrspace(3)* @ptrpackrrr(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
-; CHECK: ptr.pack r1, r2, r1
+; CHECK: pack r1, r2, r1
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 %rs2)
   ret i8 addrspace(3)* %res1
 }
 
 ; CHECK-LABEL: ptrpackrir
 define i8 addrspace(3)* @ptrpackrir(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.pack.s 42, r1, r1
+; CHECK: pack.s 42, r1, r1
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 42)
   ret i8 addrspace(3)* %res1
 }
@@ -23,7 +23,7 @@ define i8 addrspace(3)* @ptrpackrir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackrsr
 define i8 addrspace(3)* @ptrpackrsr(i8 addrspace(3)* %rs1) nounwind {
   %valptr = alloca i256
-; CHECK: ptr.pack.s stack-[1], r1, r1
+; CHECK: pack.s stack-[1], r1, r1
   %val = load i256, i256* %valptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 %val)
   ret i8 addrspace(3)* %res1
@@ -31,7 +31,7 @@ define i8 addrspace(3)* @ptrpackrsr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrpackrcr
 define i8 addrspace(3)* @ptrpackrcr(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.pack.s code[@val], r1, r1
+; CHECK: pack.s code[@val], r1, r1
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 %val)
   ret i8 addrspace(3)* %res1
@@ -39,7 +39,7 @@ define i8 addrspace(3)* @ptrpackrcr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrpackgrr
 define i8 addrspace(3)* @ptrpackgrr(i256 %rs2) nounwind {
-; CHECK: ptr.pack stack[@ptr], r1, r1
+; CHECK: pack stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %rs2)
   ret i8 addrspace(3)* %res1
@@ -47,7 +47,7 @@ define i8 addrspace(3)* @ptrpackgrr(i256 %rs2) nounwind {
 
 ; CHECK-LABEL: ptrpackgir
 define i8 addrspace(3)* @ptrpackgir(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.pack stack[@ptr], r1, r1
+; CHECK: pack stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 42)
   ret i8 addrspace(3)* %res1
@@ -55,7 +55,7 @@ define i8 addrspace(3)* @ptrpackgir(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrpackgsr
 define i8 addrspace(3)* @ptrpackgsr(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.pack stack[@ptr], r1, r1
+; CHECK: pack stack[@ptr], r1, r1
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -66,7 +66,7 @@ define i8 addrspace(3)* @ptrpackgsr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackgcr
 define i8 addrspace(3)* @ptrpackgcr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add code[@val], r0, r1
-; CHECK: ptr.pack stack[@ptr], r1, r1
+; CHECK: pack stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %val)
@@ -75,7 +75,7 @@ define i8 addrspace(3)* @ptrpackgcr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrpacksrr
 define i8 addrspace(3)* @ptrpacksrr(i256 %rs2) nounwind {
-; CHECK: ptr.pack stack-[1], r1, r1
+; CHECK: pack stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %rs2)
@@ -85,7 +85,7 @@ define i8 addrspace(3)* @ptrpacksrr(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrpacksir
 define i8 addrspace(3)* @ptrpacksir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add 42, r0, r1
-; CHECK: ptr.pack stack-[1], r1, r1
+; CHECK: pack stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 42)
@@ -95,7 +95,7 @@ define i8 addrspace(3)* @ptrpacksir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackssr
 define i8 addrspace(3)* @ptrpackssr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     stack-[2], r0, r1
-; CHECK: ptr.pack        stack-[1], r1, r1
+; CHECK: pack        stack-[1], r1, r1
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -107,7 +107,7 @@ define i8 addrspace(3)* @ptrpackssr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackscr
 define i8 addrspace(3)* @ptrpackscr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     code[@val], r0, r1
-; CHECK: ptr.pack        stack-[1], r1, r1
+; CHECK: pack        stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
@@ -118,7 +118,7 @@ define i8 addrspace(3)* @ptrpackscr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackrrs
 define void @ptrpackrrs(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.pack r1, r2, stack-[1]
+; CHECK: pack r1, r2, stack-[1]
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 %rs2)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
   ret void
@@ -127,7 +127,7 @@ define void @ptrpackrrs(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrpackris
 define void @ptrpackris(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.pack.s 42, r1, stack-[1]
+; CHECK: pack.s 42, r1, stack-[1]
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 42)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
   ret void
@@ -137,7 +137,7 @@ define void @ptrpackris(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrpackrss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   %valptr = alloca i256
-; CHECK: ptr.pack.s stack-[1], r1, stack-[2]
+; CHECK: pack.s stack-[1], r1, stack-[2]
   %val = load i256, i256* %valptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 %val)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -147,7 +147,7 @@ define void @ptrpackrss(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackrcs
 define void @ptrpackrcs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.pack.s code[@val], r1, stack-[1]
+; CHECK: pack.s code[@val], r1, stack-[1]
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %rs1, i256 %val)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -157,7 +157,7 @@ define void @ptrpackrcs(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackgrs
 define void @ptrpackgrs(i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.pack stack[@ptr], r1, stack-[1]
+; CHECK: pack stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %rs2)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -168,7 +168,7 @@ define void @ptrpackgrs(i256 %rs2) nounwind {
 define void @ptrpackgis(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add 42, r0, r1
-	; CHECK: ptr.pack stack[@ptr], r1, stack-[1]
+  ; CHECK: pack stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 42)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -179,7 +179,7 @@ define void @ptrpackgis(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrpackgss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
 ; CHECK: add stack-[1], r0, r1
-; CHECK: ptr.pack stack[@ptr], r1, stack-[2]
+; CHECK: pack stack[@ptr], r1, stack-[2]
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -192,7 +192,7 @@ define void @ptrpackgss(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrpackgcs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.pack stack[@ptr], r1, stack-[1]
+  ; CHECK: pack stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %val)
@@ -203,7 +203,7 @@ define void @ptrpackgcs(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpacksrs
 define void @ptrpacksrs(i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.pack stack-[1], r1, stack-[2]
+; CHECK: pack stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %rs2)
@@ -215,7 +215,7 @@ define void @ptrpacksrs(i256 %rs2) nounwind {
 define void @ptrpacksis(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.pack stack-[1], r1, stack-[2]
+  ; CHECK: pack stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 42)
@@ -227,7 +227,7 @@ define void @ptrpacksis(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrpacksss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add stack-[2], r0, r1
-  ; CHECK: ptr.pack stack-[1], r1, stack-[3]
+  ; CHECK: pack stack-[1], r1, stack-[3]
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -241,7 +241,7 @@ define void @ptrpacksss(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrpackscs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.pack stack-[1], r1, stack-[2]
+  ; CHECK: pack stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
@@ -252,7 +252,7 @@ define void @ptrpackscs(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrpackgrg
 define void @ptrpackgrg(i256 %rs2) nounwind {
-; CHECK: ptr.pack stack[@ptr], r1, stack[@ptr]
+; CHECK: pack stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %rs2)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** @ptr
@@ -262,7 +262,7 @@ define void @ptrpackgrg(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrpackgig
 define void @ptrpackgig(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.pack stack[@ptr], r1, stack[@ptr]
+  ; CHECK: pack stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 42)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** @ptr
@@ -272,7 +272,7 @@ define void @ptrpackgig(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackgsg
 define void @ptrpackgsg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add stack-[1], r0, r1
-  ; CHECK: ptr.pack stack[@ptr], r1, stack[@ptr]
+  ; CHECK: pack stack[@ptr], r1, stack[@ptr]
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -284,7 +284,7 @@ define void @ptrpackgsg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackgcg
 define void @ptrpackgcg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add code[@val], r0, r1
-; CHECK: ptr.pack stack[@ptr], r1, stack[@ptr]
+; CHECK: pack stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %val)
@@ -294,7 +294,7 @@ define void @ptrpackgcg(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrpacksrg
 define void @ptrpacksrg(i256 %rs2) nounwind {
-; CHECK: ptr.pack stack-[1], r1, stack[@ptr]
+; CHECK: pack stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 %rs2)
@@ -305,7 +305,7 @@ define void @ptrpacksrg(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrpacksig
 define void @ptrpacksig(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.pack stack-[1], r1, stack[@ptr]
+  ; CHECK: pack stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %ptr, i256 42)
@@ -316,7 +316,7 @@ define void @ptrpacksig(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackssg
 define void @ptrpackssg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add stack-[2], r0, r1
-  ; CHECK: ptr.pack stack-[1], r1, stack[@ptr]
+  ; CHECK: pack stack-[1], r1, stack[@ptr]
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -329,7 +329,7 @@ define void @ptrpackssg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrpackscg
 define void @ptrpackscg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.pack stack-[1], r1, stack[@ptr]
+  ; CHECK: pack stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
diff --git a/llvm/test/CodeGen/EraVM/ptrshrink.ll b/llvm/test/CodeGen/EraVM/ptrshrink.ll
index 8b164957cd64..281cf2bfc051 100644
--- a/llvm/test/CodeGen/EraVM/ptrshrink.ll
+++ b/llvm/test/CodeGen/EraVM/ptrshrink.ll
@@ -8,14 +8,14 @@ target triple = "eravm"
 
 ; CHECK-LABEL: ptrshrinkrrr
 define i8 addrspace(3)* @ptrshrinkrrr(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
-; CHECK: ptr.shrink r1, r2, r1
+; CHECK: shrnk r1, r2, r1
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 %rs2)
   ret i8 addrspace(3)* %res1
 }
 
 ; CHECK-LABEL: ptrshrinkrir
 define i8 addrspace(3)* @ptrshrinkrir(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.shrink.s 42, r1, r1
+; CHECK: shrnk.s 42, r1, r1
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 42)
   ret i8 addrspace(3)* %res1
 }
@@ -23,7 +23,7 @@ define i8 addrspace(3)* @ptrshrinkrir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkrsr
 define i8 addrspace(3)* @ptrshrinkrsr(i8 addrspace(3)* %rs1) nounwind {
   %valptr = alloca i256
-; CHECK: ptr.shrink.s stack-[1], r1, r1
+; CHECK: shrnk.s stack-[1], r1, r1
   %val = load i256, i256* %valptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 %val)
   ret i8 addrspace(3)* %res1
@@ -31,7 +31,7 @@ define i8 addrspace(3)* @ptrshrinkrsr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrshrinkrcr
 define i8 addrspace(3)* @ptrshrinkrcr(i8 addrspace(3)* %rs1) nounwind {
-; CHECK: ptr.shrink.s code[@val], r1, r1
+; CHECK: shrnk.s code[@val], r1, r1
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 %val)
   ret i8 addrspace(3)* %res1
@@ -39,7 +39,7 @@ define i8 addrspace(3)* @ptrshrinkrcr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrshrinkgrr
 define i8 addrspace(3)* @ptrshrinkgrr(i256 %rs2) nounwind {
-; CHECK: ptr.shrink stack[@ptr], r1, r1
+; CHECK: shrnk stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %rs2)
   ret i8 addrspace(3)* %res1
@@ -48,7 +48,7 @@ define i8 addrspace(3)* @ptrshrinkgrr(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrshrinkgir
 define i8 addrspace(3)* @ptrshrinkgir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     42, r0, r1
-; CHECK: ptr.shrink      stack[@ptr], r1, r1
+; CHECK: shrnk      stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 42)
   ret i8 addrspace(3)* %res1
@@ -57,7 +57,7 @@ define i8 addrspace(3)* @ptrshrinkgir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkgsr
 define i8 addrspace(3)* @ptrshrinkgsr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     stack-[1], r0, r1
-; CHECK: ptr.shrink      stack[@ptr], r1, r1
+; CHECK: shrnk      stack[@ptr], r1, r1
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -68,7 +68,7 @@ define i8 addrspace(3)* @ptrshrinkgsr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkgcr
 define i8 addrspace(3)* @ptrshrinkgcr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     code[@val], r0, r1
-; CHECK: ptr.shrink      stack[@ptr], r1, r1
+; CHECK: shrnk      stack[@ptr], r1, r1
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %val)
@@ -77,7 +77,7 @@ define i8 addrspace(3)* @ptrshrinkgcr(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrshrinksrr
 define i8 addrspace(3)* @ptrshrinksrr(i256 %rs2) nounwind {
-; CHECK: ptr.shrink stack-[1], r1, r1
+; CHECK: shrnk stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %rs2)
@@ -87,7 +87,7 @@ define i8 addrspace(3)* @ptrshrinksrr(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrshrinksir
 define i8 addrspace(3)* @ptrshrinksir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     42, r0, r1
-; CHECK: ptr.shrink      stack-[1], r1, r1
+; CHECK: shrnk      stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 42)
@@ -97,7 +97,7 @@ define i8 addrspace(3)* @ptrshrinksir(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkssr
 define i8 addrspace(3)* @ptrshrinkssr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     stack-[2], r0, r1
-; CHECK: ptr.shrink      stack-[1], r1, r1
+; CHECK: shrnk      stack-[1], r1, r1
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -109,7 +109,7 @@ define i8 addrspace(3)* @ptrshrinkssr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkscr
 define i8 addrspace(3)* @ptrshrinkscr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add     code[@val], r0, r1
-; CHECK: ptr.shrink      stack-[1], r1, r1
+; CHECK: shrnk      stack-[1], r1, r1
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
@@ -120,7 +120,7 @@ define i8 addrspace(3)* @ptrshrinkscr(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkrrs
 define void @ptrshrinkrrs(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.shrink r1, r2, stack-[1]
+; CHECK: shrnk r1, r2, stack-[1]
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 %rs2)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
   ret void
@@ -129,7 +129,7 @@ define void @ptrshrinkrrs(i8 addrspace(3)* %rs1, i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrshrinkris
 define void @ptrshrinkris(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.shrink.s 42, r1, stack-[1]
+; CHECK: shrnk.s 42, r1, stack-[1]
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 42)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
   ret void
@@ -139,7 +139,7 @@ define void @ptrshrinkris(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrshrinkrss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   %valptr = alloca i256
-; CHECK: ptr.shrink.s stack-[1], r1, stack-[2]
+; CHECK: shrnk.s stack-[1], r1, stack-[2]
   %val = load i256, i256* %valptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 %val)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -149,7 +149,7 @@ define void @ptrshrinkrss(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkrcs
 define void @ptrshrinkrcs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.shrink.s code[@val], r1, stack-[1]
+; CHECK: shrnk.s code[@val], r1, stack-[1]
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %rs1, i256 %val)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -159,7 +159,7 @@ define void @ptrshrinkrcs(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkgrs
 define void @ptrshrinkgrs(i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.shrink stack[@ptr], r1, stack-[1]
+; CHECK: shrnk stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %rs2)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -170,7 +170,7 @@ define void @ptrshrinkgrs(i256 %rs2) nounwind {
 define void @ptrshrinkgis(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.shrink stack[@ptr], r1, stack-[1]
+  ; CHECK: shrnk stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 42)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** %result
@@ -181,7 +181,7 @@ define void @ptrshrinkgis(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrshrinkgss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
 ; CHECK: add stack-[1], r0, r1
-; CHECK: ptr.shrink stack[@ptr], r1, stack-[2]
+; CHECK: shrnk stack[@ptr], r1, stack-[2]
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -194,7 +194,7 @@ define void @ptrshrinkgss(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrshrinkgcs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.shrink stack[@ptr], r1, stack-[1]
+  ; CHECK: shrnk stack[@ptr], r1, stack-[1]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %val)
@@ -205,7 +205,7 @@ define void @ptrshrinkgcs(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinksrs
 define void @ptrshrinksrs(i256 %rs2) nounwind {
   %result = alloca i8 addrspace(3)*
-; CHECK: ptr.shrink stack-[1], r1, stack-[2]
+; CHECK: shrnk stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %rs2)
@@ -217,7 +217,7 @@ define void @ptrshrinksrs(i256 %rs2) nounwind {
 define void @ptrshrinksis(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.shrink stack-[1], r1, stack-[2]
+  ; CHECK: shrnk stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 42)
@@ -229,7 +229,7 @@ define void @ptrshrinksis(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrshrinksss(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add stack-[2], r0, r1
-  ; CHECK: ptr.shrink stack-[1], r1, stack-[3]
+  ; CHECK: shrnk stack-[1], r1, stack-[3]
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -243,7 +243,7 @@ define void @ptrshrinksss(i8 addrspace(3)* %rs1) nounwind {
 define void @ptrshrinkscs(i8 addrspace(3)* %rs1) nounwind {
   %result = alloca i8 addrspace(3)*
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.shrink stack-[1], r1, stack-[2]
+  ; CHECK: shrnk stack-[1], r1, stack-[2]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
@@ -254,7 +254,7 @@ define void @ptrshrinkscs(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrshrinkgrg
 define void @ptrshrinkgrg(i256 %rs2) nounwind {
-; CHECK: ptr.shrink stack[@ptr], r1, stack[@ptr]
+; CHECK: shrnk stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %rs2)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** @ptr
@@ -264,7 +264,7 @@ define void @ptrshrinkgrg(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrshrinkgig
 define void @ptrshrinkgig(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.shrink stack[@ptr], r1, stack[@ptr]
+  ; CHECK: shrnk stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 42)
   store i8 addrspace(3)* %res1, i8 addrspace(3)** @ptr
@@ -274,7 +274,7 @@ define void @ptrshrinkgig(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkgsg
 define void @ptrshrinkgsg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add stack-[1], r0, r1
-  ; CHECK: ptr.shrink stack[@ptr], r1, stack[@ptr]
+  ; CHECK: shrnk stack[@ptr], r1, stack[@ptr]
   %valptr = alloca i256
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256* %valptr
@@ -286,7 +286,7 @@ define void @ptrshrinkgsg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkgcg
 define void @ptrshrinkgcg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK: add code[@val], r0, r1
-; CHECK: ptr.shrink stack[@ptr], r1, stack[@ptr]
+; CHECK: shrnk stack[@ptr], r1, stack[@ptr]
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** @ptr
   %val = load i256, i256 addrspace(4)* @val
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %val)
@@ -296,7 +296,7 @@ define void @ptrshrinkgcg(i8 addrspace(3)* %rs1) nounwind {
 
 ; CHECK-LABEL: ptrshrinksrg
 define void @ptrshrinksrg(i256 %rs2) nounwind {
-; CHECK: ptr.shrink stack-[1], r1, stack[@ptr]
+; CHECK: shrnk stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 %rs2)
@@ -307,7 +307,7 @@ define void @ptrshrinksrg(i256 %rs2) nounwind {
 ; CHECK-LABEL: ptrshrinksig
 define void @ptrshrinksig(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add 42, r0, r1
-  ; CHECK: ptr.shrink stack-[1], r1, stack[@ptr]
+  ; CHECK: shrnk stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %res1 = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %ptr, i256 42)
@@ -318,7 +318,7 @@ define void @ptrshrinksig(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkssg
 define void @ptrshrinkssg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add stack-[2], r0, r1
-  ; CHECK: ptr.shrink stack-[1], r1, stack[@ptr]
+  ; CHECK: shrnk stack-[1], r1, stack[@ptr]
   %valptr = alloca i256
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
@@ -331,7 +331,7 @@ define void @ptrshrinkssg(i8 addrspace(3)* %rs1) nounwind {
 ; CHECK-LABEL: ptrshrinkscg
 define void @ptrshrinkscg(i8 addrspace(3)* %rs1) nounwind {
   ; CHECK: add code[@val], r0, r1
-  ; CHECK: ptr.shrink stack-[1], r1, stack[@ptr]
+  ; CHECK: shrnk stack-[1], r1, stack[@ptr]
   %ptrptr = alloca i8 addrspace(3)*
   %ptr = load i8 addrspace(3)*, i8 addrspace(3)** %ptrptr
   %val = load i256, i256 addrspace(4)* @val
diff --git a/llvm/test/CodeGen/EraVM/reload-use.ll b/llvm/test/CodeGen/EraVM/reload-use.ll
index 6e327e18ef09..70db70c47359 100644
--- a/llvm/test/CodeGen/EraVM/reload-use.ll
+++ b/llvm/test/CodeGen/EraVM/reload-use.ll
@@ -221,7 +221,7 @@ define void @spill_shrs(i256 %a) nounwind {
 ; CHECK-LABEL: spill_ptraddr
 define i8 addrspace(3)* @spill_ptraddr(i8 addrspace(3)* %a) nounwind {
   %b = call i256 @foo()
-  ; CHECK: ptr.add stack-[1], r1, r1
+  ; CHECK: addp stack-[1], r1, r1
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %a, i256 %b)
   ret i8 addrspace(3)* %res
 }
@@ -230,7 +230,7 @@ define i8 addrspace(3)* @spill_ptraddr(i8 addrspace(3)* %a) nounwind {
 define void @spill_ptradds(i8 addrspace(3)* %a) nounwind {
   %slot = alloca i8 addrspace(3)*
   %b = call i256 @foo()
-  ; CHECK: ptr.add stack-[1], r1, stack-[2] 
+  ; CHECK: addp stack-[1], r1, stack-[2]
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %a, i256 %b)
   store i8 addrspace(3)* %res, i8 addrspace(3)** %slot
   ret void
@@ -239,7 +239,7 @@ define void @spill_ptradds(i8 addrspace(3)* %a) nounwind {
 ; CHECK-LABEL: spill_ptrpackr
 define i8 addrspace(3)* @spill_ptrpackr(i8 addrspace(3)* %a) nounwind {
   %b = call i256 @foo()
-  ; CHECK: ptr.pack stack-[1], r1, r1
+  ; CHECK: pack stack-[1], r1, r1
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %a, i256 %b)
   ret i8 addrspace(3)* %res
 }
@@ -248,7 +248,7 @@ define i8 addrspace(3)* @spill_ptrpackr(i8 addrspace(3)* %a) nounwind {
 define void @spill_ptrpacks(i8 addrspace(3)* %a) nounwind {
   %slot = alloca i8 addrspace(3)*
   %b = call i256 @foo()
-  ; CHECK: ptr.pack stack-[1], r1, stack-[2] 
+  ; CHECK: pack stack-[1], r1, stack-[2]
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %a, i256 %b)
   store i8 addrspace(3)* %res, i8 addrspace(3)** %slot
   ret void
@@ -257,7 +257,7 @@ define void @spill_ptrpacks(i8 addrspace(3)* %a) nounwind {
 ; CHECK-LABEL: spill_ptrshrinkr
 define i8 addrspace(3)* @spill_ptrshrinkr(i8 addrspace(3)* %a) nounwind {
   %b = call i256 @foo()
-  ; CHECK: ptr.shrink stack-[1], r1, r1
+  ; CHECK: shrnk stack-[1], r1, r1
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %a, i256 %b)
   ret i8 addrspace(3)* %res
 }
@@ -266,7 +266,7 @@ define i8 addrspace(3)* @spill_ptrshrinkr(i8 addrspace(3)* %a) nounwind {
 define void @spill_ptrshrinks(i8 addrspace(3)* %a) nounwind {
   %slot = alloca i8 addrspace(3)*
   %b = call i256 @foo()
-  ; CHECK: ptr.shrink stack-[1], r1, stack-[2] 
+  ; CHECK: shrnk stack-[1], r1, stack-[2]
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %a, i256 %b)
   store i8 addrspace(3)* %res, i8 addrspace(3)** %slot
   ret void
@@ -369,7 +369,7 @@ define i256 @spill_shrx(i256 %a) nounwind {
 ; CHECK-LABEL: spill_ptraddx
 define i8 addrspace(3)* @spill_ptraddx(i256 %a) nounwind {
   %b = call i8 addrspace(3)* @bar()
-  ; CHECK: ptr.add.s stack-[1], r1, r1
+  ; CHECK: addp.s stack-[1], r1, r1
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.add(i8 addrspace(3)* %b, i256 %a)
   ret i8 addrspace(3)* %res
 }
@@ -377,7 +377,7 @@ define i8 addrspace(3)* @spill_ptraddx(i256 %a) nounwind {
 ; CHECK-LABEL: spill_ptrpackx
 define i8 addrspace(3)* @spill_ptrpackx(i256 %a) nounwind {
   %b = call i8 addrspace(3)* @bar()
-  ; CHECK: ptr.pack.s stack-[1], r1, r1
+  ; CHECK: pack.s stack-[1], r1, r1
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.pack(i8 addrspace(3)* %b, i256 %a)
   ret i8 addrspace(3)* %res
 }
@@ -385,7 +385,7 @@ define i8 addrspace(3)* @spill_ptrpackx(i256 %a) nounwind {
 ; CHECK-LABEL: spill_ptrshrinkx
 define i8 addrspace(3)* @spill_ptrshrinkx(i256 %a) nounwind {
   %b = call i8 addrspace(3)* @bar()
-  ; CHECK: ptr.shrink.s stack-[1], r1, r1
+  ; CHECK: shrnk.s stack-[1], r1, r1
   %res = call i8 addrspace(3)* @llvm.eravm.ptr.shrink(i8 addrspace(3)* %b, i256 %a)
   ret i8 addrspace(3)* %res
 }
diff --git a/llvm/test/CodeGen/EraVM/rol.ll b/llvm/test/CodeGen/EraVM/rol.ll
index ab1ff09b03fd..2f8de028dba7 100644
--- a/llvm/test/CodeGen/EraVM/rol.ll
+++ b/llvm/test/CodeGen/EraVM/rol.ll
@@ -88,7 +88,7 @@ entry:
 define i256 @rolsrr(i256 %rs1) {
 ; CHECK-LABEL: rolsrr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol stack-[1], r1, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -104,7 +104,7 @@ entry:
 define i256 @rolzrr(i256 %rs1) {
 ; CHECK-LABEL: rolzrr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol.s stack-[1], r1, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -120,7 +120,7 @@ entry:
 define void @rolrrs(i256 %rs1, i256 %rs2) {
 ; CHECK-LABEL: rolrrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol r1, r2, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -136,7 +136,7 @@ entry:
 define void @rolirs(i256 %rs1) {
 ; CHECK-LABEL: rolirs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol 20, r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -152,7 +152,7 @@ entry:
 define void @rolxrs(i256 %rs1) {
 ; CHECK-LABEL: rolxrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol.s 20, r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -167,7 +167,7 @@ entry:
 define void @rolcrs(i256 %rs1) {
 ; CHECK-LABEL: rolcrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol code[@val], r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -184,7 +184,7 @@ entry:
 define void @rolcrs_cp(i256 %rs1) {
 ; CHECK-LABEL: rolcrs_cp:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol code[@CPI12_0], r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -200,7 +200,7 @@ entry:
 define void @rolyrs(i256 %rs1) {
 ; CHECK-LABEL: rolyrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    rol.s code[@val], r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -217,7 +217,7 @@ entry:
 define void @rolsrs(i256 %rs1) {
 ; CHECK-LABEL: rolsrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    rol stack-[1], r1, stack-[2]
 ; CHECK-NEXT:    ret
 entry:
@@ -235,7 +235,7 @@ entry:
 define void @rolzrs(i256 %rs1) {
 ; CHECK-LABEL: rolzrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    rol.s stack-[1], r1, stack-[2]
 ; CHECK-NEXT:    ret
 entry:
diff --git a/llvm/test/CodeGen/EraVM/ror.ll b/llvm/test/CodeGen/EraVM/ror.ll
index 9e6d021c3b10..af857e4d8a29 100644
--- a/llvm/test/CodeGen/EraVM/ror.ll
+++ b/llvm/test/CodeGen/EraVM/ror.ll
@@ -86,7 +86,7 @@ entry:
 define i256 @rorsrr(i256 %rs1) {
 ; CHECK-LABEL: rorsrr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    ror stack-[1], r1, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -102,7 +102,7 @@ entry:
 define i256 @rorzrr(i256 %rs1) {
 ; CHECK-LABEL: rorzrr:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    ror.s stack-[1], r1, r1
 ; CHECK-NEXT:    ret
 entry:
@@ -118,7 +118,7 @@ entry:
 define void @rorrrs(i256 %rs1, i256 %rs2) {
 ; CHECK-LABEL: rorrrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    ror r1, r2, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -134,7 +134,7 @@ entry:
 define void @rorirs(i256 %rs1) {
 ; CHECK-LABEL: rorirs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    ror 20, r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -150,7 +150,7 @@ entry:
 define void @rorxrs(i256 %rs1) {
 ; CHECK-LABEL: rorxrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    ror.s 20, r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -163,7 +163,7 @@ entry:
 define void @rorcrs(i256 %rs1) {
 ; CHECK-LABEL: rorcrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    ror code[@val], r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -180,7 +180,7 @@ entry:
 define void @rorcrs_cp(i256 %rs1) {
 ; CHECK-LABEL: rorcrs_cp:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp	1
 ; CHECK-NEXT:    ror code[@CPI12_0], r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -196,7 +196,7 @@ entry:
 define void @roryrs(i256 %rs1) {
 ; CHECK-LABEL: roryrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    ror.s code[@val], r1, stack-[1]
 ; CHECK-NEXT:    ret
 entry:
@@ -213,7 +213,7 @@ entry:
 define void @rorsrs(i256 %rs1) {
 ; CHECK-LABEL: rorsrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    ror stack-[1], r1, stack-[2]
 ; CHECK-NEXT:    ret
 entry:
@@ -231,7 +231,7 @@ entry:
 define void @rorzrs(i256 %rs1) {
 ; CHECK-LABEL: rorzrs:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    ror.s stack-[1], r1, stack-[2]
 ; CHECK-NEXT:    ret
 entry:
diff --git a/llvm/test/CodeGen/EraVM/select-zero.ll b/llvm/test/CodeGen/EraVM/select-zero.ll
index 74a26e4e0e52..6576fc0144dc 100644
--- a/llvm/test/CodeGen/EraVM/select-zero.ll
+++ b/llvm/test/CodeGen/EraVM/select-zero.ll
@@ -239,7 +239,7 @@ entry:
 define i256 @select_zero_add_stack(i256 %0, i256 %1) {
 ; CHECK-LABEL: select_zero_add_stack:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r1, r2, r0
 ; CHECK-NEXT:    add.eq stack-[1], r2, r2
 ; CHECK-NEXT:    add r2, r0, r1
@@ -272,7 +272,7 @@ entry:
 define i256 @select_zero_not_folded_1(i256 %0, i256 %1) {
 ; CHECK-LABEL: select_zero_not_folded_1:
 ; CHECK:       ; %bb.0: ; %entry
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r1, r2, r3
 ; CHECK-NEXT:    sub! r1, r2, r0
 ; CHECK-NEXT:    add 0, r0, r1
diff --git a/llvm/test/CodeGen/EraVM/selectcc.ll b/llvm/test/CodeGen/EraVM/selectcc.ll
index 5f9e5ed096ad..e97bebf41a41 100644
--- a/llvm/test/CodeGen/EraVM/selectcc.ll
+++ b/llvm/test/CodeGen/EraVM/selectcc.ll
@@ -79,7 +79,7 @@ define i256 @selcrr_cp(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selsrr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selsrr:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add r2, r0, r1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add.gt stack-[1], r0, r1
@@ -142,7 +142,7 @@ define i256 @selcir_cp(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selsir(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selsir:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, r1
 ; CHECK-NEXT:    add.gt stack-[1], r0, r1
@@ -269,7 +269,7 @@ define i256 @selccr_cp_cp(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selscr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selscr:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -285,7 +285,7 @@ define i256 @selscr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selscr_cp(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selscr_cp:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add code[@CPI22_0], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -300,7 +300,7 @@ define i256 @selscr_cp(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selrsr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selrsr:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add.ge stack-[1], r0, r1
 ; CHECK-NEXT:    ret
@@ -314,7 +314,7 @@ define i256 @selrsr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selisr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selisr:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt 42, r0, r1
@@ -329,7 +329,7 @@ define i256 @selisr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selcsr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selcsr:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt code[@val], r0, r1
@@ -345,7 +345,7 @@ define i256 @selcsr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selcsr_cp(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selcsr_cp:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, r1
 ; CHECK-NEXT:    add.lt code[@CPI26_0], r0, r1
@@ -360,7 +360,7 @@ define i256 @selcsr_cp(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define i256 @selssr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selssr:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[2], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
@@ -377,7 +377,7 @@ define i256 @selssr(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selrrs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selrrs:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add r2, r0, stack-[1]
 ; CHECK-NEXT:    add.eq r1, r0, stack-[1]
@@ -393,7 +393,7 @@ define void @selrrs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selirs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selirs:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add r2, r0, stack-[1]
 ; CHECK-NEXT:    add.gt 42, r0, stack-[1]
@@ -409,7 +409,7 @@ define void @selirs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selcrs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selcrs:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add r2, r0, stack-[1]
 ; CHECK-NEXT:    add.gt code[@val], r0, stack-[1]
@@ -426,7 +426,7 @@ define void @selcrs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selsrs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selsrs:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add r2, r0, stack-[2]
 ; CHECK-NEXT:    add.gt stack-[1], r0, stack-[2]
@@ -444,7 +444,7 @@ define void @selsrs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selris(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selris:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, stack-[1]
 ; CHECK-NEXT:    add.lt r1, r0, stack-[1]
@@ -460,7 +460,7 @@ define void @selris(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @seliis(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: seliis:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, stack-[1]
 ; CHECK-NEXT:    add.lt 17, r0, stack-[1]
@@ -476,7 +476,7 @@ define void @seliis(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selcis(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selcis:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, stack-[1]
 ; CHECK-NEXT:    add.gt code[@val], r0, stack-[1]
@@ -493,7 +493,7 @@ define void @selcis(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selsis(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selsis:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add 42, r0, stack-[2]
 ; CHECK-NEXT:    add.gt stack-[1], r0, stack-[2]
@@ -511,7 +511,7 @@ define void @selsis(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selrcs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selrcs:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, stack-[1]
 ; CHECK-NEXT:    add.lt r1, r0, stack-[1]
@@ -528,7 +528,7 @@ define void @selrcs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selics(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selics:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, stack-[1]
 ; CHECK-NEXT:    add.lt 42, r0, stack-[1]
@@ -545,7 +545,7 @@ define void @selics(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selccs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selccs:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add code[@val2], r0, r1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add code[@val], r0, stack-[1]
@@ -564,7 +564,7 @@ define void @selccs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selscs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selscs:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add code[@val], r0, r1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add r1, r0, stack-[2]
@@ -584,7 +584,7 @@ define void @selscs(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selrss(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selrss:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, stack-[2]
 ; CHECK-NEXT:    add.lt r1, r0, stack-[2]
@@ -602,7 +602,7 @@ define void @selrss(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @seliss(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: seliss:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, stack-[2]
 ; CHECK-NEXT:    add.lt 42, r0, stack-[2]
@@ -620,7 +620,7 @@ define void @seliss(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selcss(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selcss:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add code[@val], r0, r1
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[1], r0, stack-[2]
@@ -640,7 +640,7 @@ define void @selcss(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 define void @selsss(i256 %v1, i256 %v2, i256 %v3, i256 %v4) {
 ; CHECK-LABEL: selsss:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[3 + r0]
+; CHECK-NEXT:    incsp 3
 ; CHECK-NEXT:    sub! r3, r4, r0
 ; CHECK-NEXT:    add stack-[2], r0, r1
 ; CHECK-NEXT:    add.lt stack-[1], r0, r1
diff --git a/llvm/test/CodeGen/EraVM/selectcc_fatptr.ll b/llvm/test/CodeGen/EraVM/selectcc_fatptr.ll
index c8b13fb841d4..ae31f9cbf7bb 100644
--- a/llvm/test/CodeGen/EraVM/selectcc_fatptr.ll
+++ b/llvm/test/CodeGen/EraVM/selectcc_fatptr.ll
@@ -7,8 +7,8 @@ target datalayout = "E-p:256:256-i256:256:256-S32"
 define i256 addrspace(3)* @selrrr(i256 addrspace(3)* %ptr1, i256 addrspace(3)* %ptr2, i256 %v3, i256 %v4) {
   ; CHECK: sub! r3, r4, r{{[0-9]+}}
   %1 = icmp eq i256 %v3, %v4
-  ; CHECK: ptr.add
-  ; CHECK: ptr.add.eq
+  ; CHECK: addp
+  ; CHECK: addp.eq
   %2 = select i1 %1, i256 addrspace(3)* %ptr1, i256 addrspace(3)* %ptr2
   ret i256 addrspace(3)* %2
 }
diff --git a/llvm/test/CodeGen/EraVM/separate-const-offset-from-gep-bug.ll b/llvm/test/CodeGen/EraVM/separate-const-offset-from-gep-bug.ll
index d471fb3ff6f6..2900a4968684 100644
--- a/llvm/test/CodeGen/EraVM/separate-const-offset-from-gep-bug.ll
+++ b/llvm/test/CodeGen/EraVM/separate-const-offset-from-gep-bug.ll
@@ -11,8 +11,8 @@ define void @test(ptr addrspace(1) %0, ptr addrspace(1) %1, i256 %2) {
 ; CHECK:       sub.s! 32, r3, r3
 ; CHECK-NEXT:  add r3, r1, r4
 ; CHECK-NEXT:  add r3, r2, r5
-; CHECK-NEXT:  ld.1 r5, r5
-; CHECK-NEXT:  st.1 r4, r5
+; CHECK-NEXT:  ldm.h r5, r5
+; CHECK-NEXT:  stm.h r4, r5
 ; CHECK-NEXT:  jump.ne @.BB0_1
 ; CHECK:       .BB0_2:
 ; CHECK-NEXT:  ret
diff --git a/llvm/test/CodeGen/EraVM/stack-address.ll b/llvm/test/CodeGen/EraVM/stack-address.ll
index dc896d65935b..7df3ff423e84 100644
--- a/llvm/test/CodeGen/EraVM/stack-address.ll
+++ b/llvm/test/CodeGen/EraVM/stack-address.ll
@@ -7,7 +7,7 @@ target triple = "eravm"
 
 ; CHECK-LABEL: alloca
 define void @alloca(i256 %a1, i256 %a2, i256 %a3, i256 %a4) nounwind {
-  ; CHECK: nop stack+=[4 + r0]
+  ; CHECK: incsp 4
   %var1 = alloca i256
   %var2 = alloca i256
   %var3 = alloca i256
@@ -60,30 +60,30 @@ fail:
 
 ; CHECK-LABEL: stack.obj.passing
 define i256 @stack.obj.passing() {
-; CHECK: nop stack+=[12 + r0]
+; CHECK: incsp 12
   %unused1 = alloca [3 x i256]
   %par1 = alloca i256
   %unused2 = alloca [2 x i256]
   %elem.cont = alloca [2 x i256]
   %arr = alloca [4 x i256]
   %elem = getelementptr [2 x i256], [2 x i256]* %elem.cont, i256 0, i256 0
-; CHECK: context.sp r1
+; CHECK: sp r1
 ; CHECK: sub.s 9, r1, r1
 ; CHECK: shl.s 5, r1, r1
-; CHECK: context.sp r2
+; CHECK: sp r2
 ; CHECK: sub.s 4, r2, r2
 ; CHECK: shl.s 5, r2, r2
-; CHECK: context.sp r3
+; CHECK: sp r3
 ; CHECK: sub.s 6, r3, r3
 ; CHECK: shl.s 5, r3, r3
-; CHECK: near_call	r0, @stack.obj.accessing, @DEFAULT_UNWIND
+; CHECK: call	r0, @stack.obj.accessing, @DEFAULT_UNWIND
   %res = call i256 @stack.obj.accessing(i256* %par1, [4 x i256]* %arr, i256* %elem)
   ret i256 %res
 }
 
 ; CHECK-LABEL: load_fat_ptr
 define void @load_fat_ptr(i8 addrspace(3)** %ptr) {
-; CHECK: ptr.add stack[r1], r0, stack[@fatptr]
+; CHECK: addp stack[r1], r0, stack[@fatptr]
   %val = load i8 addrspace(3)*, i8 addrspace(3)** %ptr, align 32
   store i8 addrspace(3)* %val, i8 addrspace(3)** @fatptr
   ret void
@@ -91,7 +91,7 @@ define void @load_fat_ptr(i8 addrspace(3)** %ptr) {
 
 ; CHECK-LABEL: store_fat_ptr
 define void @store_fat_ptr(i8 addrspace(3)** %ptr) {
-; CHECK: ptr.add stack[@fatptr], r0, stack[r1]
+; CHECK: addp stack[@fatptr], r0, stack[r1]
   %val = load i8 addrspace(3)*, i8 addrspace(3)** @fatptr, align 32
   store i8 addrspace(3)* %val, i8 addrspace(3)** %ptr
   ret void
diff --git a/llvm/test/CodeGen/EraVM/storage.ll b/llvm/test/CodeGen/EraVM/storage.ll
index 96b4cb0eccd9..c59b647f2851 100644
--- a/llvm/test/CodeGen/EraVM/storage.ll
+++ b/llvm/test/CodeGen/EraVM/storage.ll
@@ -5,7 +5,7 @@ target triple = "eravm"
 
 ; CHECK-LABEL: sstore_r
 define void @sstore_r(i256 %key, i256 %val) {
-; CHECK: sstore	r1, r2
+; CHECK: sts r1, r2
   %key_ptr = inttoptr i256 %key to ptr addrspace(5)
   store i256 %val, ptr addrspace(5) %key_ptr, align 64
   ret void
@@ -13,7 +13,7 @@ define void @sstore_r(i256 %key, i256 %val) {
 
 ; CHECK-LABEL: sload_rr
 define i256 @sload_rr(i256 %key) {
-; CHECK: sload r1, r1
+; CHECK: lds r1, r1
   %key_ptr = inttoptr i256 %key to ptr addrspace(5)
   %ret = load i256, ptr addrspace(5) %key_ptr, align 64
   ret i256 %ret
diff --git a/llvm/test/CodeGen/EraVM/transient.ll b/llvm/test/CodeGen/EraVM/transient.ll
index 080b873ddd52..78007f0f931c 100644
--- a/llvm/test/CodeGen/EraVM/transient.ll
+++ b/llvm/test/CodeGen/EraVM/transient.ll
@@ -5,7 +5,7 @@ target triple = "eravm"
 
 ; CHECK-LABEL: tstore_r
 define void @tstore_r(i256 %key, i256 %val) {
-; CHECK: tstore	r1, r2
+; CHECK: stt	r1, r2
   %key_ptr = inttoptr i256 %key to ptr addrspace(6)
   store i256 %val, ptr addrspace(6) %key_ptr, align 64
   ret void
@@ -13,7 +13,7 @@ define void @tstore_r(i256 %key, i256 %val) {
 
 ; CHECK-LABEL: tload_rr
 define i256 @tload_rr(i256 %key) {
-; CHECK: tload r1, r1
+; CHECK: ldt r1, r1
   %key_ptr = inttoptr i256 %key to ptr addrspace(6)
   %ret = load i256, ptr addrspace(6) %key_ptr, align 64
   ret i256 %ret
diff --git a/llvm/test/CodeGen/EraVM/uma.ll b/llvm/test/CodeGen/EraVM/uma.ll
index d15392b4bbdd..6c1c35dbca13 100644
--- a/llvm/test/CodeGen/EraVM/uma.ll
+++ b/llvm/test/CodeGen/EraVM/uma.ll
@@ -6,63 +6,63 @@ target triple = "eravm"
 
 ; CHECK-LABEL: uma.load_heap
 define i256 @uma.load_heap(i256 addrspace(1)* %ptr) nounwind {
-; CHECK: ld.1 r1, r1
+; CHECK: ldm.h r1, r1
   %val = load i256, i256 addrspace(1)* %ptr
   ret i256 %val
 }
 
 ; CHECK-LABEL: umai.load_heap
 define i256 @umai.load_heap() nounwind {
-; CHECK: ld.1 42, r1
+; CHECK: ldm.h 42, r1
   %val = load i256, i256 addrspace(1)* inttoptr (i256 42 to i256 addrspace(1)*)
   ret i256 %val
 }
 
 ; CHECK-LABEL: uma.load_heapaux
 define i256 @uma.load_heapaux(i256 addrspace(2)* %ptr) nounwind {
-; CHECK: ld.2 r1, r1
+; CHECK: ldm.ah r1, r1
   %val = load i256, i256 addrspace(2)* %ptr
   ret i256 %val
 }
 
 ; CHECK-LABEL: umai.load_heapaux
 define i256 @umai.load_heapaux(i256 addrspace(2)* %ptr) nounwind {
-; CHECK: ld.2 42, r1
+; CHECK: ldm.ah 42, r1
   %val = load i256, i256 addrspace(2)* inttoptr (i256 42 to i256 addrspace(2)*)
   ret i256 %val
 }
 
 ; CHECK-LABEL: uma.load_generic
 define i256 @uma.load_generic(i256 addrspace(3)* %ptr) nounwind {
-; CHECK: ld r1, r1
+; CHECK: ldp r1, r1
   %val = load i256, i256 addrspace(3)* %ptr
   ret i256 %val
 }
 
 ; CHECK-LABEL: uma.store_heap
 define void @uma.store_heap(i256 %val, i256 addrspace(1)* %ptr) nounwind {
-; CHECK: st.1 r2, r1
+; CHECK: stm.h r2, r1
   store i256 %val, i256 addrspace(1)* %ptr, align 1
   ret void
 }
 
 ; CHECK-LABEL: umai.store_heap
 define void @umai.store_heap(i256 %val) nounwind {
-; CHECK: st.1 42, r1
+; CHECK: stm.h 42, r1
   store i256 %val, i256 addrspace(1)* inttoptr (i256 42 to i256 addrspace(1)*), align 1
   ret void
 }
 
 ; CHECK-LABEL: uma.store_heapaux
 define void @uma.store_heapaux(i256 %val, i256 addrspace(2)* %ptr) nounwind {
-; CHECK: st.2 r2, r1
+; CHECK: stm.ah r2, r1
   store i256 %val, i256 addrspace(2)* %ptr, align 1
   ret void
 }
 
 ; CHECK-LABEL: umai.store_heapaux
 define void @umai.store_heapaux(i256 %val) nounwind {
-; CHECK: st.2 42, r1
+; CHECK: stm.ah 42, r1
   store i256 %val, i256 addrspace(2)* inttoptr (i256 42 to i256 addrspace(2)*), align 1
   ret void
 }
@@ -70,8 +70,8 @@ define void @umai.store_heapaux(i256 %val) nounwind {
 ; CHECK-LABEL: st1inc
 define void @st1inc(i256 addrspace(1)* %addr, i256 %val) nounwind {
  store i256 %val, i256 addrspace(1)* %addr
-; CHECK: st.1.inc r1, r2, r1
-; CHECK: st.1 r1, r2
+; CHECK: stmi.h r1, r2, r1
+; CHECK: stm.h r1, r2
  %newaddr1 = getelementptr i256, i256 addrspace(1)* %addr, i256 1
  %na1 = add i256 %val, 1024
  store i256 %na1, i256 addrspace(1)* %newaddr1
@@ -81,8 +81,8 @@ define void @st1inc(i256 addrspace(1)* %addr, i256 %val) nounwind {
 ; CHECK-LABEL: st2inc
 define void @st2inc(i256 addrspace(2)* %addr, i256 %val) nounwind {
  store i256 %val, i256 addrspace(2)* %addr
-; CHECK: st.2.inc r1, r2, r1
-; CHECK: st.2 r1, r2
+; CHECK: stmi.ah r1, r2, r1
+; CHECK: stm.ah r1, r2
  %newaddr1 = getelementptr i256, i256 addrspace(2)* %addr, i256 1
  %na1 = add i256 %val, 1024
  store i256 %na1, i256 addrspace(2)* %newaddr1
@@ -91,8 +91,8 @@ define void @st2inc(i256 addrspace(2)* %addr, i256 %val) nounwind {
 
 ; CHECK-LABEL: ldinc
 define i256 @ldinc(i256 addrspace(3)* %addr) nounwind {
-; CHECK: ld.inc r1, r1, r2
-; CHECK: ld r2, r2
+; CHECK: ldpi r1, r1, r2
+; CHECK: ldp r2, r2
  %val = load i256, i256 addrspace(3)* %addr
  %newaddr1 = getelementptr i256, i256 addrspace(3)* %addr, i256 1
  %val1 = load i256, i256 addrspace(3)* %newaddr1
@@ -102,8 +102,8 @@ define i256 @ldinc(i256 addrspace(3)* %addr) nounwind {
 
 ; CHECK-LABEL: ld1inc
 define i256 @ld1inc(i256 addrspace(1)* %addr) nounwind {
-; CHECK: ld.1.inc r1, r1, r2
-; CHECK: ld.1 r2, r2
+; CHECK: ldmi.h r1, r1, r2
+; CHECK: ldm.h r2, r2
  %val = load i256, i256 addrspace(1)* %addr
  %newaddr1 = getelementptr i256, i256 addrspace(1)* %addr, i256 1
  %val1 = load i256, i256 addrspace(1)* %newaddr1
@@ -113,8 +113,8 @@ define i256 @ld1inc(i256 addrspace(1)* %addr) nounwind {
 
 ; CHECK-LABEL: ld2inc
 define i256 @ld2inc(i256 addrspace(2)* %addr) nounwind {
-; CHECK: ld.2.inc r1, r1, r2
-; CHECK: ld.2 r2, r2
+; CHECK: ldmi.ah r1, r1, r2
+; CHECK: ldm.ah r2, r2
  %val = load i256, i256 addrspace(2)* %addr
  %newaddr1 = getelementptr i256, i256 addrspace(2)* %addr, i256 1
  %val1 = load i256, i256 addrspace(2)* %newaddr1
diff --git a/llvm/test/CodeGen/EraVM/zeroinitializer.ll b/llvm/test/CodeGen/EraVM/zeroinitializer.ll
index c7c3f50acabf..cfaccceb0746 100644
--- a/llvm/test/CodeGen/EraVM/zeroinitializer.ll
+++ b/llvm/test/CodeGen/EraVM/zeroinitializer.ll
@@ -6,7 +6,7 @@ target triple = "eravm-unknown-unknown"
 ; CHECK-LABEL: zeroinit_fatptr
 define void @zeroinit_fatptr() {
 entry:
-  ; CHECK: nop stack+=[2 + r0]
+  ; CHECK: incsp 2
   %ptr = alloca { i8 addrspace(3)*, i1 }
   ; TODO: CPR-888 Codegen for store to stack-[1] is incorrect
   ; CHECK: add 0, r0, stack-[2]
diff --git a/llvm/test/MC/EraVM/asm-parser/arith-instructions-errors.s b/llvm/test/MC/EraVM/asm-parser/arith-instructions-errors.s
index e471a82b22e5..8e1e9873141d 100644
--- a/llvm/test/MC/EraVM/asm-parser/arith-instructions-errors.s
+++ b/llvm/test/MC/EraVM/asm-parser/arith-instructions-errors.s
@@ -30,17 +30,11 @@
   mul.s     42, r2, r3, r4
 
 ; non-arithmetic suffixes should be rejected
-  add.first     r1, r2, r3
-  add.static    r1, r2, r3
-  add.shard     r1, r2, r3
-  add.delegate  r1, r2, r3
-  add.mimic     r1, r2, r3
-  add.caller    r1, r2, r3
-  add.sp        r1, r2, r3
-  add.1         r1, r2, r3
-  add.1.inc     r1, r2, r3
-  add.inc       r1, r2, r3
-  add.to_label  r1, r2, r3
+  add.i     r1, r2, r3
+  add.st    r1, r2, r3
+  add.sh    r1, r2, r3
+  add.h     r1, r2, r3
+  add.ah    r1, r2, r3
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
@@ -85,36 +79,18 @@
 ; CHECK:       <stdin>:{{[0-9]+}}:13: error: cannot parse operand
 ; CHECK-NEXT:    mul.s     42, r2, r3, r4
 ; CHECK-NEXT:              ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.first
-; CHECK-NEXT:    add.first     r1, r2, r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.i
+; CHECK-NEXT:    add.i     r1, r2, r3
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.static
-; CHECK-NEXT:    add.static    r1, r2, r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.st
+; CHECK-NEXT:    add.st    r1, r2, r3
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.shard
-; CHECK-NEXT:    add.shard     r1, r2, r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.sh
+; CHECK-NEXT:    add.sh    r1, r2, r3
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.delegate
-; CHECK-NEXT:    add.delegate  r1, r2, r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.h
+; CHECK-NEXT:    add.h     r1, r2, r3
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.mimic
-; CHECK-NEXT:    add.mimic     r1, r2, r3
-; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.caller
-; CHECK-NEXT:    add.caller    r1, r2, r3
-; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.sp
-; CHECK-NEXT:    add.sp        r1, r2, r3
-; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.1
-; CHECK-NEXT:    add.1         r1, r2, r3
-; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.1.inc
-; CHECK-NEXT:    add.1.inc     r1, r2, r3
-; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.inc
-; CHECK-NEXT:    add.inc       r1, r2, r3
-; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.to_label
-; CHECK-NEXT:    add.to_label  r1, r2, r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: add.ah
+; CHECK-NEXT:    add.ah    r1, r2, r3
 ; CHECK-NEXT:    ^
diff --git a/llvm/test/MC/EraVM/asm-parser/events.s b/llvm/test/MC/EraVM/asm-parser/events.s
index 7f9759bb69e5..7d1695aec199 100644
--- a/llvm/test/MC/EraVM/asm-parser/events.s
+++ b/llvm/test/MC/EraVM/asm-parser/events.s
@@ -4,27 +4,27 @@
 foo:
 
 ; mnemonics
-  event           r3, r4
-  event.first     r3, r4
-  to_l1           r3, r4
-  to_l1.first     r3, r4
+  log           r3, r4
+  log.i         r3, r4
+  logL1         r3, r4
+  logL1.i       r3, r4
 
 ; modifiers (condition)
-  event.lt        r3, r4
-  event.first.lt  r3, r4
-  to_l1.lt        r3, r4
-  to_l1.first.lt  r3, r4
+  log.lt        r3, r4
+  log.i.lt      r3, r4
+  logL1.lt      r3, r4
+  logL1.i.lt    r3, r4
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  event        r3, r4
-; CHECK:  event.first  r3, r4
-; CHECK:  to_l1        r3, r4
-; CHECK:  to_l1.first  r3, r4
+; CHECK:  log           r3, r4
+; CHECK:  log.i         r3, r4
+; CHECK:  logL1         r3, r4
+; CHECK:  logL1.i       r3, r4
 
-; CHECK:  event.lt     r3, r4
-; CHECK:  event.first.lt       r3, r4
-; CHECK:  to_l1.lt     r3, r4
-; CHECK:  to_l1.first.lt       r3, r4
+; CHECK:  log.lt        r3, r4
+; CHECK:  log.i.lt      r3, r4
+; CHECK:  logL1.lt      r3, r4
+; CHECK:  logL1.i.lt    r3, r4
diff --git a/llvm/test/MC/EraVM/asm-parser/far-calls.s b/llvm/test/MC/EraVM/asm-parser/far-calls.s
index caa53e30dcc5..ec6d5959251f 100644
--- a/llvm/test/MC/EraVM/asm-parser/far-calls.s
+++ b/llvm/test/MC/EraVM/asm-parser/far-calls.s
@@ -4,78 +4,78 @@
 foo:
 
 ; modifiers (condition)
-  far_call                 r3, r4, @handler
-  far_call.delegate             r3, r4, @handler
-  far_call.mimic                r3, r4, @handler
-  far_call.lt              r3, r4, @handler
-  far_call.delegate.lt          r3, r4, @handler
-  far_call.mimic.lt             r3, r4, @handler
+  callf             r3, r4, @handler
+  calld             r3, r4, @handler
+  callm             r3, r4, @handler
+  callf.lt          r3, r4, @handler
+  calld.lt          r3, r4, @handler
+  callm.lt          r3, r4, @handler
 
-  far_call.static          r3, r4, @handler
-  far_call.delegate.static      r3, r4, @handler
-  far_call.mimic.static         r3, r4, @handler
-  far_call.static.lt       r3, r4, @handler
-  far_call.delegate.static.lt   r3, r4, @handler
-  far_call.mimic.static.lt      r3, r4, @handler
+  callf.st          r3, r4, @handler
+  calld.st          r3, r4, @handler
+  callm.st          r3, r4, @handler
+  callf.st.lt       r3, r4, @handler
+  calld.st.lt       r3, r4, @handler
+  callm.st.lt       r3, r4, @handler
 
-  far_call.shard           r3, r4, @handler
-  far_call.delegate.shard       r3, r4, @handler
-  far_call.mimic.shard          r3, r4, @handler
-  far_call.shard.lt        r3, r4, @handler
-  far_call.delegate.shard.lt    r3, r4, @handler
-  far_call.mimic.shard.lt       r3, r4, @handler
+  callf.sh          r3, r4, @handler
+  calld.sh          r3, r4, @handler
+  callm.sh          r3, r4, @handler
+  callf.sh.lt       r3, r4, @handler
+  calld.sh.lt       r3, r4, @handler
+  callm.sh.lt       r3, r4, @handler
 
-  far_call.st.sh           r3, r4, @handler
-  far_call.delegate.st.sh       r3, r4, @handler
-  far_call.mimic.st.sh          r3, r4, @handler
-  far_call.st.sh.lt        r3, r4, @handler
-  far_call.delegate.st.sh.lt    r3, r4, @handler
-  far_call.mimic.st.sh.lt       r3, r4, @handler
+  callf.st.sh       r3, r4, @handler
+  calld.st.sh       r3, r4, @handler
+  callm.st.sh       r3, r4, @handler
+  callf.st.sh.lt    r3, r4, @handler
+  calld.st.sh.lt    r3, r4, @handler
+  callm.st.sh.lt    r3, r4, @handler
 
 ; .st and .sh can be passed in any order (but predicate is the last modifier,
 ; as with any other instruction)
-  far_call.sh.st                r3, r4, @handler
-  far_call.sh.st.lt             r3, r4, @handler
-  far_call.delegate.sh.st       r3, r4, @handler
-  far_call.delegate.sh.st.lt    r3, r4, @handler
-  far_call.mimic.sh.st          r3, r4, @handler
-  far_call.mimic.sh.st.lt       r3, r4, @handler
+  callf.sh.st       r3, r4, @handler
+  callf.sh.st.lt    r3, r4, @handler
+  calld.sh.st       r3, r4, @handler
+  calld.sh.st.lt    r3, r4, @handler
+  callm.sh.st       r3, r4, @handler
+  callm.sh.st.lt    r3, r4, @handler
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  far_call     r3, r4, @handler
-; CHECK:  far_call.delegate r3, r4, @handler
-; CHECK:  far_call.mimic    r3, r4, @handler
-; CHECK:  far_call.lt  r3, r4, @handler
-; CHECK:  far_call.delegate.lt      r3, r4, @handler
-; CHECK:  far_call.mimic.lt r3, r4, @handler
+; CHECK:  callf             r3, r4, @handler
+; CHECK:  calld             r3, r4, @handler
+; CHECK:  callm             r3, r4, @handler
+; CHECK:  callf.lt          r3, r4, @handler
+; CHECK:  calld.lt          r3, r4, @handler
+; CHECK:  callm.lt          r3, r4, @handler
 
-; CHECK:  far_call.static      r3, r4, @handler
-; CHECK:  far_call.delegate.static  r3, r4, @handler
-; CHECK:  far_call.mimic.static     r3, r4, @handler
-; CHECK:  far_call.static.lt   r3, r4, @handler
-; CHECK:  far_call.delegate.static.lt       r3, r4, @handler
-; CHECK:  far_call.mimic.static.lt  r3, r4, @handler
+; CHECK:  callf.st          r3, r4, @handler
+; CHECK:  calld.st          r3, r4, @handler
+; CHECK:  callm.st          r3, r4, @handler
+; CHECK:  callf.st.lt       r3, r4, @handler
+; CHECK:  calld.st.lt       r3, r4, @handler
+; CHECK:  callm.st.lt       r3, r4, @handler
 
-; CHECK:  far_call.shard       r3, r4, @handler
-; CHECK:  far_call.delegate.shard   r3, r4, @handler
-; CHECK:  far_call.mimic.shard      r3, r4, @handler
-; CHECK:  far_call.shard.lt    r3, r4, @handler
-; CHECK:  far_call.delegate.shard.lt        r3, r4, @handler
-; CHECK:  far_call.mimic.shard.lt   r3, r4, @handler
+; CHECK:  callf.sh          r3, r4, @handler
+; CHECK:  calld.sh          r3, r4, @handler
+; CHECK:  callm.sh          r3, r4, @handler
+; CHECK:  callf.sh.lt       r3, r4, @handler
+; CHECK:  calld.sh.lt       r3, r4, @handler
+; CHECK:  callm.sh.lt       r3, r4, @handler
 
-; CHECK:  far_call.st.sh       r3, r4, @handler
-; CHECK:  far_call.delegate.st.sh   r3, r4, @handler
-; CHECK:  far_call.mimic.st.sh      r3, r4, @handler
-; CHECK:  far_call.st.sh.lt    r3, r4, @handler
-; CHECK:  far_call.delegate.st.sh.lt        r3, r4, @handler
-; CHECK:  far_call.mimic.st.sh.lt   r3, r4, @handler
+; CHECK:  callf.st.sh       r3, r4, @handler
+; CHECK:  calld.st.sh       r3, r4, @handler
+; CHECK:  callm.st.sh       r3, r4, @handler
+; CHECK:  callf.st.sh.lt    r3, r4, @handler
+; CHECK:  calld.st.sh.lt    r3, r4, @handler
+; CHECK:  callm.st.sh.lt    r3, r4, @handler
 
-; CHECK:  far_call.st.sh                r3, r4, @handler
-; CHECK:  far_call.st.sh.lt             r3, r4, @handler
-; CHECK:  far_call.delegate.st.sh       r3, r4, @handler
-; CHECK:  far_call.delegate.st.sh.lt    r3, r4, @handler
-; CHECK:  far_call.mimic.st.sh          r3, r4, @handler
-; CHECK:  far_call.mimic.st.sh.lt       r3, r4, @handler
+; CHECK:  callf.st.sh       r3, r4, @handler
+; CHECK:  callf.st.sh.lt    r3, r4, @handler
+; CHECK:  calld.st.sh       r3, r4, @handler
+; CHECK:  calld.st.sh.lt    r3, r4, @handler
+; CHECK:  callm.st.sh       r3, r4, @handler
+; CHECK:  callm.st.sh.lt    r3, r4, @handler
diff --git a/llvm/test/MC/EraVM/asm-parser/far-returns.s b/llvm/test/MC/EraVM/asm-parser/far-returns.s
index 10597510b746..55e392e723ec 100644
--- a/llvm/test/MC/EraVM/asm-parser/far-returns.s
+++ b/llvm/test/MC/EraVM/asm-parser/far-returns.s
@@ -4,23 +4,23 @@
 foo:
 
 ; mnemonics
-  ret.ok      r3
-  ret.revert  r3
-  panic
+  ret  r3
+  rev  r3
+  pnc
 
 ; modifiers (condition, not testing aliases)
-  ret.ok.lt      r3
-  ret.revert.lt   r3
-  panic.lt
+  ret.lt   r3
+  rev.lt   r3
+  pnc.lt
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  ret.ok  r3
-; CHECK:  ret.revert       r3
-; CHECK:  panic
+; CHECK:  ret       r3
+; CHECK:  rev       r3
+; CHECK:  pnc
 
-; CHECK:  ret.ok.lt       r3
-; CHECK:  ret.revert.lt    r3
-; CHECK:  panic.lt
+; CHECK:  ret.lt    r3
+; CHECK:  rev.lt    r3
+; CHECK:  pnc.lt
diff --git a/llvm/test/MC/EraVM/asm-parser/misc-operands-errors.s b/llvm/test/MC/EraVM/asm-parser/misc-operands-errors.s
index bd195fe080ec..969beb16e6af 100644
--- a/llvm/test/MC/EraVM/asm-parser/misc-operands-errors.s
+++ b/llvm/test/MC/EraVM/asm-parser/misc-operands-errors.s
@@ -6,70 +6,92 @@
 
 ; reject integer literals as immediate jump targets
   jump 42
-  near_call r1, 42
-  near_call r1, @foo, 42
-  far_call r1, r2, 42
+  call r1, 42
+  call r1, @foo, 42
+  callf r1, r2, 42
 
 ; reject 2-operand far calls
-  far_call             r3, r4
-  far_call.static      r3, r4
-  far_call.shard       r3, r4
-  far_call.st.sh       r3, r4
-  far_call.delegate         r3, r4
-  far_call.delegate.static  r3, r4
-  far_call.delegate.shard   r3, r4
-  far_call.delegate.st.sh   r3, r4
-  far_call.mimic            r3, r4
-  far_call.mimic.static     r3, r4
-  far_call.mimic.shard      r3, r4
-  far_call.mimic.st.sh      r3, r4
+  callf          r3, r4
+  callf.st       r3, r4
+  callf.sh       r3, r4
+  callf.st.sh    r3, r4
+  calld          r3, r4
+  calld.st       r3, r4
+  calld.sh       r3, r4
+  calld.st.sh    r3, r4
+  callm          r3, r4
+  callm.st       r3, r4
+  callm.sh       r3, r4
+  callm.st.sh    r3, r4
+
+; incsp and decsp require custom parsing
+  incsp
+  incsp stack-=[1]
+  incsp stack+=[1]
+  incsp r1, 42  ; reg and imm should be separated with "+"
+  incsp 42 + r1 ; not supported yet
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:       <stdin>:{{[0-9]+}}:8: error: cannot parse operand
 ; CHECK-NEXT:    jump 42
 ; CHECK-NEXT:         ^
+; CHECK:       <stdin>:{{[0-9]+}}:12: error: cannot parse operand
+; CHECK-NEXT:    call r1, 42
+; CHECK-NEXT:             ^
+; CHECK:       <stdin>:{{[0-9]+}}:18: error: cannot parse operand
+; CHECK-NEXT:    call r1, @foo, 42
+; CHECK-NEXT:                   ^
 ; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    near_call r1, 42
+; CHECK-NEXT:    callf r1, r2, 42
 ; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:23: error: cannot parse operand
-; CHECK-NEXT:    near_call r1, @foo, 42
-; CHECK-NEXT:                        ^
-; CHECK:       <stdin>:{{[0-9]+}}:20: error: cannot parse operand
-; CHECK-NEXT:    far_call r1, r2, 42
-; CHECK-NEXT:                     ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call             r3, r4
+; CHECK-NEXT:    callf          r3, r4
+; CHECK-NEXT:    ^
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
+; CHECK-NEXT:    callf.st       r3, r4
+; CHECK-NEXT:    ^
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
+; CHECK-NEXT:    callf.sh       r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.static      r3, r4
+; CHECK-NEXT:    callf.st.sh    r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.shard       r3, r4
+; CHECK-NEXT:    calld          r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.st.sh       r3, r4
+; CHECK-NEXT:    calld.st       r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.delegate         r3, r4
+; CHECK-NEXT:    calld.sh       r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.delegate.static  r3, r4
+; CHECK-NEXT:    calld.st.sh    r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.delegate.shard   r3, r4
+; CHECK-NEXT:    callm          r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.delegate.st.sh   r3, r4
+; CHECK-NEXT:    callm.st       r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.mimic            r3, r4
+; CHECK-NEXT:    callm.sh       r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.mimic.static     r3, r4
+; CHECK-NEXT:    callm.st.sh    r3, r4
 ; CHECK-NEXT:    ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.mimic.shard      r3, r4
+; CHECK-NEXT:    incsp
 ; CHECK-NEXT:    ^
+; CHECK:       <stdin>:{{[0-9]+}}:9: error: cannot parse register
+; CHECK-NEXT:    incsp stack-=[1]
+; CHECK-NEXT:          ^
+; CHECK:       <stdin>:{{[0-9]+}}:9: error: cannot parse register
+; CHECK-NEXT:    incsp stack+=[1]
+; CHECK-NEXT:          ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: unexpected token
+; CHECK-NEXT:    incsp r1, 42  ; reg and imm should be separated with "+"
+; CHECK-NEXT:            ^
 ; CHECK:       <stdin>:{{[0-9]+}}:3: error: cannot parse instruction
-; CHECK-NEXT:    far_call.mimic.st.sh      r3, r4
+; CHECK-NEXT:    incsp 42 + r1 ; not supported yet
 ; CHECK-NEXT:    ^
diff --git a/llvm/test/MC/EraVM/asm-parser/misc.s b/llvm/test/MC/EraVM/asm-parser/misc.s
index 2aefcab154d8..6aba239a890f 100644
--- a/llvm/test/MC/EraVM/asm-parser/misc.s
+++ b/llvm/test/MC/EraVM/asm-parser/misc.s
@@ -4,60 +4,60 @@
 foo:
 
 ; mnemonics
-  log.decommit  r3, r4, r5
-  precompile    r3, r4, r5
-  context.this                  r3
-  context.caller                r3
-  context.code_source           r3
-  context.gas_left              r3
-  context.sp                    r3
-  context.get_context_u128      r3
-  context.set_context_u128      r3
-  context.meta                  r3
-  context.inc_tx_num
-  context.set_gas_per_pubdata   r3
+  dcmt      r3, r4, r5
+  callp     r3, r4, r5
+  this      r3
+  par       r3
+  code      r3
+  ergs      r3
+  sp        r3
+  ldvl      r3
+  stvl      r3
+  meta      r3
+  inctx
+  stpub     r3  ; removed in VM 1.5.0
 
 ; modifiers (condition)
-  log.decommit.lt  r3, r4, r5
-  precompile.lt    r3, r4, r5
-  context.this.lt                  r3
-  context.caller.lt                r3
-  context.code_source.lt           r3
-  context.gas_left.lt              r3
-  context.sp.lt                    r3
-  context.get_context_u128.lt      r3
-  context.set_context_u128.lt      r3
-  context.meta.lt                  r3
-  context.inc_tx_num.lt
-  context.set_gas_per_pubdata.lt   r3
+  dcmt.lt   r3, r4, r5
+  callp.lt  r3, r4, r5
+  this.lt   r3
+  par.lt    r3
+  code.lt   r3
+  ergs.lt   r3
+  sp.lt     r3
+  ldvl.lt   r3
+  stvl.lt   r3
+  meta.lt   r3
+  inctx.lt
+  stpub.lt  r3  ; removed in VM 1.5.0
 
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  log.decommit  r3, r4, r5
-; CHECK:  precompile    r3, r4, r5
-; CHECK:  context.this r3
-; CHECK:  context.caller       r3
-; CHECK:  context.code_source  r3
-; CHECK:  context.gas_left     r3
-; CHECK:  context.sp   r3
-; CHECK:  context.get_context_u128     r3
-; CHECK:  context.set_context_u128     r3
-; CHECK:  context.meta r3
-; CHECK:  context.inc_tx_num
-; CHECK:  context.set_gas_per_pubdata  r3
+; CHECK:  dcmt      r3, r4, r5
+; CHECK:  callp     r3, r4, r5
+; CHECK:  this      r3
+; CHECK:  par       r3
+; CHECK:  code      r3
+; CHECK:  ergs      r3
+; CHECK:  sp        r3
+; CHECK:  ldvl      r3
+; CHECK:  stvl      r3
+; CHECK:  meta      r3
+; CHECK:  inctx
+; CHECK:  stpub     r3
 
-; CHECK:  log.decommit.lt      r3, r4, r5
-; CHECK:  precompile.lt        r3, r4, r5
-; CHECK:  context.this.lt      r3
-; CHECK:  context.caller.lt    r3
-; CHECK:  context.code_source.lt       r3
-; CHECK:  context.gas_left.lt  r3
-; CHECK:  context.sp.lt        r3
-; CHECK:  context.get_context_u128.lt  r3
-; CHECK:  context.set_context_u128.lt  r3
-; CHECK:  context.meta.lt      r3
-; CHECK:  context.inc_tx_num.lt
-; CHECK:  context.set_gas_per_pubdata.lt       r3
+; CHECK:  dcmt.lt   r3, r4, r5
+; CHECK:  callp.lt  r3, r4, r5
+; CHECK:  this.lt   r3
+; CHECK:  par.lt    r3
+; CHECK:  code.lt   r3
+; CHECK:  ergs.lt   r3
+; CHECK:  sp.lt     r3
+; CHECK:  ldvl.lt   r3
+; CHECK:  stvl.lt   r3
+; CHECK:  meta.lt   r3
+; CHECK:  inctx.lt
+; CHECK:  stpub.lt  r3
diff --git a/llvm/test/MC/EraVM/asm-parser/mnemonic-errors.s b/llvm/test/MC/EraVM/asm-parser/mnemonic-errors.s
index 35166999d91c..b635297fca72 100644
--- a/llvm/test/MC/EraVM/asm-parser/mnemonic-errors.s
+++ b/llvm/test/MC/EraVM/asm-parser/mnemonic-errors.s
@@ -37,27 +37,34 @@
   sub.s!!.lt     42, r2, r3
 
 ; invalid instruction-specific modifiers
-  event.abc          r3, r4
-  event.first.abc    r3, r4
-  event.first.first  r3, r4
-  to_l1.abc          r3, r4
-  to_l1.first.abc    r3, r4
-  to_l1.first.first  r3, r4
-  context            r3
-  context.sp.sp      r3
-  context.sp.abc     r3
-  context.abc        r3
+  log.abc            r3, r4
+  log.i.abc          r3, r4
+  log.i.i            r3, r4
+  logL1.abc          r3, r4
+  logL1.i.abc        r3, r4
+  logL1.i.i          r3, r4
+  callf.abc          r3, r4, @foo
+
+; missing mandatory modifier
+  ldm                r1, r2
+  ldmi               r1, r2, r3
+  stm                r1, r2
+  stmi               r1, r2, r3
+; multiple modifiers
+  ldm.h.st           r1, r2
+  ldm.h.ah           r1, r2
+  ldm.st.h           r1, r2
 
 ; Modifiers specific to far calls
-  far_call .st.sh    r1, r2, @foo ; unexpected space
-  far_call. st.sh    r1, r2, @foo ; unexpected space
-  far_call.st .sh    r1, r2, @foo ; unexpected space
-  far_call.st.sh .lt r1, r2, @foo ; unexpected space
-  far_call.lt.st.sh  r1, r2, @foo ; invalid position of predicate
-  far_call.st.lt.sh  r1, r2, @foo ; invalid position of predicate
-  far_call.st.st.sh  r1, r2, @foo ; duplicated modifiers
-  far_call.sh.st.sh  r1, r2, @foo ; duplicated modifiers
-  far_call.st.st     r1, r2, @foo ; duplicated modifiers
+  callf .st.sh    r1, r2, @foo ; unexpected space
+  callf. st.sh    r1, r2, @foo ; unexpected space
+  callf.st .sh    r1, r2, @foo ; unexpected space
+  callf.st.sh .lt r1, r2, @foo ; unexpected space
+  callf.lt.st.sh  r1, r2, @foo ; invalid position of predicate
+  callf.st.lt.sh  r1, r2, @foo ; invalid position of predicate
+  callf.st.st.sh  r1, r2, @foo ; duplicated modifiers
+  callf.sh.st.sh  r1, r2, @foo ; duplicated modifiers
+  callf.st.st     r1, r2, @foo ; duplicated modifiers
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:       <stdin>:{{[0-9]+}}:10: error: cannot parse operand
@@ -120,60 +127,72 @@
 ; CHECK:       <stdin>:{{[0-9]+}}:9: error: cannot parse operand
 ; CHECK-NEXT:    sub.s!!.lt     42, r2, r3
 ; CHECK-NEXT:          ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: event.abc
-; CHECK-NEXT:    event.abc          r3, r4
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: log.abc
+; CHECK-NEXT:    log.abc            r3, r4
+; CHECK-NEXT:    ^
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: log.i.abc
+; CHECK-NEXT:    log.i.abc          r3, r4
+; CHECK-NEXT:    ^
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: log.i.i
+; CHECK-NEXT:    log.i.i            r3, r4
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: event.first.abc
-; CHECK-NEXT:    event.first.abc    r3, r4
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: logl1.abc
+; CHECK-NEXT:    logL1.abc          r3, r4
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: event.first.first
-; CHECK-NEXT:    event.first.first  r3, r4
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: logl1.i.abc
+; CHECK-NEXT:    logL1.i.abc        r3, r4
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: to_l1.abc
-; CHECK-NEXT:    to_l1.abc          r3, r4
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: logl1.i.i
+; CHECK-NEXT:    logL1.i.i          r3, r4
+; CHECK-NEXT:    ^
+; CHECK:       <stdin>:{{[0-9]+}}:30: error: cannot parse operand
+; CHECK-NEXT:    callf.abc          r3, r4, @foo
+; CHECK-NEXT:                               ^
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: ldm
+; CHECK-NEXT:    ldm                r1, r2
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: to_l1.first.abc
-; CHECK-NEXT:    to_l1.first.abc    r3, r4
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: ldmi
+; CHECK-NEXT:    ldmi               r1, r2, r3
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: to_l1.first.first
-; CHECK-NEXT:    to_l1.first.first  r3, r4
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: stm
+; CHECK-NEXT:    stm                r1, r2
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: context
-; CHECK-NEXT:    context            r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: stmi
+; CHECK-NEXT:    stmi               r1, r2, r3
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: context.sp.sp
-; CHECK-NEXT:    context.sp.sp      r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: ldm.h.st
+; CHECK-NEXT:    ldm.h.st           r1, r2
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: context.sp.abc
-; CHECK-NEXT:    context.sp.abc     r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: ldm.h.ah
+; CHECK-NEXT:    ldm.h.ah           r1, r2
 ; CHECK-NEXT:    ^
-; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: context.abc
-; CHECK-NEXT:    context.abc        r3
+; CHECK:       <stdin>:{{[0-9]+}}:3: error: unknown mnemonic: ldm.st.h
+; CHECK-NEXT:    ldm.st.h           r1, r2
 ; CHECK-NEXT:    ^
+; CHECK:       <stdin>:{{[0-9]+}}:9: error: cannot parse operand
+; CHECK-NEXT:    callf .st.sh    r1, r2, @foo ; unexpected space
+; CHECK-NEXT:          ^
+; CHECK:       <stdin>:{{[0-9]+}}:10: error: cannot parse operand
+; CHECK-NEXT:    callf. st.sh    r1, r2, @foo ; unexpected space
+; CHECK-NEXT:           ^
 ; CHECK:       <stdin>:{{[0-9]+}}:12: error: cannot parse operand
-; CHECK-NEXT:    far_call .st.sh    r1, r2, @foo ; unexpected space
+; CHECK-NEXT:    callf.st .sh    r1, r2, @foo ; unexpected space
 ; CHECK-NEXT:             ^
-; CHECK:       <stdin>:{{[0-9]+}}:13: error: cannot parse operand
-; CHECK-NEXT:    far_call. st.sh    r1, r2, @foo ; unexpected space
-; CHECK-NEXT:              ^
-; CHECK:       <stdin>:{{[0-9]+}}:15: error: cannot parse operand
-; CHECK-NEXT:    far_call.st .sh    r1, r2, @foo ; unexpected space
+; CHECK:       <stdin>:{{[0-9]+}}:15: error: unexpected whitespace before condition code
+; CHECK-NEXT:    callf.st.sh .lt r1, r2, @foo ; unexpected space
 ; CHECK-NEXT:                ^
-; CHECK:       <stdin>:{{[0-9]+}}:18: error: unexpected whitespace before condition code
-; CHECK-NEXT:    far_call.st.sh .lt r1, r2, @foo ; unexpected space
-; CHECK-NEXT:                   ^
-; CHECK:       <stdin>:{{[0-9]+}}:30: error: cannot parse operand
-; CHECK-NEXT:    far_call.lt.st.sh  r1, r2, @foo ; invalid position of predicate
-; CHECK-NEXT:                               ^
-; CHECK:       <stdin>:{{[0-9]+}}:30: error: cannot parse operand
-; CHECK-NEXT:    far_call.st.lt.sh  r1, r2, @foo ; invalid position of predicate
-; CHECK-NEXT:                               ^
-; CHECK:       <stdin>:{{[0-9]+}}:30: error: cannot parse operand
-; CHECK-NEXT:    far_call.st.st.sh  r1, r2, @foo ; duplicated modifiers
-; CHECK-NEXT:                               ^
-; CHECK:       <stdin>:{{[0-9]+}}:30: error: cannot parse operand
-; CHECK-NEXT:    far_call.sh.st.sh  r1, r2, @foo ; duplicated modifiers
-; CHECK-NEXT:                               ^
-; CHECK:       <stdin>:{{[0-9]+}}:30: error: cannot parse operand
-; CHECK-NEXT:    far_call.st.st     r1, r2, @foo ; duplicated modifiers
-; CHECK-NEXT:                               ^
+; CHECK:       <stdin>:{{[0-9]+}}:27: error: cannot parse operand
+; CHECK-NEXT:    callf.lt.st.sh  r1, r2, @foo ; invalid position of predicate
+; CHECK-NEXT:                            ^
+; CHECK:       <stdin>:{{[0-9]+}}:27: error: cannot parse operand
+; CHECK-NEXT:    callf.st.lt.sh  r1, r2, @foo ; invalid position of predicate
+; CHECK-NEXT:                            ^
+; CHECK:       <stdin>:{{[0-9]+}}:27: error: cannot parse operand
+; CHECK-NEXT:    callf.st.st.sh  r1, r2, @foo ; duplicated modifiers
+; CHECK-NEXT:                            ^
+; CHECK:       <stdin>:{{[0-9]+}}:27: error: cannot parse operand
+; CHECK-NEXT:    callf.sh.st.sh  r1, r2, @foo ; duplicated modifiers
+; CHECK-NEXT:                            ^
+; CHECK:       <stdin>:{{[0-9]+}}:27: error: cannot parse operand
+; CHECK-NEXT:    callf.st.st     r1, r2, @foo ; duplicated modifiers
+; CHECK-NEXT:                            ^
diff --git a/llvm/test/MC/EraVM/asm-parser/near-calls.s b/llvm/test/MC/EraVM/asm-parser/near-calls.s
index f07e72e5237c..fbb45dd0e82d 100644
--- a/llvm/test/MC/EraVM/asm-parser/near-calls.s
+++ b/llvm/test/MC/EraVM/asm-parser/near-calls.s
@@ -4,28 +4,29 @@
 foo:
 
 ; 3-operand form
-  near_call      r3, @callee, @exception_handler
+  call      r3, @callee, @exception_handler
 ; 2-operand form
-  near_call      r3, @callee
+  call      r3, @callee
 ; 1-operand form
-  near_call      @callee
-  near_call      r0, @callee ; the same as above
+  call      @callee
+  call      r0, @callee ; the same as above
 
 ; modifiers (condition)
-  near_call.lt   r3, @callee, @exception_handler
-  near_call.lt   r3, @callee
-  near_call.lt   @callee
+  call.lt   r3, @callee, @exception_handler
+  call.lt   r3, @callee
+  call.lt   @callee
 
 
 ; COM: Autogenerated checks below, see README.md.
+; COM: Manually added {{[ \t]}} to prevent matching obsolete near_call mnemonic.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  near_call    r3, @callee, @exception_handler
-; CHECK:  near_call    r3, @callee, @DEFAULT_UNWIND_DEST
-; CHECK:  near_call    @callee, @DEFAULT_UNWIND_DEST
-; CHECK:  near_call    @callee, @DEFAULT_UNWIND_DEST
+; CHECK:  {{[ \t]}}call    r3, @callee, @exception_handler
+; CHECK:  {{[ \t]}}call    r3, @callee, @DEFAULT_UNWIND_DEST
+; CHECK:  {{[ \t]}}call    @callee, @DEFAULT_UNWIND_DEST
+; CHECK:  {{[ \t]}}call    @callee, @DEFAULT_UNWIND_DEST
 
-; CHECK:  near_call.lt r3, @callee, @exception_handler
-; CHECK:  near_call.lt r3, @callee, @DEFAULT_UNWIND_DEST
-; CHECK:  near_call.lt @callee, @DEFAULT_UNWIND_DEST
+; CHECK:  {{[ \t]}}call.lt r3, @callee, @exception_handler
+; CHECK:  {{[ \t]}}call.lt r3, @callee, @DEFAULT_UNWIND_DEST
+; CHECK:  {{[ \t]}}call.lt @callee, @DEFAULT_UNWIND_DEST
diff --git a/llvm/test/MC/EraVM/asm-parser/near-returns.s b/llvm/test/MC/EraVM/asm-parser/near-returns.s
index 5b37c25cf559..3300659d26df 100644
--- a/llvm/test/MC/EraVM/asm-parser/near-returns.s
+++ b/llvm/test/MC/EraVM/asm-parser/near-returns.s
@@ -4,37 +4,37 @@
 foo:
 
 ; mnemonics
-  ret           ; aliased to ret.ok r1
-  ret.ok r1
-  ret.ok r3
-  revert        ; aliased to ret.revert r1
-  ret.revert r1
-  ret.revert r3
-  panic
-  ret.ok.to_label @label
-  ret.revert.to_label @label
-  ret.panic.to_label @label
+  ret        ; aliased to ret r1
+  ret r1
+  ret r3
+  rev        ; aliased to rev r1
+  rev r1
+  rev r3
+  pnc
+  retl @label
+  revl @label
+  pncl @label
 
 ; modifiers (condition)
   ret.lt
-  revert.lt
-  ret.ok.lt r3
-  ret.revert.lt r3
-  panic.lt
-  ret.ok.to_label.lt @label
-  ret.revert.to_label.lt @label
-  ret.panic.to_label.lt @label
+  rev.lt
+  ret.lt r3
+  rev.lt r3
+  pnc.lt
+  retl.lt @label
+  revl.lt @label
+  pncl.lt @label
 
 ; aliases
-  ret.ok.to_label         r1, @label
-  ret.revert.to_label     r1, @label
-  ret.ok.to_label.lt      r1, @label
-  ret.revert.to_label.lt  r1, @label
+  retl      r1, @label
+  revl      r1, @label
+  retl.lt   r1, @label
+  revl.lt   r1, @label
 ; generic case
-  ret.ok.to_label         r3, @label
-  ret.revert.to_label     r3, @label
-  ret.ok.to_label.lt      r3, @label
-  ret.revert.to_label.lt  r3, @label
+  retl      r3, @label
+  revl      r3, @label
+  retl.lt   r3, @label
+  revl.lt   r3, @label
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:  .text
@@ -42,29 +42,29 @@ foo:
 
 ; CHECK:  ret
 ; CHECK:  ret
-; CHECK:  ret.ok r3
-; CHECK:  revert
-; CHECK:  revert
-; CHECK:  ret.revert r3
-; CHECK:  panic
-; CHECK:  ret.ok.to_label  r1, @label
-; CHECK:  revert.to_label  r1, @label
-; CHECK:  panic.to_label   @label
+; CHECK:  ret r3
+; CHECK:  rev
+; CHECK:  rev
+; CHECK:  rev r3
+; CHECK:  pnc
+; CHECK:  retl  @label
+; CHECK:  revl  @label
+; CHECK:  pncl  @label
 
 ; CHECK:  ret.lt
-; CHECK:  revert.lt
-; CHECK:  ret.ok.lt r3
-; CHECK:  ret.revert.lt r3
-; CHECK:  panic.lt
-; CHECK:  ret.ok.to_label.lt r1, @label
-; CHECK:  ret.revert.to_label.lt r1, @label
-; CHECK:  panic.to_label.lt @label
+; CHECK:  rev.lt
+; CHECK:  ret.lt r3
+; CHECK:  rev.lt r3
+; CHECK:  pnc.lt
+; CHECK:  retl.lt @label
+; CHECK:  revl.lt @label
+; CHECK:  pncl.lt @label
 
-; CHECK:  ret.ok.to_label       r1, @label
-; CHECK:  ret.revert.to_label   r1, @label
-; CHECK:  ret.ok.to_label.lt    r1, @label
-; CHECK:  ret.revert.to_label.lt        r1, @label
-; CHECK:  ret.ok.to_label       r3, @label
-; CHECK:  ret.revert.to_label   r3, @label
-; CHECK:  ret.ok.to_label.lt    r3, @label
-; CHECK:  ret.revert.to_label.lt        r3, @label
+; CHECK:  retl       @label
+; CHECK:  revl       @label
+; CHECK:  retl.lt    @label
+; CHECK:  revl.lt    @label
+; CHECK:  retl       r3, @label
+; CHECK:  revl       r3, @label
+; CHECK:  retl.lt    r3, @label
+; CHECK:  revl.lt    r3, @label
diff --git a/llvm/test/MC/EraVM/asm-parser/ptr-instructions-errors.s b/llvm/test/MC/EraVM/asm-parser/ptr-instructions-errors.s
index 8cc88bc2d2d2..86ce8b00b405 100644
--- a/llvm/test/MC/EraVM/asm-parser/ptr-instructions-errors.s
+++ b/llvm/test/MC/EraVM/asm-parser/ptr-instructions-errors.s
@@ -10,64 +10,64 @@
 ; modification instructions is "Ensure the op_1 is tagged as a pointer and
 ; op_2 is not tagged as a pointer. Otherwise panic" and that only registers
 ; and stack can be tagged.
-  ptr.add       42, r2, r3
-  ptr.add       code[r1 + 1], r2, r3
-  ptr.add       42, r2, stack[r3 + 1]
-  ptr.add       code[r1 + 1], r2, stack[r3 + 1]
-  ptr.add       42, r2, stack-[r3 + 1]
-  ptr.add       code[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add       42, r2, stack+=[r3 + 1]
-  ptr.add       code[r1 + 1], r2, stack+=[r3 + 1]
+  addp    42, r2, r3
+  addp    code[r1 + 1], r2, r3
+  addp    42, r2, stack[r3 + 1]
+  addp    code[r1 + 1], r2, stack[r3 + 1]
+  addp    42, r2, stack-[r3 + 1]
+  addp    code[r1 + 1], r2, stack-[r3 + 1]
+  addp    42, r2, stack+=[r3 + 1]
+  addp    code[r1 + 1], r2, stack+=[r3 + 1]
 
 ; briefly check the three other instructions
-  ptr.sub       42, r2, r3
-  ptr.sub       code[r1 + 1], r2, r3
-  ptr.shrink    42, r2, r3
-  ptr.shrink    code[r1 + 1], r2, r3
-  ptr.pack      42, r2, r3
-  ptr.pack      code[r1 + 1], r2, r3
+  subp    42, r2, r3
+  subp    code[r1 + 1], r2, r3
+  shrnk   42, r2, r3
+  shrnk   code[r1 + 1], r2, r3
+  pack    42, r2, r3
+  pack    code[r1 + 1], r2, r3
 
 
 ; COM: Autogenerated checks below, see README.md.
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       42, r2, r3
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       code[r1 + 1], r2, r3
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       42, r2, stack[r3 + 1]
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       code[r1 + 1], r2, stack[r3 + 1]
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       42, r2, stack-[r3 + 1]
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       code[r1 + 1], r2, stack-[r3 + 1]
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       42, r2, stack+=[r3 + 1]
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.add       code[r1 + 1], r2, stack+=[r3 + 1]
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.sub       42, r2, r3
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.sub       code[r1 + 1], r2, r3
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.shrink    42, r2, r3
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.shrink    code[r1 + 1], r2, r3
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.pack      42, r2, r3
-; CHECK-NEXT:                  ^
-; CHECK:       <stdin>:{{[0-9]+}}:17: error: cannot parse operand
-; CHECK-NEXT:    ptr.pack      code[r1 + 1], r2, r3
-; CHECK-NEXT:                  ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    42, r2, r3
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    code[r1 + 1], r2, r3
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    42, r2, stack[r3 + 1]
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    code[r1 + 1], r2, stack[r3 + 1]
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    42, r2, stack-[r3 + 1]
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    code[r1 + 1], r2, stack-[r3 + 1]
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    42, r2, stack+=[r3 + 1]
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    addp    code[r1 + 1], r2, stack+=[r3 + 1]
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    subp    42, r2, r3
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    subp    code[r1 + 1], r2, r3
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    shrnk   42, r2, r3
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    shrnk   code[r1 + 1], r2, r3
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    pack    42, r2, r3
+; CHECK-NEXT:            ^
+; CHECK:       <stdin>:{{[0-9]+}}:11: error: cannot parse operand
+; CHECK-NEXT:    pack    code[r1 + 1], r2, r3
+; CHECK-NEXT:            ^
diff --git a/llvm/test/MC/EraVM/asm-parser/ptr-instructions.s b/llvm/test/MC/EraVM/asm-parser/ptr-instructions.s
index 4d27b5587817..b8189a58da01 100644
--- a/llvm/test/MC/EraVM/asm-parser/ptr-instructions.s
+++ b/llvm/test/MC/EraVM/asm-parser/ptr-instructions.s
@@ -7,130 +7,130 @@
 foo:
 
 ; mnemonics (incl. ".s" modifier)
-  ptr.add       r1, r2, r3
-  ptr.sub       r1, r2, r3
-  ptr.shrink    r1, r2, r3
-  ptr.pack      r1, r2, r3
-  ptr.add.s     42, r2, r3
-  ptr.sub.s     42, r2, r3
-  ptr.shrink.s  42, r2, r3
-  ptr.pack.s    42, r2, r3
+  addp        r1, r2, r3
+  subp        r1, r2, r3
+  shrnk       r1, r2, r3
+  pack        r1, r2, r3
+  addp.s      42, r2, r3
+  subp.s      42, r2, r3
+  shrnk.s     42, r2, r3
+  pack.s      42, r2, r3
 
 ; modifiers (condition)
-  ptr.add.lt       r1, r2, r3
-  ptr.sub.lt       r1, r2, r3
-  ptr.shrink.lt    r1, r2, r3
-  ptr.pack.lt      r1, r2, r3
-  ptr.add.s.lt     42, r2, r3
-  ptr.sub.s.lt     42, r2, r3
-  ptr.shrink.s.lt  42, r2, r3
-  ptr.pack.s.lt    42, r2, r3
+  addp.lt     r1, r2, r3
+  subp.lt     r1, r2, r3
+  shrnk.lt    r1, r2, r3
+  pack.lt     r1, r2, r3
+  addp.s.lt   42, r2, r3
+  subp.s.lt   42, r2, r3
+  shrnk.s.lt  42, r2, r3
+  pack.s.lt   42, r2, r3
 
 ; operands (non-swapped version: 4 src modes x 4 dst modes)
-  ptr.add       r1, r2, r3
-  ptr.add       stack[r1 + 1], r2, r3
-  ptr.add       stack-[r1 + 1], r2, r3
-  ptr.add       stack-=[r1 + 1], r2, r3
-  ptr.add       r1, r2, stack[r3 + 1]
-  ptr.add       stack[r1 + 1], r2, stack[r3 + 1]
-  ptr.add       stack-[r1 + 1], r2, stack[r3 + 1]
-  ptr.add       stack-=[r1 + 1], r2, stack[r3 + 1]
-  ptr.add       r1, r2, stack-[r3 + 1]
-  ptr.add       stack[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add       stack-[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add       stack-=[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add       r1, r2, stack+=[r3 + 1]
-  ptr.add       stack[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add       stack-[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add       stack-=[r1 + 1], r2, stack+=[r3 + 1]
+  addp        r1, r2, r3
+  addp        stack[r1 + 1], r2, r3
+  addp        stack-[r1 + 1], r2, r3
+  addp        stack-=[r1 + 1], r2, r3
+  addp        r1, r2, stack[r3 + 1]
+  addp        stack[r1 + 1], r2, stack[r3 + 1]
+  addp        stack-[r1 + 1], r2, stack[r3 + 1]
+  addp        stack-=[r1 + 1], r2, stack[r3 + 1]
+  addp        r1, r2, stack-[r3 + 1]
+  addp        stack[r1 + 1], r2, stack-[r3 + 1]
+  addp        stack-[r1 + 1], r2, stack-[r3 + 1]
+  addp        stack-=[r1 + 1], r2, stack-[r3 + 1]
+  addp        r1, r2, stack+=[r3 + 1]
+  addp        stack[r1 + 1], r2, stack+=[r3 + 1]
+  addp        stack-[r1 + 1], r2, stack+=[r3 + 1]
+  addp        stack-=[r1 + 1], r2, stack+=[r3 + 1]
 
 ; operands (swapped version: 6 src modes x 4 dst modes)
-  ptr.add.s    r1, r2, r3
-  ptr.add.s    42, r2, r3
-  ptr.add.s    stack[r1 + 1], r2, r3
-  ptr.add.s    stack-[r1 + 1], r2, r3
-  ptr.add.s    stack-=[r1 + 1], r2, r3
-  ptr.add.s    code[r1 + 1], r2, r3
-  ptr.add.s    r1, r2, stack[r3 + 1]
-  ptr.add.s    42, r2, stack[r3 + 1]
-  ptr.add.s    stack[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    stack-[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    stack-=[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    code[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    r1, r2, stack-[r3 + 1]
-  ptr.add.s    42, r2, stack-[r3 + 1]
-  ptr.add.s    stack[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    stack-[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    stack-=[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    code[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    r1, r2, stack+=[r3 + 1]
-  ptr.add.s    42, r2, stack+=[r3 + 1]
-  ptr.add.s    stack[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add.s    stack-[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add.s    stack-=[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add.s    code[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s      r1, r2, r3
+  addp.s      42, r2, r3
+  addp.s      stack[r1 + 1], r2, r3
+  addp.s      stack-[r1 + 1], r2, r3
+  addp.s      stack-=[r1 + 1], r2, r3
+  addp.s      code[r1 + 1], r2, r3
+  addp.s      r1, r2, stack[r3 + 1]
+  addp.s      42, r2, stack[r3 + 1]
+  addp.s      stack[r1 + 1], r2, stack[r3 + 1]
+  addp.s      stack-[r1 + 1], r2, stack[r3 + 1]
+  addp.s      stack-=[r1 + 1], r2, stack[r3 + 1]
+  addp.s      code[r1 + 1], r2, stack[r3 + 1]
+  addp.s      r1, r2, stack-[r3 + 1]
+  addp.s      42, r2, stack-[r3 + 1]
+  addp.s      stack[r1 + 1], r2, stack-[r3 + 1]
+  addp.s      stack-[r1 + 1], r2, stack-[r3 + 1]
+  addp.s      stack-=[r1 + 1], r2, stack-[r3 + 1]
+  addp.s      code[r1 + 1], r2, stack-[r3 + 1]
+  addp.s      r1, r2, stack+=[r3 + 1]
+  addp.s      42, r2, stack+=[r3 + 1]
+  addp.s      stack[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s      stack-[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s      stack-=[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s      code[r1 + 1], r2, stack+=[r3 + 1]
 
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  ptr.add      r1, r2, r3
-; CHECK:  ptr.sub      r1, r2, r3
-; CHECK:  ptr.shrink   r1, r2, r3
-; CHECK:  ptr.pack     r1, r2, r3
-; CHECK:  ptr.add.s    42, r2, r3
-; CHECK:  ptr.sub.s    42, r2, r3
-; CHECK:  ptr.shrink.s 42, r2, r3
-; CHECK:  ptr.pack.s   42, r2, r3
+; CHECK:  addp       r1, r2, r3
+; CHECK:  subp       r1, r2, r3
+; CHECK:  shrnk      r1, r2, r3
+; CHECK:  pack       r1, r2, r3
+; CHECK:  addp.s     42, r2, r3
+; CHECK:  subp.s     42, r2, r3
+; CHECK:  shrnk.s    42, r2, r3
+; CHECK:  pack.s     42, r2, r3
 
-; CHECK:  ptr.add.lt   r1, r2, r3
-; CHECK:  ptr.sub.lt   r1, r2, r3
-; CHECK:  ptr.shrink.lt        r1, r2, r3
-; CHECK:  ptr.pack.lt  r1, r2, r3
-; CHECK:  ptr.add.s.lt 42, r2, r3
-; CHECK:  ptr.sub.s.lt 42, r2, r3
-; CHECK:  ptr.shrink.s.lt      42, r2, r3
-; CHECK:  ptr.pack.s.lt        42, r2, r3
+; CHECK:  addp.lt    r1, r2, r3
+; CHECK:  subp.lt    r1, r2, r3
+; CHECK:  shrnk.lt   r1, r2, r3
+; CHECK:  pack.lt    r1, r2, r3
+; CHECK:  addp.s.lt  42, r2, r3
+; CHECK:  subp.s.lt  42, r2, r3
+; CHECK:  shrnk.s.lt 42, r2, r3
+; CHECK:  pack.s.lt  42, r2, r3
 
-; CHECK:  ptr.add      r1, r2, r3
-; CHECK:  ptr.add      stack[1 + r1], r2, r3
-; CHECK:  ptr.add      stack-[1 + r1], r2, r3
-; CHECK:  ptr.add      stack-=[1 + r1], r2, r3
-; CHECK:  ptr.add      r1, r2, stack[1 + r3]
-; CHECK:  ptr.add      stack[1 + r1], r2, stack[1 + r3]
-; CHECK:  ptr.add      stack-[1 + r1], r2, stack[1 + r3]
-; CHECK:  ptr.add      stack-=[1 + r1], r2, stack[1 + r3]
-; CHECK:  ptr.add      r1, r2, stack-[1 + r3]
-; CHECK:  ptr.add      stack[1 + r1], r2, stack-[1 + r3]
-; CHECK:  ptr.add      stack-[1 + r1], r2, stack-[1 + r3]
-; CHECK:  ptr.add      stack-=[1 + r1], r2, stack-[1 + r3]
-; CHECK:  ptr.add      r1, r2, stack+=[1 + r3]
-; CHECK:  ptr.add      stack[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  ptr.add      stack-[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  ptr.add      stack-=[1 + r1], r2, stack+=[1 + r3]
+; CHECK:  addp       r1, r2, r3
+; CHECK:  addp       stack[1 + r1], r2, r3
+; CHECK:  addp       stack-[1 + r1], r2, r3
+; CHECK:  addp       stack-=[1 + r1], r2, r3
+; CHECK:  addp       r1, r2, stack[1 + r3]
+; CHECK:  addp       stack[1 + r1], r2, stack[1 + r3]
+; CHECK:  addp       stack-[1 + r1], r2, stack[1 + r3]
+; CHECK:  addp       stack-=[1 + r1], r2, stack[1 + r3]
+; CHECK:  addp       r1, r2, stack-[1 + r3]
+; CHECK:  addp       stack[1 + r1], r2, stack-[1 + r3]
+; CHECK:  addp       stack-[1 + r1], r2, stack-[1 + r3]
+; CHECK:  addp       stack-=[1 + r1], r2, stack-[1 + r3]
+; CHECK:  addp       r1, r2, stack+=[1 + r3]
+; CHECK:  addp       stack[1 + r1], r2, stack+=[1 + r3]
+; CHECK:  addp       stack-[1 + r1], r2, stack+=[1 + r3]
+; CHECK:  addp       stack-=[1 + r1], r2, stack+=[1 + r3]
 
-; CHECK:  ptr.add.s    r1, r2, r3
-; CHECK:  ptr.add.s    42, r2, r3
-; CHECK:  ptr.add.s    stack[1 + r1], r2, r3
-; CHECK:  ptr.add.s    stack-[1 + r1], r2, r3
-; CHECK:  ptr.add.s    stack-=[1 + r1], r2, r3
-; CHECK:  ptr.add.s    code[r1+1], r2, r3
-; CHECK:  ptr.add.s    r1, r2, stack[1 + r3]
-; CHECK:  ptr.add.s    42, r2, stack[1 + r3]
-; CHECK:  ptr.add.s    stack[1 + r1], r2, stack[1 + r3]
-; CHECK:  ptr.add.s    stack-[1 + r1], r2, stack[1 + r3]
-; CHECK:  ptr.add.s    stack-=[1 + r1], r2, stack[1 + r3]
-; CHECK:  ptr.add.s    code[r1+1], r2, stack[1 + r3]
-; CHECK:  ptr.add.s    r1, r2, stack-[1 + r3]
-; CHECK:  ptr.add.s    42, r2, stack-[1 + r3]
-; CHECK:  ptr.add.s    stack[1 + r1], r2, stack-[1 + r3]
-; CHECK:  ptr.add.s    stack-[1 + r1], r2, stack-[1 + r3]
-; CHECK:  ptr.add.s    stack-=[1 + r1], r2, stack-[1 + r3]
-; CHECK:  ptr.add.s    code[r1+1], r2, stack-[1 + r3]
-; CHECK:  ptr.add.s    r1, r2, stack+=[1 + r3]
-; CHECK:  ptr.add.s    42, r2, stack+=[1 + r3]
-; CHECK:  ptr.add.s    stack[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  ptr.add.s    stack-[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  ptr.add.s    stack-=[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  ptr.add.s    code[r1+1], r2, stack+=[1 + r3]
+; CHECK:  addp.s     r1, r2, r3
+; CHECK:  addp.s     42, r2, r3
+; CHECK:  addp.s     stack[1 + r1], r2, r3
+; CHECK:  addp.s     stack-[1 + r1], r2, r3
+; CHECK:  addp.s     stack-=[1 + r1], r2, r3
+; CHECK:  addp.s     code[r1+1], r2, r3
+; CHECK:  addp.s     r1, r2, stack[1 + r3]
+; CHECK:  addp.s     42, r2, stack[1 + r3]
+; CHECK:  addp.s     stack[1 + r1], r2, stack[1 + r3]
+; CHECK:  addp.s     stack-[1 + r1], r2, stack[1 + r3]
+; CHECK:  addp.s     stack-=[1 + r1], r2, stack[1 + r3]
+; CHECK:  addp.s     code[r1+1], r2, stack[1 + r3]
+; CHECK:  addp.s     r1, r2, stack-[1 + r3]
+; CHECK:  addp.s     42, r2, stack-[1 + r3]
+; CHECK:  addp.s     stack[1 + r1], r2, stack-[1 + r3]
+; CHECK:  addp.s     stack-[1 + r1], r2, stack-[1 + r3]
+; CHECK:  addp.s     stack-=[1 + r1], r2, stack-[1 + r3]
+; CHECK:  addp.s     code[r1+1], r2, stack-[1 + r3]
+; CHECK:  addp.s     r1, r2, stack+=[1 + r3]
+; CHECK:  addp.s     42, r2, stack+=[1 + r3]
+; CHECK:  addp.s     stack[1 + r1], r2, stack+=[1 + r3]
+; CHECK:  addp.s     stack-[1 + r1], r2, stack+=[1 + r3]
+; CHECK:  addp.s     stack-=[1 + r1], r2, stack+=[1 + r3]
+; CHECK:  addp.s     code[r1+1], r2, stack+=[1 + r3]
diff --git a/llvm/test/MC/EraVM/asm-parser/sp-changes.s b/llvm/test/MC/EraVM/asm-parser/sp-changes.s
index 60127ed81c0e..a2ac5473162b 100644
--- a/llvm/test/MC/EraVM/asm-parser/sp-changes.s
+++ b/llvm/test/MC/EraVM/asm-parser/sp-changes.s
@@ -11,14 +11,14 @@ foo:
   nop.lt    r0, r0, r0
 
 ; incsp: inputs are r0, output is stack+=[...]
-  nop       stack+=[r0 + 0]
-  nop       stack+=[r1]
-  nop       stack+=[42]
-  nop       stack+=[r1 + 42]
-  nop.lt    stack+=[r0 + 0]
-  nop.lt    stack+=[r1]
-  nop.lt    stack+=[42]
-  nop.lt    stack+=[r1 + 42]
+  incsp     r0 + 0
+  incsp     r1
+  incsp     42
+  incsp     r1 + 42
+  incsp.lt  r0 + 0
+  incsp.lt  r1
+  incsp.lt  42
+  incsp.lt  r1 + 42
 ; the same in generic form
   nop       r0, r0, stack+=[r0 + 0]
   nop       r0, r0, stack+=[r1]
@@ -30,14 +30,14 @@ foo:
   nop.lt    r0, r0, stack+=[r1 + 42]
 
 ; decsp: first input is stack-=[...], output and second input are r0
-  nop       stack-=[r0 + 0]
-  nop       stack-=[r1]
-  nop       stack-=[42]
-  nop       stack-=[r1 + 42]
-  nop.lt    stack-=[r0 + 0]
-  nop.lt    stack-=[r1]
-  nop.lt    stack-=[42]
-  nop.lt    stack-=[r1 + 42]
+  decsp     r0 + 0
+  decsp     r1
+  decsp     42
+  decsp     r1 + 42
+  decsp.lt  r0 + 0
+  decsp.lt  r1
+  decsp.lt  42
+  decsp.lt  r1 + 42
 ; the same in generic form
   nop       stack-=[r0 + 0], r0, r0
   nop       stack-=[r1], r0, r0
@@ -49,44 +49,45 @@ foo:
   nop.lt    stack-=[r1 + 42], r0, r0
 
 ; COM: Autogenerated checks below, see README.md.
+; COM: Manually added {{$}} to prevent matching the generic form.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  nop
-; CHECK:  nop.lt
-; CHECK:  nop
-; CHECK:  nop.lt
+; CHECK:  nop{{$}}
+; CHECK:  nop.lt{{$}}
+; CHECK:  nop{{$}}
+; CHECK:  nop.lt{{$}}
 
-; CHECK:  nop   stack+=[0 + r0]
-; CHECK:  nop   stack+=[0 + r1]
-; CHECK:  nop   stack+=[42]
-; CHECK:  nop   stack+=[42 + r1]
-; CHECK:  nop.lt        stack+=[0 + r0]
-; CHECK:  nop.lt        stack+=[0 + r1]
-; CHECK:  nop.lt        stack+=[42]
-; CHECK:  nop.lt        stack+=[42 + r1]
-; CHECK:  nop   stack+=[0 + r0]
-; CHECK:  nop   stack+=[0 + r1]
-; CHECK:  nop   stack+=[42]
-; CHECK:  nop   stack+=[42 + r1]
-; CHECK:  nop.lt        stack+=[0 + r0]
-; CHECK:  nop.lt        stack+=[0 + r1]
-; CHECK:  nop.lt        stack+=[42]
-; CHECK:  nop.lt        stack+=[42 + r1]
+; CHECK:  incsp r0
+; CHECK:  incsp r1
+; CHECK:  incsp 42
+; CHECK:  incsp r1+42
+; CHECK:  incsp.lt      r0
+; CHECK:  incsp.lt      r1
+; CHECK:  incsp.lt      42
+; CHECK:  incsp.lt      r1+42
+; CHECK:  incsp r0
+; CHECK:  incsp r1
+; CHECK:  incsp 42
+; CHECK:  incsp r1+42
+; CHECK:  incsp.lt      r0
+; CHECK:  incsp.lt      r1
+; CHECK:  incsp.lt      42
+; CHECK:  incsp.lt      r1+42
 
-; CHECK:  nop   stack-=[0 + r0]
-; CHECK:  nop   stack-=[0 + r1]
-; CHECK:  nop   stack-=[42]
-; CHECK:  nop   stack-=[42 + r1]
-; CHECK:  nop.lt        stack-=[0 + r0]
-; CHECK:  nop.lt        stack-=[0 + r1]
-; CHECK:  nop.lt        stack-=[42]
-; CHECK:  nop.lt        stack-=[42 + r1]
-; CHECK:  nop   stack-=[0 + r0]
-; CHECK:  nop   stack-=[0 + r1]
-; CHECK:  nop   stack-=[42]
-; CHECK:  nop   stack-=[42 + r1]
-; CHECK:  nop.lt        stack-=[0 + r0]
-; CHECK:  nop.lt        stack-=[0 + r1]
-; CHECK:  nop.lt        stack-=[42]
-; CHECK:  nop.lt        stack-=[42 + r1]
+; CHECK:  decsp r0
+; CHECK:  decsp r1
+; CHECK:  decsp 42
+; CHECK:  decsp r1+42
+; CHECK:  decsp.lt      r0
+; CHECK:  decsp.lt      r1
+; CHECK:  decsp.lt      42
+; CHECK:  decsp.lt      r1+42
+; CHECK:  decsp r0
+; CHECK:  decsp r1
+; CHECK:  decsp 42
+; CHECK:  decsp r1+42
+; CHECK:  decsp.lt      r0
+; CHECK:  decsp.lt      r1
+; CHECK:  decsp.lt      42
+; CHECK:  decsp.lt      r1+42
diff --git a/llvm/test/MC/EraVM/asm-parser/storage.s b/llvm/test/MC/EraVM/asm-parser/storage.s
index a1abf77f7443..c61acbaf05dc 100644
--- a/llvm/test/MC/EraVM/asm-parser/storage.s
+++ b/llvm/test/MC/EraVM/asm-parser/storage.s
@@ -4,27 +4,27 @@
 foo:
 
 ; mnemonics
-  sload       r3, r4
-  sstore      r3, r4
-  tload       r3, r4
-  tstore      r3, r4
+  lds       r3, r4
+  sts       r3, r4
+  ldt       r3, r4
+  stt       r3, r4
 
 ; modifiers (condition)
-  sload.lt    r3, r4
-  sstore.lt   r3, r4
-  tload.lt    r3, r4
-  tstore.lt   r3, r4
+  lds.lt    r3, r4
+  sts.lt    r3, r4
+  ldt.lt    r3, r4
+  stt.lt    r3, r4
 
 ; COM: Autogenerated checks below, see README.md.
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  sload        r3, r4
-; CHECK:  sstore       r3, r4
-; CHECK:  tload        r3, r4
-; CHECK:  tstore       r3, r4
+; CHECK:  lds       r3, r4
+; CHECK:  sts       r3, r4
+; CHECK:  ldt       r3, r4
+; CHECK:  stt       r3, r4
 
-; CHECK:  sload.lt     r3, r4
-; CHECK:  sstore.lt    r3, r4
-; CHECK:  tload.lt     r3, r4
-; CHECK:  tstore.lt    r3, r4
+; CHECK:  lds.lt    r3, r4
+; CHECK:  sts.lt    r3, r4
+; CHECK:  ldt.lt    r3, r4
+; CHECK:  stt.lt    r3, r4
diff --git a/llvm/test/MC/EraVM/asm-parser/uma.s b/llvm/test/MC/EraVM/asm-parser/uma.s
index ba842772ffe2..a4bd5651f672 100644
--- a/llvm/test/MC/EraVM/asm-parser/uma.s
+++ b/llvm/test/MC/EraVM/asm-parser/uma.s
@@ -4,18 +4,18 @@
 foo:
 
 ; mnemonics
-  ld      r3, r4
-  ld.inc  r3, r4, r5
+  ldp       r3, r4
+  ldpi      r3, r4, r5
 
-  ld.1      r3, r4
-  ld.2      r3, r4
-  ld.1.inc  r3, r4, r5
-  ld.2.inc  r3, r4, r5
+  ldm.h     r3, r4
+  ldm.ah    r3, r4
+  ldmi.h    r3, r4, r5
+  ldmi.ah   r3, r4, r5
 
-  st.1      r3, r4
-  st.2      r3, r4
-  st.1.inc  r3, r4, r5
-  st.2.inc  r3, r4, r5
+  stm.h     r3, r4
+  stm.ah    r3, r4
+  stmi.h    r3, r4, r5
+  stmi.ah   r3, r4, r5
 
   ldm.st    r3, r4
   ldmi.st   r3, r4, r5
@@ -24,30 +24,30 @@ foo:
 
 ; modifiers (condition code)
 
-  ld.lt        r3, r4
-  ld.inc.lt    r3, r4, r5
-  ld.1.lt      r3, r4
-  ld.2.lt      r3, r4
-  ld.1.inc.lt  r3, r4, r5
-  ld.2.inc.lt  r3, r4, r5
-  st.1.lt      r3, r4
-  st.2.lt      r3, r4
-  st.1.inc.lt  r3, r4, r5
-  st.2.inc.lt  r3, r4, r5
-  ldm.st.lt    r3, r4
-  ldmi.st.lt   r3, r4, r5
-  stm.st.lt    r3, r4
-  stmi.st.lt   r3, r4, r5
+  ldp.lt        r3, r4
+  ldpi.lt       r3, r4, r5
+  ldm.h.lt      r3, r4
+  ldm.ah.lt     r3, r4
+  ldmi.h.lt     r3, r4, r5
+  ldmi.ah.lt    r3, r4, r5
+  stm.h.lt      r3, r4
+  stm.ah.lt     r3, r4
+  stmi.h.lt     r3, r4, r5
+  stmi.ah.lt    r3, r4, r5
+  ldm.st.lt     r3, r4
+  ldmi.st.lt    r3, r4, r5
+  stm.st.lt     r3, r4
+  stmi.st.lt    r3, r4, r5
 
 ; operands (instructions operating on "local" heap can accept immediate addresses)
-  ld.1      42, r4
-  ld.2      42, r4
-  ld.1.inc  42, r4, r5
-  ld.2.inc  42, r4, r5
-  st.1      42, r4
-  st.2      42, r4
-  st.1.inc  42, r4, r5
-  st.2.inc  42, r4, r5
+  ldm.h     42, r4
+  ldm.ah    42, r4
+  ldmi.h    42, r4, r5
+  ldmi.ah   42, r4, r5
+  stm.h     42, r4
+  stm.ah    42, r4
+  stmi.h    42, r4, r5
+  stmi.ah   42, r4, r5
   ldm.st    42, r4
   ldmi.st   42, r4, r5
   stm.st    42, r4
@@ -57,47 +57,47 @@ foo:
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  ld   r3, r4
-; CHECK:  ld.inc       r3, r4, r5
+; CHECK:  ldp       r3, r4
+; CHECK:  ldpi      r3, r4, r5
 
-; CHECK:  ld.1 r3, r4
-; CHECK:  ld.2 r3, r4
-; CHECK:  ld.1.inc     r3, r4, r5
-; CHECK:  ld.2.inc     r3, r4, r5
+; CHECK:  ldm.h     r3, r4
+; CHECK:  ldm.ah    r3, r4
+; CHECK:  ldmi.h    r3, r4, r5
+; CHECK:  ldmi.ah   r3, r4, r5
 
-; CHECK:  st.1 r3, r4
-; CHECK:  st.2 r3, r4
-; CHECK:  st.1.inc     r3, r4, r5
-; CHECK:  st.2.inc     r3, r4, r5
+; CHECK:  stm.h     r3, r4
+; CHECK:  stm.ah    r3, r4
+; CHECK:  stmi.h    r3, r4, r5
+; CHECK:  stmi.ah   r3, r4, r5
 
 ; CHECK:  ldm.st    r3, r4
 ; CHECK:  ldmi.st   r3, r4, r5
 ; CHECK:  stm.st    r3, r4
 ; CHECK:  stmi.st   r3, r4, r5
 
-; CHECK:  ld.lt        r3, r4
-; CHECK:  ld.inc.lt    r3, r4, r5
-; CHECK:  ld.1.lt      r3, r4
-; CHECK:  ld.2.lt      r3, r4
-; CHECK:  ld.1.inc.lt  r3, r4, r5
-; CHECK:  ld.2.inc.lt  r3, r4, r5
-; CHECK:  st.1.lt      r3, r4
-; CHECK:  st.2.lt      r3, r4
-; CHECK:  st.1.inc.lt  r3, r4, r5
-; CHECK:  st.2.inc.lt  r3, r4, r5
-; CHECK:  ldm.st.lt    r3, r4
-; CHECK:  ldmi.st.lt   r3, r4, r5
-; CHECK:  stm.st.lt    r3, r4
-; CHECK:  stmi.st.lt   r3, r4, r5
+; CHECK:  ldp.lt        r3, r4
+; CHECK:  ldpi.lt       r3, r4, r5
+; CHECK:  ldm.h.lt      r3, r4
+; CHECK:  ldm.ah.lt     r3, r4
+; CHECK:  ldmi.h.lt     r3, r4, r5
+; CHECK:  ldmi.ah.lt    r3, r4, r5
+; CHECK:  stm.h.lt      r3, r4
+; CHECK:  stm.ah.lt     r3, r4
+; CHECK:  stmi.h.lt     r3, r4, r5
+; CHECK:  stmi.ah.lt    r3, r4, r5
+; CHECK:  ldm.st.lt     r3, r4
+; CHECK:  ldmi.st.lt    r3, r4, r5
+; CHECK:  stm.st.lt     r3, r4
+; CHECK:  stmi.st.lt    r3, r4, r5
 
-; CHECK:  ld.1 42, r4
-; CHECK:  ld.2 42, r4
-; CHECK:  ld.1.inc     42, r4, r5
-; CHECK:  ld.2.inc     42, r4, r5
-; CHECK:  st.1 42, r4
-; CHECK:  st.2 42, r4
-; CHECK:  st.1.inc     42, r4, r5
-; CHECK:  st.2.inc     42, r4, r5
+; CHECK:  ldm.h     42, r4
+; CHECK:  ldm.ah    42, r4
+; CHECK:  ldmi.h    42, r4, r5
+; CHECK:  ldmi.ah   42, r4, r5
+; CHECK:  stm.h     42, r4
+; CHECK:  stm.ah    42, r4
+; CHECK:  stmi.h    42, r4, r5
+; CHECK:  stmi.ah   42, r4, r5
 ; CHECK:  ldm.st    42, r4
 ; CHECK:  ldmi.st   42, r4, r5
 ; CHECK:  stm.st    42, r4
diff --git a/llvm/test/MC/EraVM/decoding/events.txt b/llvm/test/MC/EraVM/decoding/events.txt
index 6161c728671c..762acffcc17f 100644
--- a/llvm/test/MC/EraVM/decoding/events.txt
+++ b/llvm/test/MC/EraVM/decoding/events.txt
@@ -6,7 +6,7 @@
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1f]
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1c]
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1d]
-# CHECK:  event           r3, r4
-# CHECK:  event.first     r3, r4
-# CHECK:  to_l1           r3, r4
-# CHECK:  to_l1.first     r3, r4
+# CHECK:  log       r3, r4
+# CHECK:  log.i     r3, r4
+# CHECK:  logL1     r3, r4
+# CHECK:  logL1.i   r3, r4
diff --git a/llvm/test/MC/EraVM/decoding/far-calls.txt b/llvm/test/MC/EraVM/decoding/far-calls.txt
index 81094c1fe9e2..767250f7a21d 100644
--- a/llvm/test/MC/EraVM/decoding/far-calls.txt
+++ b/llvm/test/MC/EraVM/decoding/far-calls.txt
@@ -8,27 +8,27 @@
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x21]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x25]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x29]
-# CHECK:  far_call                      r3, r4, 65535
-# CHECK:  far_call.delegate             r3, r4, 65535
-# CHECK:  far_call.mimic                r3, r4, 65535
+# CHECK:  callf          r3, r4, 65535
+# CHECK:  calld          r3, r4, 65535
+# CHECK:  callm          r3, r4, 65535
 
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x23]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x27]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x2b]
-# CHECK:  far_call.static               r3, r4, 65535
-# CHECK:  far_call.delegate.static      r3, r4, 65535
-# CHECK:  far_call.mimic.static         r3, r4, 65535
+# CHECK:  callf.st       r3, r4, 65535
+# CHECK:  calld.st       r3, r4, 65535
+# CHECK:  callm.st       r3, r4, 65535
 
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x22]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x26]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x2a]
-# CHECK:  far_call.shard                r3, r4, 65535
-# CHECK:  far_call.delegate.shard       r3, r4, 65535
-# CHECK:  far_call.mimic.shard          r3, r4, 65535
+# CHECK:  callf.sh       r3, r4, 65535
+# CHECK:  calld.sh       r3, r4, 65535
+# CHECK:  callm.sh       r3, r4, 65535
 
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x24]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x28]
 [0x00,0x00,0xff,0xff,0x00,0x43,0x04,0x2c]
-# CHECK:  far_call.st.sh                r3, r4, 65535
-# CHECK:  far_call.delegate.st.sh       r3, r4, 65535
-# CHECK:  far_call.mimic.st.sh          r3, r4, 65535
+# CHECK:  callf.st.sh    r3, r4, 65535
+# CHECK:  calld.st.sh    r3, r4, 65535
+# CHECK:  callm.st.sh    r3, r4, 65535
diff --git a/llvm/test/MC/EraVM/decoding/misc.txt b/llvm/test/MC/EraVM/decoding/misc.txt
index 183294b9a102..880590a82203 100644
--- a/llvm/test/MC/EraVM/decoding/misc.txt
+++ b/llvm/test/MC/EraVM/decoding/misc.txt
@@ -13,17 +13,19 @@
 [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x17]
 [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x13]
 [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x19]
+# CHECK:  dcmt    r3, r4, r5
+# CHECK:  callp   r3, r4, r5
+# CHECK:  this    r3
+# CHECK:  par     r3
+# CHECK:  code    r3
+# CHECK:  ergs    r3
+# CHECK:  sp      r3
+# CHECK:  ldvl    r3
+# CHECK:  stvl    r3
+# CHECK:  meta    r3
+# CHECK:  inctx
+
+# Removed in VM 1.5.0
 [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x18]
-# CHECK:  log.decommit  r3, r4, r5
-# CHECK:  precompile    r3, r4, r5
-# CHECK:  context.this                  r3
-# CHECK:  context.caller                r3
-# CHECK:  context.code_source           r3
-# CHECK:  context.gas_left              r3
-# CHECK:  context.sp                    r3
-# CHECK:  context.get_context_u128      r3
-# CHECK:  context.set_context_u128      r3
-# CHECK:  context.meta                  r3
-# CHECK:  context.inc_tx_num
-# CHECK:  context.set_gas_per_pubdata   r3
+# CHECK:  stpub   r3
 
diff --git a/llvm/test/MC/EraVM/decoding/near-calls.txt b/llvm/test/MC/EraVM/decoding/near-calls.txt
index f6b2bd8f5ff8..f5d1782e8e90 100644
--- a/llvm/test/MC/EraVM/decoding/near-calls.txt
+++ b/llvm/test/MC/EraVM/decoding/near-calls.txt
@@ -7,4 +7,4 @@
 # FIXME: Simplified forms not tested.
 
 [0xab,0xcd,0x10,0x01,0x00,0x03,0x04,0x0f]
-# CHECK:  near_call      r3, 4097, 43981
+# CHECK:  call      r3, 4097, 43981
diff --git a/llvm/test/MC/EraVM/decoding/nop.txt b/llvm/test/MC/EraVM/decoding/nop.txt
index 4202a8feadaa..c2d4e415254c 100644
--- a/llvm/test/MC/EraVM/decoding/nop.txt
+++ b/llvm/test/MC/EraVM/decoding/nop.txt
@@ -4,7 +4,7 @@
 
 # mnemonic
 [0x00,0x00,0x00,0x00,0x03,0x21,0x00,0x01]
-; CHECK:  nop   r1, r2, r3
+# CHECK:  nop   r1, r2, r3
 
 # combinations of operand types
 [0x00,0x00,0x00,0x00,0x03,0x21,0x00,0x01]
@@ -31,27 +31,27 @@
 [0x00,0x01,0x00,0x01,0x03,0x21,0x00,0x0a]
 [0x00,0x01,0x00,0x01,0x03,0x21,0x00,0x06]
 [0x00,0x01,0x00,0x01,0x03,0x21,0x00,0x16]
-; CHECK:  nop   r1, r2, r3
-; CHECK:  nop   42, r2, r3
-; CHECK:  nop   stack[1 + r1], r2, r3
-; CHECK:  nop   stack-[1 + r1], r2, r3
-; CHECK:  nop   stack-=[1 + r1], r2, r3
-; CHECK:  nop   code[r1+1], r2, r3
-; CHECK:  nop   r1, r2, stack[1 + r3]
-; CHECK:  nop   42, r2, stack[1 + r3]
-; CHECK:  nop   stack[1 + r1], r2, stack[1 + r3]
-; CHECK:  nop   stack-[1 + r1], r2, stack[1 + r3]
-; CHECK:  nop   stack-=[1 + r1], r2, stack[1 + r3]
-; CHECK:  nop   code[r1+1], r2, stack[1 + r3]
-; CHECK:  nop   r1, r2, stack-[1 + r3]
-; CHECK:  nop   42, r2, stack-[1 + r3]
-; CHECK:  nop   stack[1 + r1], r2, stack-[1 + r3]
-; CHECK:  nop   stack-[1 + r1], r2, stack-[1 + r3]
-; CHECK:  nop   stack-=[1 + r1], r2, stack-[1 + r3]
-; CHECK:  nop   code[r1+1], r2, stack-[1 + r3]
-; CHECK:  nop   r1, r2, stack+=[1 + r3]
-; CHECK:  nop   42, r2, stack+=[1 + r3]
-; CHECK:  nop   stack[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  nop   stack-[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  nop   stack-=[1 + r1], r2, stack+=[1 + r3]
-; CHECK:  nop   code[r1+1], r2, stack+=[1 + r3]
+# CHECK:  nop   r1, r2, r3
+# CHECK:  nop   42, r2, r3
+# CHECK:  nop   stack[1 + r1], r2, r3
+# CHECK:  nop   stack-[1 + r1], r2, r3
+# CHECK:  nop   stack-=[1 + r1], r2, r3
+# CHECK:  nop   code[r1+1], r2, r3
+# CHECK:  nop   r1, r2, stack[1 + r3]
+# CHECK:  nop   42, r2, stack[1 + r3]
+# CHECK:  nop   stack[1 + r1], r2, stack[1 + r3]
+# CHECK:  nop   stack-[1 + r1], r2, stack[1 + r3]
+# CHECK:  nop   stack-=[1 + r1], r2, stack[1 + r3]
+# CHECK:  nop   code[r1+1], r2, stack[1 + r3]
+# CHECK:  nop   r1, r2, stack-[1 + r3]
+# CHECK:  nop   42, r2, stack-[1 + r3]
+# CHECK:  nop   stack[1 + r1], r2, stack-[1 + r3]
+# CHECK:  nop   stack-[1 + r1], r2, stack-[1 + r3]
+# CHECK:  nop   stack-=[1 + r1], r2, stack-[1 + r3]
+# CHECK:  nop   code[r1+1], r2, stack-[1 + r3]
+# CHECK:  nop   r1, r2, stack+=[1 + r3]
+# CHECK:  nop   42, r2, stack+=[1 + r3]
+# CHECK:  nop   stack[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  nop   stack-[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  nop   stack-=[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  nop   code[r1+1], r2, stack+=[1 + r3]
diff --git a/llvm/test/MC/EraVM/decoding/ptr-instructions.txt b/llvm/test/MC/EraVM/decoding/ptr-instructions.txt
index 5cd708b9cbe2..e8a1efda79ee 100644
--- a/llvm/test/MC/EraVM/decoding/ptr-instructions.txt
+++ b/llvm/test/MC/EraVM/decoding/ptr-instructions.txt
@@ -11,14 +11,14 @@
 [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0xa0]
 [0x00,0x00,0x00,0x2a,0x03,0x20,0x04,0x00]
 [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0xd0]
-# CHECK:  ptr.add       r1, r2, r3
-# CHECK:  ptr.sub       r1, r2, r3
-# CHECK:  ptr.shrink    r1, r2, r3
-# CHECK:  ptr.pack      r1, r2, r3
-# CHECK:  ptr.add.s     42, r2, r3
-# CHECK:  ptr.sub.s     42, r2, r3
-# CHECK:  ptr.shrink.s  42, r2, r3
-# CHECK:  ptr.pack.s    42, r2, r3
+# CHECK:  addp      r1, r2, r3
+# CHECK:  subp      r1, r2, r3
+# CHECK:  shrnk     r1, r2, r3
+# CHECK:  pack      r1, r2, r3
+# CHECK:  addp.s    42, r2, r3
+# CHECK:  subp.s    42, r2, r3
+# CHECK:  shrnk.s   42, r2, r3
+# CHECK:  pack.s    42, r2, r3
 
 # operands (non-swapped version: 4 src modes x 4 dst modes)
 [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x4f]
@@ -37,22 +37,22 @@
 [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x69]
 [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x61]
 [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x59]
-# CHECK:  ptr.add       r1, r2, r3
-# CHECK:  ptr.add       stack[1 + r1], r2, r3
-# CHECK:  ptr.add       stack-[1 + r1], r2, r3
-# CHECK:  ptr.add       stack-=[1 + r1], r2, r3
-# CHECK:  ptr.add       r1, r2, stack[1 + r3]
-# CHECK:  ptr.add       stack[1 + r1], r2, stack[1 + r3]
-# CHECK:  ptr.add       stack-[1 + r1], r2, stack[1 + r3]
-# CHECK:  ptr.add       stack-=[1 + r1], r2, stack[1 + r3]
-# CHECK:  ptr.add       r1, r2, stack-[1 + r3]
-# CHECK:  ptr.add       stack[1 + r1], r2, stack-[1 + r3]
-# CHECK:  ptr.add       stack-[1 + r1], r2, stack-[1 + r3]
-# CHECK:  ptr.add       stack-=[1 + r1], r2, stack-[1 + r3]
-# CHECK:  ptr.add       r1, r2, stack+=[1 + r3]
-# CHECK:  ptr.add       stack[1 + r1], r2, stack+=[1 + r3]
-# CHECK:  ptr.add       stack-[1 + r1], r2, stack+=[1 + r3]
-# CHECK:  ptr.add       stack-=[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  addp      r1, r2, r3
+# CHECK:  addp      stack[1 + r1], r2, r3
+# CHECK:  addp      stack-[1 + r1], r2, r3
+# CHECK:  addp      stack-=[1 + r1], r2, r3
+# CHECK:  addp      r1, r2, stack[1 + r3]
+# CHECK:  addp      stack[1 + r1], r2, stack[1 + r3]
+# CHECK:  addp      stack-[1 + r1], r2, stack[1 + r3]
+# CHECK:  addp      stack-=[1 + r1], r2, stack[1 + r3]
+# CHECK:  addp      r1, r2, stack-[1 + r3]
+# CHECK:  addp      stack[1 + r1], r2, stack-[1 + r3]
+# CHECK:  addp      stack-[1 + r1], r2, stack-[1 + r3]
+# CHECK:  addp      stack-=[1 + r1], r2, stack-[1 + r3]
+# CHECK:  addp      r1, r2, stack+=[1 + r3]
+# CHECK:  addp      stack[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  addp      stack-[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  addp      stack-=[1 + r1], r2, stack+=[1 + r3]
 
 # operands (swapped version: 6 src modes x 4 dst modes)
 [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x50]
@@ -79,27 +79,27 @@
 [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x62]
 [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5a]
 [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x7a]
-# CHECK:  ptr.add.s    r1, r2, r3
-# CHECK:  ptr.add.s    42, r2, r3
-# CHECK:  ptr.add.s    stack[1 + r1], r2, r3
-# CHECK:  ptr.add.s    stack-[1 + r1], r2, r3
-# CHECK:  ptr.add.s    stack-=[1 + r1], r2, r3
-# CHECK:  ptr.add.s    code[r1+1], r2, r3
-# CHECK:  ptr.add.s    r1, r2, stack[1 + r3]
-# CHECK:  ptr.add.s    42, r2, stack[1 + r3]
-# CHECK:  ptr.add.s    stack[1 + r1], r2, stack[1 + r3]
-# CHECK:  ptr.add.s    stack-[1 + r1], r2, stack[1 + r3]
-# CHECK:  ptr.add.s    stack-=[1 + r1], r2, stack[1 + r3]
-# CHECK:  ptr.add.s    code[r1+1], r2, stack[1 + r3]
-# CHECK:  ptr.add.s    r1, r2, stack-[1 + r3]
-# CHECK:  ptr.add.s    42, r2, stack-[1 + r3]
-# CHECK:  ptr.add.s    stack[1 + r1], r2, stack-[1 + r3]
-# CHECK:  ptr.add.s    stack-[1 + r1], r2, stack-[1 + r3]
-# CHECK:  ptr.add.s    stack-=[1 + r1], r2, stack-[1 + r3]
-# CHECK:  ptr.add.s    code[r1+1], r2, stack-[1 + r3]
-# CHECK:  ptr.add.s    r1, r2, stack+=[1 + r3]
-# CHECK:  ptr.add.s    42, r2, stack+=[1 + r3]
-# CHECK:  ptr.add.s    stack[1 + r1], r2, stack+=[1 + r3]
-# CHECK:  ptr.add.s    stack-[1 + r1], r2, stack+=[1 + r3]
-# CHECK:  ptr.add.s    stack-=[1 + r1], r2, stack+=[1 + r3]
-# CHECK:  ptr.add.s    code[r1+1], r2, stack+=[1 + r3]
+# CHECK:  addp.s    r1, r2, r3
+# CHECK:  addp.s    42, r2, r3
+# CHECK:  addp.s    stack[1 + r1], r2, r3
+# CHECK:  addp.s    stack-[1 + r1], r2, r3
+# CHECK:  addp.s    stack-=[1 + r1], r2, r3
+# CHECK:  addp.s    code[r1+1], r2, r3
+# CHECK:  addp.s    r1, r2, stack[1 + r3]
+# CHECK:  addp.s    42, r2, stack[1 + r3]
+# CHECK:  addp.s    stack[1 + r1], r2, stack[1 + r3]
+# CHECK:  addp.s    stack-[1 + r1], r2, stack[1 + r3]
+# CHECK:  addp.s    stack-=[1 + r1], r2, stack[1 + r3]
+# CHECK:  addp.s    code[r1+1], r2, stack[1 + r3]
+# CHECK:  addp.s    r1, r2, stack-[1 + r3]
+# CHECK:  addp.s    42, r2, stack-[1 + r3]
+# CHECK:  addp.s    stack[1 + r1], r2, stack-[1 + r3]
+# CHECK:  addp.s    stack-[1 + r1], r2, stack-[1 + r3]
+# CHECK:  addp.s    stack-=[1 + r1], r2, stack-[1 + r3]
+# CHECK:  addp.s    code[r1+1], r2, stack-[1 + r3]
+# CHECK:  addp.s    r1, r2, stack+=[1 + r3]
+# CHECK:  addp.s    42, r2, stack+=[1 + r3]
+# CHECK:  addp.s    stack[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  addp.s    stack-[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  addp.s    stack-=[1 + r1], r2, stack+=[1 + r3]
+# CHECK:  addp.s    code[r1+1], r2, stack+=[1 + r3]
diff --git a/llvm/test/MC/EraVM/decoding/returns.txt b/llvm/test/MC/EraVM/decoding/returns.txt
index 851e21f0e21b..6931d7b3c7b3 100644
--- a/llvm/test/MC/EraVM/decoding/returns.txt
+++ b/llvm/test/MC/EraVM/decoding/returns.txt
@@ -13,16 +13,16 @@
 [0x00,0x00,0xff,0xff,0x00,0x01,0x04,0x30]
 [0x00,0x00,0xff,0xff,0x00,0x00,0x04,0x32]
 # CHECK:  ret
-# CHECK:  revert
-# CHECK:  panic
-# CHECK:  ret.ok.to_label      r1, 65535
-# CHECK:  ret.revert.to_label  r1, 65535
-# CHECK:  ret.panic.to_label   65535
+# CHECK:  rev
+# CHECK:  pnc
+# CHECK:  retl  65535
+# CHECK:  revl  65535
+# CHECK:  pncl  65535
 
 # far
 [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x2d]
 [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x2f]
 [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x31]
-# CHECK:  ret.ok      r3
-# CHECK:  ret.revert  r3
-# CHECK:  panic
+# CHECK:  ret   r3
+# CHECK:  rev   r3
+# CHECK:  pnc
diff --git a/llvm/test/MC/EraVM/decoding/sp-changes.txt b/llvm/test/MC/EraVM/decoding/sp-changes.txt
index 7606836ad3ad..e94d5468e32d 100644
--- a/llvm/test/MC/EraVM/decoding/sp-changes.txt
+++ b/llvm/test/MC/EraVM/decoding/sp-changes.txt
@@ -9,16 +9,16 @@
 [0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x02]
 [0x00,0x2a,0x00,0x00,0x00,0x00,0x00,0x02]
 [0x00,0x2a,0x00,0x00,0x01,0x00,0x00,0x02]
-# CHECK:  nop stack+=[0 + r0]
-# CHECK:  nop stack+=[0 + r1]
-# CHECK:  nop stack+=[42 + r0]
-# CHECK:  nop stack+=[42 + r1]
+# CHECK:  incsp r0
+# CHECK:  incsp r1
+# CHECK:  incsp 42
+# CHECK:  incsp r1+42
 
 [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05]
 [0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x05]
 [0x00,0x00,0x00,0x2a,0x00,0x00,0x00,0x05]
 [0x00,0x00,0x00,0x2a,0x00,0x01,0x00,0x05]
-# CHECK:  nop stack-=[0 + r0]
-# CHECK:  nop stack-=[0 + r1]
-# CHECK:  nop stack-=[42 + r0]
-# CHECK:  nop stack-=[42 + r1]
+# CHECK:  decsp r0
+# CHECK:  decsp r1
+# CHECK:  decsp 42
+# CHECK:  decsp r1+42
diff --git a/llvm/test/MC/EraVM/decoding/storage.txt b/llvm/test/MC/EraVM/decoding/storage.txt
index c9308735da66..1217005d26db 100644
--- a/llvm/test/MC/EraVM/decoding/storage.txt
+++ b/llvm/test/MC/EraVM/decoding/storage.txt
@@ -4,10 +4,10 @@
 
 [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x1a]
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1b]
-# CHECK:  sload       r3, r4
-# CHECK:  sstore      r3, r4
+# CHECK:  lds       r3, r4
+# CHECK:  sts       r3, r4
 
 [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x46]
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x47]
-# CHECK:  tload       r3, r4
-# CHECK:  tstore      r3, r4
+# CHECK:  ldt       r3, r4
+# CHECK:  stt       r3, r4
diff --git a/llvm/test/MC/EraVM/decoding/uma.txt b/llvm/test/MC/EraVM/decoding/uma.txt
index c81da1189ee8..9a4d6a37adeb 100644
--- a/llvm/test/MC/EraVM/decoding/uma.txt
+++ b/llvm/test/MC/EraVM/decoding/uma.txt
@@ -5,24 +5,24 @@
 # mnemonics
 [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x3b]
 [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x3c]
-# CHECK:  ld        r3, r4
-# CHECK:  ld.inc    r3, r4, r5
+# CHECK:  ldp       r3, r4
+# CHECK:  ldpi      r3, r4, r5
 [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x33]
 [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x37]
 [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x34]
 [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x38]
-# CHECK:  ld.1      r3, r4
-# CHECK:  ld.2      r3, r4
-# CHECK:  ld.1.inc  r3, r4, r5
-# CHECK:  ld.2.inc  r3, r4, r5
+# CHECK:  ldm.h     r3, r4
+# CHECK:  ldm.ah    r3, r4
+# CHECK:  ldmi.h    r3, r4, r5
+# CHECK:  ldmi.ah   r3, r4, r5
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x35]
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x39]
 [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x36]
 [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x3a]
-# CHECK:  st.1      r3, r4
-# CHECK:  st.2      r3, r4
-# CHECK:  st.1.inc  r3, r4, r5
-# CHECK:  st.2.inc  r3, r4, r5
+# CHECK:  stm.h     r3, r4
+# CHECK:  stm.ah    r3, r4
+# CHECK:  stmi.h    r3, r4, r5
+# CHECK:  stmi.ah   r3, r4, r5
 [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x48]
 [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x49]
 [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x4c]
@@ -41,14 +41,14 @@
 [0x00,0x00,0x00,0x2a,0x00,0x40,0x04,0x43]
 [0x00,0x00,0x00,0x2a,0x05,0x40,0x04,0x40]
 [0x00,0x00,0x00,0x2a,0x05,0x40,0x04,0x44]
-# CHECK:  ld.1      42, r4
-# CHECK:  ld.2      42, r4
-# CHECK:  ld.1.inc  42, r4, r5
-# CHECK:  ld.2.inc  42, r4, r5
-# CHECK:  st.1      42, r4
-# CHECK:  st.2      42, r4
-# CHECK:  st.1.inc  42, r4, r5
-# CHECK:  st.2.inc  42, r4, r5
+# CHECK:  ldm.h     42, r4
+# CHECK:  ldm.ah    42, r4
+# CHECK:  ldmi.h    42, r4, r5
+# CHECK:  ldmi.ah   42, r4, r5
+# CHECK:  stm.h     42, r4
+# CHECK:  stm.ah    42, r4
+# CHECK:  stmi.h    42, r4, r5
+# CHECK:  stmi.ah   42, r4, r5
 [0x00,0x00,0x00,0x2a,0x04,0x00,0x04,0x4a]
 [0x00,0x00,0x00,0x2a,0x54,0x00,0x04,0x4b]
 [0x00,0x00,0x00,0x2a,0x00,0x40,0x04,0x4e]
diff --git a/llvm/test/MC/EraVM/encoding/data.ll b/llvm/test/MC/EraVM/encoding/data.ll
index d6a46a5a9f20..96585cd3e49d 100644
--- a/llvm/test/MC/EraVM/encoding/data.ll
+++ b/llvm/test/MC/EraVM/encoding/data.ll
@@ -18,7 +18,7 @@ define void @set(ptr addrspace(3) %p, i256 %v1, i256 %v2) nounwind {
 }
 ; CHECK-LABEL: set:
 ; CHECK:         add     r2, r0, stack[@var1]
-; CHECK-NEXT:    ptr.add r1, r0, stack[@ptr]
+; CHECK-NEXT:    addp    r1, r0, stack[@ptr]
 ; CHECK-NEXT:    add     r3, r0, stack[@var2]
 ; CHECK-NEXT:    ret
 
@@ -34,7 +34,7 @@ define ptr addrspace(3) @get() nounwind {
 ; CHECK-LABEL: get:
 ; CHECK:         add     stack[@var2], r0, r1
 ; CHECK-NEXT:    mul     stack[@var1], r1, r1, r0
-; CHECK-NEXT:    ptr.add stack[@ptr], r1, r1
+; CHECK-NEXT:    addp    stack[@ptr], r1, r1
 ; CHECK-NEXT:    ret
 
 ; CHECK:       .data
diff --git a/llvm/test/MC/EraVM/encoding/events.s b/llvm/test/MC/EraVM/encoding/events.s
index a2247f3d0f6d..7b64f57d840f 100644
--- a/llvm/test/MC/EraVM/encoding/events.s
+++ b/llvm/test/MC/EraVM/encoding/events.s
@@ -3,15 +3,15 @@
   .text
 foo:
 
-  event           r3, r4
-  event.first     r3, r4
-  to_l1           r3, r4
-  to_l1.first     r3, r4
+  log       r3, r4
+  log.i     r3, r4
+  logL1     r3, r4
+  logL1.i   r3, r4
 
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  event r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1e]
-; CHECK:  event.first   r3, r4                  ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1f]
-; CHECK:  to_l1 r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1c]
-; CHECK:  to_l1.first   r3, r4                  ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1d]
+; CHECK:  log       r3, r4                  ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1e]
+; CHECK:  log.i     r3, r4                  ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1f]
+; CHECK:  logL1     r3, r4                  ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1c]
+; CHECK:  logL1.i   r3, r4                  ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1d]
diff --git a/llvm/test/MC/EraVM/encoding/far-calls.s b/llvm/test/MC/EraVM/encoding/far-calls.s
index 0bba8795db4a..1675e2c4d3ff 100644
--- a/llvm/test/MC/EraVM/encoding/far-calls.s
+++ b/llvm/test/MC/EraVM/encoding/far-calls.s
@@ -6,50 +6,50 @@ handler:
 
 foo:
 
-  far_call                      r3, r4, @handler
-  far_call.delegate             r3, r4, @handler
-  far_call.mimic                r3, r4, @handler
+  callf          r3, r4, @handler
+  calld          r3, r4, @handler
+  callm          r3, r4, @handler
 
-  far_call.static               r3, r4, @handler
-  far_call.delegate.static      r3, r4, @handler
-  far_call.mimic.static         r3, r4, @handler
+  callf.st       r3, r4, @handler
+  calld.st       r3, r4, @handler
+  callm.st       r3, r4, @handler
 
-  far_call.shard                r3, r4, @handler
-  far_call.delegate.shard       r3, r4, @handler
-  far_call.mimic.shard          r3, r4, @handler
+  callf.sh       r3, r4, @handler
+  calld.sh       r3, r4, @handler
+  callm.sh       r3, r4, @handler
 
-  far_call.st.sh               r3, r4, @handler
-  far_call.delegate.st.sh      r3, r4, @handler
-  far_call.mimic.st.sh         r3, r4, @handler
+  callf.st.sh    r3, r4, @handler
+  calld.st.sh    r3, r4, @handler
+  callm.st.sh    r3, r4, @handler
 
 ; CHECK:  .text
 ; CHECK:handler:
 ; CHECK:foo:
 
-; CHECK:  far_call           r3, r4, @handler                ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x21]
+; CHECK:  callf          r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x21]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.delegate  r3, r4, @handler                ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x25]
+; CHECK:  calld          r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x25]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.mimic     r3, r4, @handler                ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x29]
+; CHECK:  callm          r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x29]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
 
-; CHECK:  far_call.static            r3, r4, @handler        ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x23]
+; CHECK:  callf.st       r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x23]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.delegate.static   r3, r4, @handler        ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x27]
+; CHECK:  calld.st       r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x27]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.mimic.static      r3, r4, @handler        ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x2b]
+; CHECK:  callm.st       r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x2b]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
 
-; CHECK:  far_call.shard             r3, r4, @handler        ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x22]
+; CHECK:  callf.sh       r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x22]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.delegate.shard    r3, r4, @handler        ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x26]
+; CHECK:  calld.sh       r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x26]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.mimic.shard       r3, r4, @handler        ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x2a]
+; CHECK:  callm.sh       r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x2a]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
 
-; CHECK:  far_call.st.sh                 r3, r4, @handler    ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x24]
+; CHECK:  callf.st.sh    r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x24]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.delegate.st.sh        r3, r4, @handler    ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x28]
+; CHECK:  calld.st.sh    r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x28]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
-; CHECK:  far_call.mimic.st.sh           r3, r4, @handler    ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x2c]
+; CHECK:  callm.st.sh    r3, r4, @handler  ; encoding: [0x00,0x00,A,A,0x00,0x43,0x04,0x2c]
 ; CHECK:  ;   fixup A - offset: 2, value: @handler, kind: fixup_16_scale_8
diff --git a/llvm/test/MC/EraVM/encoding/misc.s b/llvm/test/MC/EraVM/encoding/misc.s
index 85e6208cc9a7..3c987d6091e0 100644
--- a/llvm/test/MC/EraVM/encoding/misc.s
+++ b/llvm/test/MC/EraVM/encoding/misc.s
@@ -3,31 +3,32 @@
   .text
 foo:
 
-  log.decommit  r3, r4, r5
-  precompile    r3, r4, r5
-  context.this                  r3
-  context.caller                r3
-  context.code_source           r3
-  context.gas_left              r3
-  context.sp                    r3
-  context.get_context_u128      r3
-  context.set_context_u128      r3
-  context.meta                  r3
-  context.inc_tx_num
-  context.set_gas_per_pubdata   r3
+  dcmt    r3, r4, r5
+  callp   r3, r4, r5
+  this    r3
+  par     r3
+  code    r3
+  ergs    r3
+  sp      r3
+  ldvl    r3
+  stvl    r3
+  meta    r3
+  inctx
+; removed in VM 1.5.0
+  stpub   r3
 
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  log.decommit  r3, r4, r5              ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x45]
-; CHECK:  precompile    r3, r4, r5              ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x20]
-; CHECK:  context.this  r3                      ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x10]
-; CHECK:  context.caller        r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x11]
-; CHECK:  context.code_source   r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x12]
-; CHECK:  context.gas_left     r3               ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x14]
-; CHECK:  context.sp    r3                      ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x15]
-; CHECK:  context.get_context_u128      r3      ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x16]
-; CHECK:  context.set_context_u128      r3      ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x17]
-; CHECK:  context.meta  r3                      ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x13]
-; CHECK:  context.inc_tx_num                    ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x19]
-; CHECK:  context.set_gas_per_pubdata  r3       ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x18]
+; CHECK:  dcmt    r3, r4, r5    ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x45]
+; CHECK:  callp   r3, r4, r5    ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x20]
+; CHECK:  this    r3            ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x10]
+; CHECK:  par     r3            ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x11]
+; CHECK:  code    r3            ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x12]
+; CHECK:  ergs    r3            ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x14]
+; CHECK:  sp      r3            ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x15]
+; CHECK:  ldvl    r3            ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x16]
+; CHECK:  stvl    r3            ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x17]
+; CHECK:  meta    r3            ; encoding: [0x00,0x00,0x00,0x00,0x03,0x00,0x04,0x13]
+; CHECK:  inctx                 ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x19]
+; CHECK:  stpub  r3             ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x18]
diff --git a/llvm/test/MC/EraVM/encoding/named-constants.s b/llvm/test/MC/EraVM/encoding/named-constants.s
index 8374e1786d70..dff3a9c0e2b2 100644
--- a/llvm/test/MC/EraVM/encoding/named-constants.s
+++ b/llvm/test/MC/EraVM/encoding/named-constants.s
@@ -34,10 +34,10 @@ foo:
   div    code[@constant + r1 + 42], r2, stack+=[r3 + 123], r4
 
   ; pointer arithmetics (only swapped version is supported)
-  ptr.add.s    code[@constant + r1 + 42], r2, r3
-  ptr.add.s    code[@constant + r1 + 42], r2, stack[r3 + 123]
-  ptr.add.s    code[@constant + r1 + 42], r2, stack-[r3 + 123]
-  ptr.add.s    code[@constant + r1 + 42], r2, stack+=[r3 + 123]
+  addp.s    code[@constant + r1 + 42], r2, r3
+  addp.s    code[@constant + r1 + 42], r2, stack[r3 + 123]
+  addp.s    code[@constant + r1 + 42], r2, stack-[r3 + 123]
+  addp.s    code[@constant + r1 + 42], r2, stack+=[r3 + 123]
 
   ; jumps
   jump       code[@jump_table + 42]
@@ -86,13 +86,13 @@ foo:
 ; CHECK:  div   code[@constant+r1+42], r2, stack+=[123 + r3], r4 ; encoding: [0x00,0x7b,A,0x2a'A',0x43,0x21,0x01,0x2d]
 ; CHECK:  ;   fixup A - offset: 2, value: @constant, kind: fixup_16_scale_32
 
-; CHECK:  ptr.add.s     code[@constant+r1+42], r2, r3 ; encoding: [0x00,0x00,A,0x2a'A',0x03,0x21,0x03,0x78]
+; CHECK:  addp.s     code[@constant+r1+42], r2, r3 ; encoding: [0x00,0x00,A,0x2a'A',0x03,0x21,0x03,0x78]
 ; CHECK:  ;   fixup A - offset: 2, value: @constant, kind: fixup_16_scale_32
-; CHECK:  ptr.add.s     code[@constant+r1+42], r2, stack[123 + r3] ; encoding: [0x00,0x7b,A,0x2a'A',0x03,0x21,0x03,0x7e]
+; CHECK:  addp.s     code[@constant+r1+42], r2, stack[123 + r3] ; encoding: [0x00,0x7b,A,0x2a'A',0x03,0x21,0x03,0x7e]
 ; CHECK:  ;   fixup A - offset: 2, value: @constant, kind: fixup_16_scale_32
-; CHECK:  ptr.add.s     code[@constant+r1+42], r2, stack-[123 + r3] ; encoding: [0x00,0x7b,A,0x2a'A',0x03,0x21,0x03,0x7c]
+; CHECK:  addp.s     code[@constant+r1+42], r2, stack-[123 + r3] ; encoding: [0x00,0x7b,A,0x2a'A',0x03,0x21,0x03,0x7c]
 ; CHECK:  ;   fixup A - offset: 2, value: @constant, kind: fixup_16_scale_32
-; CHECK:  ptr.add.s     code[@constant+r1+42], r2, stack+=[123 + r3] ; encoding: [0x00,0x7b,A,0x2a'A',0x03,0x21,0x03,0x7a]
+; CHECK:  addp.s     code[@constant+r1+42], r2, stack+=[123 + r3] ; encoding: [0x00,0x7b,A,0x2a'A',0x03,0x21,0x03,0x7a]
 ; CHECK:  ;   fixup A - offset: 2, value: @constant, kind: fixup_16_scale_32
 
 ; CHECK:  jump  code[@jump_table+42]                 ; encoding: [0x00,0x00,A,0x2a'A',0x00,0x00,0x01,0x3e]
diff --git a/llvm/test/MC/EraVM/encoding/near-calls.s b/llvm/test/MC/EraVM/encoding/near-calls.s
index 169b94dc9420..345d88aca5b8 100644
--- a/llvm/test/MC/EraVM/encoding/near-calls.s
+++ b/llvm/test/MC/EraVM/encoding/near-calls.s
@@ -8,23 +8,25 @@ exception_handler:
 foo:
 
 ; 3-operand form
-  near_call      r3, @callee, @exception_handler
+  call      r3, @callee, @exception_handler
 ; 2-operand form
-  near_call      r3, @callee
+  call      r3, @callee
 ; 1-operand form
-  near_call      @callee
+  call      @callee
+
+; COM: Added {{[ \t]}} to prevent matching obsolete near_call mnemonic.
 
 ; CHECK:  .text
 ; CHECK:callee:
 ; CHECK:exception_handler:
 ; CHECK:foo:
 
-; CHECK:  near_call     r3, @callee, @exception_handler              ; encoding: [B,B,A,A,0x00,0x03,0x04,0x0f]
+; CHECK:  {{[ \t]}}call     r3, @callee, @exception_handler              ; encoding: [B,B,A,A,0x00,0x03,0x04,0x0f]
 ; CHECK:  ;   fixup A - offset: 2, value: @callee, kind: fixup_16_scale_8
 ; CHECK:  ;   fixup B - offset: 0, value: @exception_handler, kind: fixup_16_scale_8
-; CHECK:  near_call     r3,     @callee,        @DEFAULT_UNWIND_DEST ; encoding: [B,B,A,A,0x00,0x03,0x04,0x0f]
+; CHECK:  {{[ \t]}}call     r3,     @callee,        @DEFAULT_UNWIND_DEST ; encoding: [B,B,A,A,0x00,0x03,0x04,0x0f]
 ; CHECK:  ;   fixup A - offset: 2, value: @callee, kind: fixup_16_scale_8
 ; CHECK:  ;   fixup B - offset: 0, value: @DEFAULT_UNWIND_DEST, kind: fixup_16_scale_8
-; CHECK:  near_call     @callee,        @DEFAULT_UNWIND_DEST         ; encoding: [B,B,A,A,0x00,0x00,0x04,0x0f]
+; CHECK:  {{[ \t]}}call     @callee,        @DEFAULT_UNWIND_DEST         ; encoding: [B,B,A,A,0x00,0x00,0x04,0x0f]
 ; CHECK:  ;   fixup A - offset: 2, value: @callee, kind: fixup_16_scale_8
 ; CHECK:  ;   fixup B - offset: 0, value: @DEFAULT_UNWIND_DEST, kind: fixup_16_scale_8
diff --git a/llvm/test/MC/EraVM/encoding/ptr-instructions.s b/llvm/test/MC/EraVM/encoding/ptr-instructions.s
index 3a3a2ce3498c..1a28b4f3ad2f 100644
--- a/llvm/test/MC/EraVM/encoding/ptr-instructions.s
+++ b/llvm/test/MC/EraVM/encoding/ptr-instructions.s
@@ -4,109 +4,109 @@
 foo:
 
 ; mnemonics (incl. ".s" modifier)
-  ptr.add       r1, r2, r3
-  ptr.sub       r1, r2, r3
-  ptr.shrink    r1, r2, r3
-  ptr.pack      r1, r2, r3
-  ptr.add.s     42, r2, r3
-  ptr.sub.s     42, r2, r3
-  ptr.shrink.s  42, r2, r3
-  ptr.pack.s    42, r2, r3
+  addp      r1, r2, r3
+  subp      r1, r2, r3
+  shrnk     r1, r2, r3
+  pack      r1, r2, r3
+  addp.s    42, r2, r3
+  subp.s    42, r2, r3
+  shrnk.s   42, r2, r3
+  pack.s    42, r2, r3
 
 ; operands (non-swapped version: 4 src modes x 4 dst modes)
-  ptr.add       r1, r2, r3
-  ptr.add       stack[r1 + 1], r2, r3
-  ptr.add       stack-[r1 + 1], r2, r3
-  ptr.add       stack-=[r1 + 1], r2, r3
-  ptr.add       r1, r2, stack[r3 + 1]
-  ptr.add       stack[r1 + 1], r2, stack[r3 + 1]
-  ptr.add       stack-[r1 + 1], r2, stack[r3 + 1]
-  ptr.add       stack-=[r1 + 1], r2, stack[r3 + 1]
-  ptr.add       r1, r2, stack-[r3 + 1]
-  ptr.add       stack[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add       stack-[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add       stack-=[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add       r1, r2, stack+=[r3 + 1]
-  ptr.add       stack[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add       stack-[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add       stack-=[r1 + 1], r2, stack+=[r3 + 1]
+  addp      r1, r2, r3
+  addp      stack[r1 + 1], r2, r3
+  addp      stack-[r1 + 1], r2, r3
+  addp      stack-=[r1 + 1], r2, r3
+  addp      r1, r2, stack[r3 + 1]
+  addp      stack[r1 + 1], r2, stack[r3 + 1]
+  addp      stack-[r1 + 1], r2, stack[r3 + 1]
+  addp      stack-=[r1 + 1], r2, stack[r3 + 1]
+  addp      r1, r2, stack-[r3 + 1]
+  addp      stack[r1 + 1], r2, stack-[r3 + 1]
+  addp      stack-[r1 + 1], r2, stack-[r3 + 1]
+  addp      stack-=[r1 + 1], r2, stack-[r3 + 1]
+  addp      r1, r2, stack+=[r3 + 1]
+  addp      stack[r1 + 1], r2, stack+=[r3 + 1]
+  addp      stack-[r1 + 1], r2, stack+=[r3 + 1]
+  addp      stack-=[r1 + 1], r2, stack+=[r3 + 1]
 
 ; operands (swapped version: 6 src modes x 4 dst modes)
-  ptr.add.s    r1, r2, r3
-  ptr.add.s    42, r2, r3
-  ptr.add.s    stack[r1 + 1], r2, r3
-  ptr.add.s    stack-[r1 + 1], r2, r3
-  ptr.add.s    stack-=[r1 + 1], r2, r3
-  ptr.add.s    code[r1 + 1], r2, r3
-  ptr.add.s    r1, r2, stack[r3 + 1]
-  ptr.add.s    42, r2, stack[r3 + 1]
-  ptr.add.s    stack[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    stack-[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    stack-=[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    code[r1 + 1], r2, stack[r3 + 1]
-  ptr.add.s    r1, r2, stack-[r3 + 1]
-  ptr.add.s    42, r2, stack-[r3 + 1]
-  ptr.add.s    stack[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    stack-[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    stack-=[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    code[r1 + 1], r2, stack-[r3 + 1]
-  ptr.add.s    r1, r2, stack+=[r3 + 1]
-  ptr.add.s    42, r2, stack+=[r3 + 1]
-  ptr.add.s    stack[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add.s    stack-[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add.s    stack-=[r1 + 1], r2, stack+=[r3 + 1]
-  ptr.add.s    code[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s    r1, r2, r3
+  addp.s    42, r2, r3
+  addp.s    stack[r1 + 1], r2, r3
+  addp.s    stack-[r1 + 1], r2, r3
+  addp.s    stack-=[r1 + 1], r2, r3
+  addp.s    code[r1 + 1], r2, r3
+  addp.s    r1, r2, stack[r3 + 1]
+  addp.s    42, r2, stack[r3 + 1]
+  addp.s    stack[r1 + 1], r2, stack[r3 + 1]
+  addp.s    stack-[r1 + 1], r2, stack[r3 + 1]
+  addp.s    stack-=[r1 + 1], r2, stack[r3 + 1]
+  addp.s    code[r1 + 1], r2, stack[r3 + 1]
+  addp.s    r1, r2, stack-[r3 + 1]
+  addp.s    42, r2, stack-[r3 + 1]
+  addp.s    stack[r1 + 1], r2, stack-[r3 + 1]
+  addp.s    stack-[r1 + 1], r2, stack-[r3 + 1]
+  addp.s    stack-=[r1 + 1], r2, stack-[r3 + 1]
+  addp.s    code[r1 + 1], r2, stack-[r3 + 1]
+  addp.s    r1, r2, stack+=[r3 + 1]
+  addp.s    42, r2, stack+=[r3 + 1]
+  addp.s    stack[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s    stack-[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s    stack-=[r1 + 1], r2, stack+=[r3 + 1]
+  addp.s    code[r1 + 1], r2, stack+=[r3 + 1]
 
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  ptr.add       r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x4f]
-; CHECK:  ptr.sub       r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x7f]
-; CHECK:  ptr.shrink    r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0xdf]
-; CHECK:  ptr.pack      r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0xaf]
-; CHECK:  ptr.add.s     42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0x70]
-; CHECK:  ptr.sub.s     42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0xa0]
-; CHECK:  ptr.shrink.s  42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x04,0x00]
-; CHECK:  ptr.pack.s    42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0xd0]
+; CHECK:  addp      r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x4f]
+; CHECK:  subp      r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x7f]
+; CHECK:  shrnk     r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0xdf]
+; CHECK:  pack      r1, r2, r3              ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0xaf]
+; CHECK:  addp.s    42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0x70]
+; CHECK:  subp.s    42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0xa0]
+; CHECK:  shrnk.s   42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x04,0x00]
+; CHECK:  pack.s    42, r2, r3              ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0xd0]
 
-; CHECK:  ptr.add       r1, r2, r3                           ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x4f]
-; CHECK:  ptr.add       stack[1 + r1], r2, r3                ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x67]
-; CHECK:  ptr.add       stack-[1 + r1], r2, r3               ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x5f]
-; CHECK:  ptr.add       stack-=[1 + r1], r2, r3              ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x57]
-; CHECK:  ptr.add       r1, r2, stack[1 + r3]                ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x55]
-; CHECK:  ptr.add       stack[1 + r1], r2, stack[1 + r3]     ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6d]
-; CHECK:  ptr.add       stack-[1 + r1], r2, stack[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x65]
-; CHECK:  ptr.add       stack-=[1 + r1], r2, stack[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5d]
-; CHECK:  ptr.add       r1, r2, stack-[1 + r3]               ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x53]
-; CHECK:  ptr.add       stack[1 + r1], r2, stack-[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6b]
-; CHECK:  ptr.add       stack-[1 + r1], r2, stack-[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x63]
-; CHECK:  ptr.add       stack-=[1 + r1], r2, stack-[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5b]
-; CHECK:  ptr.add       r1, r2, stack+=[1 + r3]              ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x51]
-; CHECK:  ptr.add       stack[1 + r1], r2, stack+=[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x69]
-; CHECK:  ptr.add       stack-[1 + r1], r2, stack+=[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x61]
-; CHECK:  ptr.add       stack-=[1 + r1], r2, stack+=[1 + r3] ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x59]
+; CHECK:  addp      r1, r2, r3                           ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x4f]
+; CHECK:  addp      stack[1 + r1], r2, r3                ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x67]
+; CHECK:  addp      stack-[1 + r1], r2, r3               ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x5f]
+; CHECK:  addp      stack-=[1 + r1], r2, r3              ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x57]
+; CHECK:  addp      r1, r2, stack[1 + r3]                ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x55]
+; CHECK:  addp      stack[1 + r1], r2, stack[1 + r3]     ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6d]
+; CHECK:  addp      stack-[1 + r1], r2, stack[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x65]
+; CHECK:  addp      stack-=[1 + r1], r2, stack[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5d]
+; CHECK:  addp      r1, r2, stack-[1 + r3]               ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x53]
+; CHECK:  addp      stack[1 + r1], r2, stack-[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6b]
+; CHECK:  addp      stack-[1 + r1], r2, stack-[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x63]
+; CHECK:  addp      stack-=[1 + r1], r2, stack-[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5b]
+; CHECK:  addp      r1, r2, stack+=[1 + r3]              ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x51]
+; CHECK:  addp      stack[1 + r1], r2, stack+=[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x69]
+; CHECK:  addp      stack-[1 + r1], r2, stack+=[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x61]
+; CHECK:  addp      stack-=[1 + r1], r2, stack+=[1 + r3] ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x59]
 
-; CHECK:  ptr.add.s     r1, r2, r3                           ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x50]
-; CHECK:  ptr.add.s     42, r2, r3                           ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0x70]
-; CHECK:  ptr.add.s     stack[1 + r1], r2, r3                ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x68]
-; CHECK:  ptr.add.s     stack-[1 + r1], r2, r3               ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x60]
-; CHECK:  ptr.add.s     stack-=[1 + r1], r2, r3              ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x58]
-; CHECK:  ptr.add.s     code[r1+1], r2, r3                   ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x78]
-; CHECK:  ptr.add.s     r1, r2, stack[1 + r3]                ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x56]
-; CHECK:  ptr.add.s     42, r2, stack[1 + r3]                ; encoding: [0x00,0x01,0x00,0x2a,0x03,0x20,0x03,0x76]
-; CHECK:  ptr.add.s     stack[1 + r1], r2, stack[1 + r3]     ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6e]
-; CHECK:  ptr.add.s     stack-[1 + r1], r2, stack[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x66]
-; CHECK:  ptr.add.s     stack-=[1 + r1], r2, stack[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5e]
-; CHECK:  ptr.add.s     code[r1+1], r2, stack[1 + r3]        ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x7e]
-; CHECK:  ptr.add.s     r1, r2, stack-[1 + r3]               ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x54]
-; CHECK:  ptr.add.s     42, r2, stack-[1 + r3]               ; encoding: [0x00,0x01,0x00,0x2a,0x03,0x20,0x03,0x74]
-; CHECK:  ptr.add.s     stack[1 + r1], r2, stack-[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6c]
-; CHECK:  ptr.add.s     stack-[1 + r1], r2, stack-[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x64]
-; CHECK:  ptr.add.s     stack-=[1 + r1], r2, stack-[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5c]
-; CHECK:  ptr.add.s     code[r1+1], r2, stack-[1 + r3]       ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x7c]
-; CHECK:  ptr.add.s     r1, r2, stack+=[1 + r3]              ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x52]
-; CHECK:  ptr.add.s     42, r2, stack+=[1 + r3]              ; encoding: [0x00,0x01,0x00,0x2a,0x03,0x20,0x03,0x72]
-; CHECK:  ptr.add.s     stack[1 + r1], r2, stack+=[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6a]
-; CHECK:  ptr.add.s     stack-[1 + r1], r2, stack+=[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x62]
-; CHECK:  ptr.add.s     stack-=[1 + r1], r2, stack+=[1 + r3] ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5a]
-; CHECK:  ptr.add.s     code[r1+1], r2, stack+=[1 + r3]      ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x7a]
+; CHECK:  addp.s    r1, r2, r3                           ; encoding: [0x00,0x00,0x00,0x00,0x03,0x21,0x03,0x50]
+; CHECK:  addp.s    42, r2, r3                           ; encoding: [0x00,0x00,0x00,0x2a,0x03,0x20,0x03,0x70]
+; CHECK:  addp.s    stack[1 + r1], r2, r3                ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x68]
+; CHECK:  addp.s    stack-[1 + r1], r2, r3               ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x60]
+; CHECK:  addp.s    stack-=[1 + r1], r2, r3              ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x58]
+; CHECK:  addp.s    code[r1+1], r2, r3                   ; encoding: [0x00,0x00,0x00,0x01,0x03,0x21,0x03,0x78]
+; CHECK:  addp.s    r1, r2, stack[1 + r3]                ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x56]
+; CHECK:  addp.s    42, r2, stack[1 + r3]                ; encoding: [0x00,0x01,0x00,0x2a,0x03,0x20,0x03,0x76]
+; CHECK:  addp.s    stack[1 + r1], r2, stack[1 + r3]     ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6e]
+; CHECK:  addp.s    stack-[1 + r1], r2, stack[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x66]
+; CHECK:  addp.s    stack-=[1 + r1], r2, stack[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5e]
+; CHECK:  addp.s    code[r1+1], r2, stack[1 + r3]        ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x7e]
+; CHECK:  addp.s    r1, r2, stack-[1 + r3]               ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x54]
+; CHECK:  addp.s    42, r2, stack-[1 + r3]               ; encoding: [0x00,0x01,0x00,0x2a,0x03,0x20,0x03,0x74]
+; CHECK:  addp.s    stack[1 + r1], r2, stack-[1 + r3]    ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6c]
+; CHECK:  addp.s    stack-[1 + r1], r2, stack-[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x64]
+; CHECK:  addp.s    stack-=[1 + r1], r2, stack-[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5c]
+; CHECK:  addp.s    code[r1+1], r2, stack-[1 + r3]       ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x7c]
+; CHECK:  addp.s    r1, r2, stack+=[1 + r3]              ; encoding: [0x00,0x01,0x00,0x00,0x03,0x21,0x03,0x52]
+; CHECK:  addp.s    42, r2, stack+=[1 + r3]              ; encoding: [0x00,0x01,0x00,0x2a,0x03,0x20,0x03,0x72]
+; CHECK:  addp.s    stack[1 + r1], r2, stack+=[1 + r3]   ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x6a]
+; CHECK:  addp.s    stack-[1 + r1], r2, stack+=[1 + r3]  ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x62]
+; CHECK:  addp.s    stack-=[1 + r1], r2, stack+=[1 + r3] ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x5a]
+; CHECK:  addp.s    code[r1+1], r2, stack+=[1 + r3]      ; encoding: [0x00,0x01,0x00,0x01,0x03,0x21,0x03,0x7a]
diff --git a/llvm/test/MC/EraVM/encoding/returns.s b/llvm/test/MC/EraVM/encoding/returns.s
index da964363f603..3bf68af9fbb9 100644
--- a/llvm/test/MC/EraVM/encoding/returns.s
+++ b/llvm/test/MC/EraVM/encoding/returns.s
@@ -7,31 +7,31 @@ label:
 
 ; near
   ret
-  revert
-  panic
-  ret.ok.to_label     @label
-  ret.revert.to_label  @label
-  ret.panic.to_label   @label
+  rev
+  pnc
+  retl  @label
+  revl  @label
+  pncl  @label
 
 ; far
-  ret.ok      r3
-  ret.revert  r3
-  panic
+  ret   r3
+  rev   r3
+  pnc
 
 ; CHECK:  .text
 ; CHECK:foo:
 ; CHECK:label:
 
 ; CHECK:  ret                                     ; encoding: [0x00,0x00,0x00,0x00,0x00,0x01,0x04,0x2d]
-; CHECK:  revert                                  ; encoding: [0x00,0x00,0x00,0x00,0x00,0x01,0x04,0x2f]
-; CHECK:  panic                                   ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x31]
-; CHECK:  ret.ok.to_label    r1, @label           ; encoding: [0x00,0x00,A,A,0x00,0x01,0x04,0x2e]
+; CHECK:  rev                                     ; encoding: [0x00,0x00,0x00,0x00,0x00,0x01,0x04,0x2f]
+; CHECK:  pnc                                     ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x31]
+; CHECK:  retl  @label                            ; encoding: [0x00,0x00,A,A,0x00,0x01,0x04,0x2e]
 ; CHECK:  ;   fixup A - offset: 2, value: @label, kind: fixup_16_scale_8
-; CHECK:  ret.revert.to_label r1, @label          ; encoding: [0x00,0x00,A,A,0x00,0x01,0x04,0x30]
+; CHECK:  revl  @label                            ; encoding: [0x00,0x00,A,A,0x00,0x01,0x04,0x30]
 ; CHECK:  ;   fixup A - offset: 2, value: @label, kind: fixup_16_scale_8
-; CHECK:  ret.panic.to_label  @label              ; encoding: [0x00,0x00,A,A,0x00,0x00,0x04,0x32]
+; CHECK:  pncl  @label                            ; encoding: [0x00,0x00,A,A,0x00,0x00,0x04,0x32]
 ; CHECK:  ;   fixup A - offset: 2, value: @label, kind: fixup_16_scale_8
 
-; CHECK:  ret.ok      r3                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x2d]
-; CHECK:  ret.revert  r3                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x2f]
-; CHECK:  panic                                   ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x31]
+; CHECK:  ret   r3                                ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x2d]
+; CHECK:  rev   r3                                ; encoding: [0x00,0x00,0x00,0x00,0x00,0x03,0x04,0x2f]
+; CHECK:  pnc                                     ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x31]
diff --git a/llvm/test/MC/EraVM/encoding/sp-changes.s b/llvm/test/MC/EraVM/encoding/sp-changes.s
index 8f45afba3a30..922a63e2144f 100644
--- a/llvm/test/MC/EraVM/encoding/sp-changes.s
+++ b/llvm/test/MC/EraVM/encoding/sp-changes.s
@@ -5,27 +5,27 @@ foo:
 
   nop
 
-  nop       stack+=[r0 + 0]
-  nop       stack+=[r1]
-  nop       stack+=[42]
-  nop       stack+=[r1 + 42]
+  incsp  0
+  incsp  r1
+  incsp  42
+  incsp  r1 + 42
 
-  nop       stack-=[r0 + 0]
-  nop       stack-=[r1]
-  nop       stack-=[42]
-  nop       stack-=[r1 + 42]
+  decsp  0
+  decsp  r1
+  decsp  42
+  decsp  r1 + 42
 
 ; CHECK:  .text
 ; CHECK:foo:
 
 ; CHECK:  nop                                   ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01]
 
-; CHECK:  nop   stack+=[0 + r0]                 ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02]
-; CHECK:  nop   stack+=[0 + r1]                 ; encoding: [0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x02]
-; CHECK:  nop   stack+=[42]                     ; encoding: [0x00,0x2a,0x00,0x00,0x00,0x00,0x00,0x02]
-; CHECK:  nop   stack+=[42 + r1]                ; encoding: [0x00,0x2a,0x00,0x00,0x01,0x00,0x00,0x02]
+; CHECK:  incsp r0                              ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02]
+; CHECK:  incsp r1                              ; encoding: [0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x02]
+; CHECK:  incsp 42                              ; encoding: [0x00,0x2a,0x00,0x00,0x00,0x00,0x00,0x02]
+; CHECK:  incsp r1+42                           ; encoding: [0x00,0x2a,0x00,0x00,0x01,0x00,0x00,0x02]
 
-; CHECK:  nop   stack-=[0 + r0]                 ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05]
-; CHECK:  nop   stack-=[0 + r1]                 ; encoding: [0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x05]
-; CHECK:  nop   stack-=[42]                     ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x00,0x00,0x05]
-; CHECK:  nop   stack-=[42 + r1]                ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x01,0x00,0x05]
+; CHECK:  decsp r0                              ; encoding: [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05]
+; CHECK:  decsp r1                              ; encoding: [0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x05]
+; CHECK:  decsp 42                              ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x00,0x00,0x05]
+; CHECK:  decsp r1+42                           ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x01,0x00,0x05]
diff --git a/llvm/test/MC/EraVM/encoding/storage.s b/llvm/test/MC/EraVM/encoding/storage.s
index 572c9e6f1b4d..d7e1d6af8e5b 100644
--- a/llvm/test/MC/EraVM/encoding/storage.s
+++ b/llvm/test/MC/EraVM/encoding/storage.s
@@ -3,17 +3,17 @@
   .text
 foo:
 
-  sload       r3, r4
-  sstore      r3, r4
+  lds       r3, r4
+  sts       r3, r4
 
-  tload       r3, r4
-  tstore      r3, r4
+  ldt       r3, r4
+  stt       r3, r4
 
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  sload   r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x1a]
-; CHECK:  sstore  r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1b]
+; CHECK:  lds   r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x1a]
+; CHECK:  sts   r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x1b]
 
-; CHECK:  tload   r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x46]
-; CHECK:  tstore  r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x47]
+; CHECK:  ldt   r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x46]
+; CHECK:  stt   r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x47]
diff --git a/llvm/test/MC/EraVM/encoding/uma.s b/llvm/test/MC/EraVM/encoding/uma.s
index 63812c73be95..cae980271a4a 100644
--- a/llvm/test/MC/EraVM/encoding/uma.s
+++ b/llvm/test/MC/EraVM/encoding/uma.s
@@ -4,33 +4,33 @@
 foo:
 
 ; mnemonics
-  ld        r3, r4
-  ld.inc    r3, r4, r5
+  ldp       r3, r4
+  ldpi      r3, r4, r5
 
-  ld.1      r3, r4
-  ld.2      r3, r4
-  ld.1.inc  r3, r4, r5
-  ld.2.inc  r3, r4, r5
+  ldm.h     r3, r4
+  ldm.ah    r3, r4
+  ldmi.h    r3, r4, r5
+  ldmi.ah   r3, r4, r5
 
-  st.1      r3, r4
-  st.2      r3, r4
-  st.1.inc  r3, r4, r5
-  st.2.inc  r3, r4, r5
+  stm.h     r3, r4
+  stm.ah    r3, r4
+  stmi.h    r3, r4, r5
+  stmi.ah   r3, r4, r5
 
-  ldm.st      r3, r4
-  ldmi.st  r3, r4, r5
-  stm.st      r3, r4
-  stmi.st  r3, r4, r5
+  ldm.st    r3, r4
+  ldmi.st   r3, r4, r5
+  stm.st    r3, r4
+  stmi.st   r3, r4, r5
 
 ; operands (instructions operating on "local" heap can accept immediate addresses)
-  ld.1      42, r4
-  ld.2      42, r4
-  ld.1.inc  42, r4, r5
-  ld.2.inc  42, r4, r5
-  st.1      42, r4
-  st.2      42, r4
-  st.1.inc  42, r4, r5
-  st.2.inc  42, r4, r5
+  ldm.h     42, r4
+  ldm.ah    42, r4
+  ldmi.h    42, r4, r5
+  ldmi.ah   42, r4, r5
+  stm.h     42, r4
+  stm.ah    42, r4
+  stmi.h    42, r4, r5
+  stmi.ah   42, r4, r5
   ldm.st    42, r4
   ldmi.st   42, r4, r5
   stm.st    42, r4
@@ -39,32 +39,32 @@ foo:
 ; CHECK:  .text
 ; CHECK:foo:
 
-; CHECK:  ld        r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x3b]
-; CHECK:  ld.inc    r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x3c]
+; CHECK:  ldp       r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x3b]
+; CHECK:  ldpi      r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x3c]
 
-; CHECK:  ld.1      r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x33]
-; CHECK:  ld.2      r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x37]
-; CHECK:  ld.1.inc  r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x34]
-; CHECK:  ld.2.inc  r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x38]
+; CHECK:  ldm.h     r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x33]
+; CHECK:  ldm.ah    r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x37]
+; CHECK:  ldmi.h    r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x34]
+; CHECK:  ldmi.ah   r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x38]
 
-; CHECK:  st.1      r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x35]
-; CHECK:  st.2      r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x39]
-; CHECK:  st.1.inc  r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x36]
-; CHECK:  st.2.inc  r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x3a]
+; CHECK:  stm.h     r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x35]
+; CHECK:  stm.ah    r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x39]
+; CHECK:  stmi.h    r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x36]
+; CHECK:  stmi.ah   r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x3a]
 
 ; CHECK:  ldm.st    r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x04,0x03,0x04,0x48]
 ; CHECK:  ldmi.st   r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x54,0x03,0x04,0x49]
 ; CHECK:  stm.st    r3, r4                          ; encoding: [0x00,0x00,0x00,0x00,0x00,0x43,0x04,0x4c]
 ; CHECK:  stmi.st   r3, r4, r5                      ; encoding: [0x00,0x00,0x00,0x00,0x05,0x43,0x04,0x4d]
 
-; CHECK:  ld.1      42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x04,0x00,0x04,0x3d]
-; CHECK:  ld.2      42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x04,0x00,0x04,0x41]
-; CHECK:  ld.1.inc  42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x54,0x00,0x04,0x3e]
-; CHECK:  ld.2.inc  42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x54,0x00,0x04,0x42]
-; CHECK:  st.1      42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x40,0x04,0x3f]
-; CHECK:  st.2      42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x40,0x04,0x43]
-; CHECK:  st.1.inc  42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x05,0x40,0x04,0x40]
-; CHECK:  st.2.inc  42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x05,0x40,0x04,0x44]
+; CHECK:  ldm.h     42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x04,0x00,0x04,0x3d]
+; CHECK:  ldm.ah    42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x04,0x00,0x04,0x41]
+; CHECK:  ldmi.h    42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x54,0x00,0x04,0x3e]
+; CHECK:  ldmi.ah   42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x54,0x00,0x04,0x42]
+; CHECK:  stm.h     42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x40,0x04,0x3f]
+; CHECK:  stm.ah    42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x40,0x04,0x43]
+; CHECK:  stmi.h    42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x05,0x40,0x04,0x40]
+; CHECK:  stmi.ah   42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x05,0x40,0x04,0x44]
 ; CHECK:  ldm.st    42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x04,0x00,0x04,0x4a]
 ; CHECK:  ldmi.st   42, r4, r5                      ; encoding: [0x00,0x00,0x00,0x2a,0x54,0x00,0x04,0x4b]
 ; CHECK:  stm.st    42, r4                          ; encoding: [0x00,0x00,0x00,0x2a,0x00,0x40,0x04,0x4e]
diff --git a/llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/eravm-basic.ll.expected b/llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/eravm-basic.ll.expected
index 022f3a317842..632be4cd1ac0 100644
--- a/llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/eravm-basic.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/eravm-basic.ll.expected
@@ -6,7 +6,7 @@
 define void @test1(i256 %rs1) {
 ; CHECK-LABEL: test1:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[1 + r0]
+; CHECK-NEXT:    incsp 1
 ; CHECK-NEXT:    add code[@val], r1, stack-[1]
 ; CHECK-NEXT:    ret
   %valptr = alloca i256
@@ -19,7 +19,7 @@ define void @test1(i256 %rs1) {
 define void @test2(i256 %rs1) {
 ; CHECK-LABEL: test2:
 ; CHECK:       ; %bb.0:
-; CHECK-NEXT:    nop stack+=[2 + r0]
+; CHECK-NEXT:    incsp 2
 ; CHECK-NEXT:    add stack-[2], r1, stack-[1]
 ; CHECK-NEXT:    ret
   %valptr = alloca i256