fix: EXLR flagged as error by plugin

parser_library/src/checking/instr_operand.cpp

@@ -212,10 +212,10 @@ hlasm_plugin::parser_library::diagnostic_op machine_operand::get_simple_operand_
             return diagnostic_op::error_M111(instr_name, operand_range);
         case machine_operand_type::IMM: // I
             return diagnostic_op::error_M112(instr_name, operand_range);
-        case machine_operand_type::REG_IMM: // RI
-            return diagnostic_op::error_M113(instr_name, operand_range);
         case machine_operand_type::VEC_REG: // V
             return diagnostic_op::error_M114(instr_name, operand_range);
+        case machine_operand_type::RELOC_IMM: // RI
+            return diagnostic_op::error_M113(instr_name, operand_range);
     }
     assert(false);
     return diagnostic_op::error_I999(instr_name, stmt_range);
@@ -265,7 +265,6 @@ one_operand::one_operand(const one_operand& op)
     value = op.value;
     is_default = op.is_default;
 };
-
 bool one_operand::check(
     diagnostic_op& diag, const machine_operand_format to_check, const std::string& instr_name, const range&) const
 {
@@ -287,7 +286,6 @@ bool one_operand::check(
         }
         return true;
     }
-
     // it is a simple operand
     if (to_check.identifier.is_signed && !is_size_corresponding_signed(value, to_check.identifier.size))
     {
@@ -297,7 +295,7 @@ bool one_operand::check(
             case machine_operand_type::IMM:
                 diag = diagnostic_op::error_M122(instr_name, -boundary, boundary - 1, operand_range);
                 break;
-            case machine_operand_type::REG_IMM:
+            case machine_operand_type::RELOC_IMM:
                 diag = diagnostic_op::error_M123(instr_name, -boundary, boundary - 1, operand_range);
                 break;
             default:
@@ -350,10 +348,6 @@ std::string parameter::to_string() const
             return "M";
         case machine_operand_type::REG:
             return "R";
-        case machine_operand_type::REG_IMM: {
-            ret_val = "RI";
-            break;
-        }
         case machine_operand_type::IMM: {
             ret_val = "I";
             break;
@@ -370,6 +364,10 @@ std::string parameter::to_string() const
             ret_val = "L";
             break;
         }
+        case machine_operand_type::RELOC_IMM: {
+            ret_val = "RI";
+            break;
+        }
         case machine_operand_type::VEC_REG:
             return "V";
         case machine_operand_type::DIS_REG:

parser_library/src/checking/instr_operand.h

@@ -67,14 +67,14 @@ enum class machine_operand_type : uint8_t
 {
     MASK,
     REG,
-    REG_IMM,
     IMM,
     NONE,
     DISPLC,
     BASE,
     LENGTH,
     VEC_REG,
-    DIS_REG
+    DIS_REG,
+    RELOC_IMM
 };
 
 // Describes a component of machine operand format. Specifies allowed values.

parser_library/src/context/instruction.h

@@ -136,10 +136,10 @@ const checking::parameter imm_24s = { true, 24, checking::machine_operand_type::
 const checking::parameter imm_32s = { true, 32, checking::machine_operand_type::IMM };
 const checking::parameter imm_32u = { false, 32, checking::machine_operand_type::IMM };
 const checking::parameter vec_reg = { false, 4, checking::machine_operand_type::VEC_REG };
-const checking::parameter reg_imm_12s = { true, 12, checking::machine_operand_type::REG_IMM };
-const checking::parameter reg_imm_16s = { true, 16, checking::machine_operand_type::REG_IMM };
-const checking::parameter reg_imm_24s = { true, 24, checking::machine_operand_type::REG_IMM };
-const checking::parameter reg_imm_32s = { true, 32, checking::machine_operand_type::REG_IMM };
+const checking::parameter reladdr_imm_12s = { true, 12, checking::machine_operand_type::RELOC_IMM };
+const checking::parameter reladdr_imm_16s = { true, 16, checking::machine_operand_type::RELOC_IMM };
+const checking::parameter reladdr_imm_24s = { true, 24, checking::machine_operand_type::RELOC_IMM };
+const checking::parameter reladdr_imm_32s = { true, 32, checking::machine_operand_type::RELOC_IMM };
 
 /*
 Rules for displacement operands:
@@ -169,10 +169,15 @@ const checking::machine_operand_format imm_32_U = checking::machine_operand_form
 const checking::machine_operand_format vec_reg_4_U = checking::machine_operand_format(vec_reg, empty, empty);
 const checking::machine_operand_format db_12_8x4L_U = checking::machine_operand_format(dis_12u, length_8, base_);
 const checking::machine_operand_format db_12_4x4L_U = checking::machine_operand_format(dis_12u, length_4, base_);
-const checking::machine_operand_format reg_imm_12_S = checking::machine_operand_format(reg_imm_12s, empty, empty);
-const checking::machine_operand_format reg_imm_16_S = checking::machine_operand_format(reg_imm_16s, empty, empty);
-const checking::machine_operand_format reg_imm_24_S = checking::machine_operand_format(reg_imm_24s, empty, empty);
-const checking::machine_operand_format reg_imm_32_S = checking::machine_operand_format(reg_imm_32s, empty, empty);
+const checking::machine_operand_format rel_addr_imm_12_S =
+    checking::machine_operand_format(reladdr_imm_12s, empty, empty);
+const checking::machine_operand_format rel_addr_imm_16_S =
+    checking::machine_operand_format(reladdr_imm_16s, empty, empty);
+const checking::machine_operand_format rel_addr_imm_24_S =
+    checking::machine_operand_format(reladdr_imm_24s, empty, empty);
+const checking::machine_operand_format rel_addr_imm_32_S =
+    checking::machine_operand_format(reladdr_imm_32s, empty, empty);
+
 
 // machine instruction representation for checking
 class machine_instruction

parser_library/src/diagnostic.cpp

@@ -1231,7 +1231,7 @@ diagnostic_op diagnostic_op::error_M113(const std::string& instr_name, const ran
 {
     return diagnostic_op(diagnostic_severity::error,
         "M113",
-        "Error at " + instr_name + " instruction: operand must be an absolute register immediate value",
+        "Error at " + instr_name + " instruction: operand must be relocatable symbol or an absolute  immediate value",
         range);
 }
 
@@ -1272,7 +1272,7 @@ diagnostic_op diagnostic_op::error_M123(const std::string& instr_name, long long
 {
     return diagnostic_op(diagnostic_severity::error,
         "M123",
-        "Error at " + instr_name + " instruction: register immediate operand absolute value must be between "
+        "Error at " + instr_name + " instruction: relocatable symbol or immediate absolute value must be between "
             + std::to_string(from) + " and " + std::to_string(to),
         range);
 }
@@ -1477,6 +1477,13 @@ diagnostic_op diagnostic_op::warn_D025(const range& range, const std::string& ty
     return diagnostic_op(
         diagnostic_severity::warning, "D025", "The " + modifier + " modifier is ignored with type " + type, range);
 }
+diagnostic_op diagnostic_op::warn_D031(const range& range, const std::string& operand_value)
+{
+    return diagnostic_op(diagnostic_severity::warning,
+        "D031",
+        "Operand value " + operand_value + " should be a relocatable symbol",
+        range);
+}
 
 diagnostic_op diagnostic_op::error_D026(const range& range)
 {
@@ -1857,6 +1864,13 @@ diagnostic_op diagnostic_op::error_ME002(const range& range)
     return diagnostic_op(diagnostic_severity::error, "ME002", "multiplication or division of address", range);
 }
 
+diagnostic_op diagnostic_op::error_ME003(const range& range)
+{
+    return diagnostic_op(diagnostic_severity::error,
+        "ME003",
+        "Relative Immediate Operand value must be signed number of halfwords.",
+        range);
+}
 diagnostic_op diagnostic_op::error_CE001(const range& range)
 {
     return diagnostic_op(diagnostic_severity::error, "CE001", "Operator expected", range);

parser_library/src/diagnostic.h

@@ -444,6 +444,7 @@ struct diagnostic_op
     static diagnostic_op error_D028(const range& range);
     static diagnostic_op error_D029(const range& range);
     static diagnostic_op error_D030(const range& range, const std::string& type);
+    static diagnostic_op warn_D031(const range& range, const std::string& modifier);
 
     static diagnostic_op error_M102(const std::string& instr_name, const range& range);
 
@@ -591,6 +592,8 @@ struct diagnostic_op
 
     static diagnostic_op error_ME002(const range& range);
 
+    static diagnostic_op error_ME003(const range& range);
+
     static diagnostic_op error_CE001(const range& range);
 
     static diagnostic_op error_CE002(const std::string& message, const range& range);

parser_library/src/expressions/mach_operator.h

@@ -107,7 +107,12 @@ struct sub
     static std::string sign_char_begin() { return "-"; }
     static std::string sign_char_end() { return ""; }
 };
-
+struct rel_addr
+{
+    static std::string sign_char() { return "-"; }
+    static std::string sign_char_begin() { return "-"; }
+    static std::string sign_char_end() { return ""; }
+};
 struct mul
 {
     static std::string sign_char() { return "*"; }
@@ -137,7 +142,21 @@ inline mach_expression::value_t mach_expr_binary<sub>::evaluate(mach_evaluate_in
 {
     return left_->evaluate(info) - right_->evaluate(info);
 }
+template<>
+inline mach_expression::value_t mach_expr_binary<rel_addr>::evaluate(mach_evaluate_info info) const
+{
+    auto location = left_->evaluate(info);
+    auto target = right_->evaluate(info);
+    if (target.value_kind() == context::symbol_value_kind::ABS)
+    {
+        add_diagnostic(diagnostic_op::warn_D031(get_range(), std::to_string(target.get_abs())));
+        return target;
+    }
 
+    if ((target - location).value_kind() == context::symbol_value_kind::ABS && (target - location).get_abs() % 2 != 0)
+        add_diagnostic(diagnostic_op::error_ME003(get_range()));
+    return target - location;
+}
 template<>
 inline mach_expression::value_t mach_expr_binary<mul>::evaluate(mach_evaluate_info info) const
 {
@@ -198,7 +217,11 @@ inline context::dependency_collector mach_expr_binary<sub>::get_dependencies(mac
 {
     return left_->get_dependencies(info) - right_->get_dependencies(info);
 }
-
+template<>
+inline context::dependency_collector mach_expr_binary<rel_addr>::get_dependencies(mach_evaluate_info info) const
+{
+    return left_->get_dependencies(info) - right_->get_dependencies(info);
+}
 template<>
 inline context::dependency_collector mach_expr_binary<mul>::get_dependencies(mach_evaluate_info info) const
 {

parser_library/src/parsing/parser_impl.cpp

@@ -537,6 +537,40 @@ void parser_impl::process_lookahead()
             parse_lookahead_operands(std::move(*look_lab_instr->op_text), look_lab_instr->op_range);
     }
 }
+void parser_impl::transform_imm_reg_operands(semantics::collector& col, id_index instruction)
+{
+    std::string instruction_name;
+    instruction_name = *instruction;
+    std::vector<std::pair<size_t, size_t>> replaced;
+    auto opernds = &col.current_operands().value;
+    if (auto mnem_tmp = context::instruction::mnemonic_codes.find(*instruction);
+        mnem_tmp != context::instruction::mnemonic_codes.end())
+    {
+        instruction_name = context::instruction::mnemonic_codes.at(*instruction).instruction->instr_name;
+        replaced = context::instruction::mnemonic_codes.at(*instruction).replaced;
+    }
+    int position = 0;
+    for (const auto& operand : *opernds)
+    {
+        // replaced operands are skipped being immediate values
+        if (!replaced.empty() && replaced.at(position).first == position)
+        {
+            position++;
+        }
+
+        if (auto type =
+                context::instruction::machine_instructions.at(instruction_name).operands[position].identifier.type;
+            type == checking::machine_operand_type::RELOC_IMM && operand.get()->access_mach() != nullptr
+            && operand.get()->access_mach()->kind == mach_kind::EXPR)
+        {
+            auto range = operand.get()->access_mach()->access_expr()->expression.get()->get_range();
+            mach_expr_ptr& transformed_exp = operand.get()->access_mach()->access_expr()->expression;
+            transformed_exp = std::make_unique<mach_expr_binary<rel_addr>>(
+                std::make_unique<mach_expr_location_counter>(range), std::move(transformed_exp), range);
+        }
+        position++;
+    }
+}
 
 void parser_impl::parse_operands(const std::string& text, range text_range)
 {
@@ -595,6 +629,7 @@ void parser_impl::parse_operands(const std::string& text, range text_range)
                 break;
             case processing::processing_form::MACH:
                 h.parser->op_rem_body_mach();
+                transform_imm_reg_operands(h.parser->collector, opcode.value);
                 break;
             case processing::processing_form::DAT:
                 h.parser->op_rem_body_dat();

parser_library/src/parsing/parser_impl.h

@@ -137,6 +137,7 @@ class parser_impl : public antlr4::Parser,
 
     void parse_operands(const std::string& text, range text_range);
     void parse_lookahead_operands(const std::string& text, range text_range);
+    static void transform_imm_reg_operands(semantics::collector& col, context::id_index instruction);
 
     antlr4::misc::IntervalSet getExpectedTokens() override;
 

parser_library/src/processing/instruction_sets/low_language_processor.cpp

@@ -200,6 +200,7 @@ low_language_processor::transform_result low_language_processor::transform_mnemo
     // the associated mnemonic structure with the given name
     auto mnemonic = context::instruction::mnemonic_codes.at(instr_name);
     // the machine instruction structure associated with the given instruction name
+
     auto curr_instr = mnemonic.instruction;
 
     // check whether substituted mnemonic values are ok

parser_library/src/semantics/collector.cpp

@@ -36,7 +36,9 @@ const instruction_si& collector::current_instruction() { return *instr_; }
 
 bool collector::has_instruction() const { return instr_.has_value(); }
 
-const operands_si& collector::current_operands() { return *op_; }
+
+const operands_si& collector::current_operands() const { return *op_; }
+operands_si& collector::current_operands() { return *op_; }
 
 const remarks_si& collector::current_remarks() { return *rem_; }
 

parser_library/src/semantics/collector.h

@@ -34,7 +34,8 @@ class collector
     bool has_label() const;
     const instruction_si& current_instruction();
     bool has_instruction() const;
-    const operands_si& current_operands();
+    const operands_si& current_operands() const;
+    operands_si& current_operands();
     const remarks_si& current_remarks();
 
     void set_label_field(range symbol_range);

parser_library/src/semantics/operand_impls.cpp

@@ -14,9 +14,12 @@
 
 #include "operand_impls.h"
 
+#include <expressions/mach_operator.h>
+
 #include "expressions/conditional_assembly/terms/ca_var_sym.h"
 #include "expressions/mach_expr_term.h"
 #include "operand_visitor.h"
+using namespace hlasm_plugin::parser_library::expressions;
 
 namespace hlasm_plugin::parser_library::semantics {
 
@@ -81,9 +84,8 @@ address_machine_operand* machine_operand::access_address()
     return kind == mach_kind::ADDR ? static_cast<address_machine_operand*>(this) : nullptr;
 }
 
-std::unique_ptr<checking::operand> make_check_operand(expressions::mach_evaluate_info info,
-    const expressions::mach_expression& expr,
-    std::optional<checking::machine_operand_type> type_hint = std::nullopt)
+std::unique_ptr<checking::operand> make_check_operand(
+    expressions::mach_evaluate_info info, const expressions::mach_expression& expr)
 {
     auto res = expr.evaluate(info);
     if (res.value_kind() == context::symbol_value_kind::ABS)
@@ -92,18 +94,24 @@ std::unique_ptr<checking::operand> make_check_operand(expressions::mach_evaluate
     }
     else
     {
-        if (type_hint && *type_hint == checking::machine_operand_type::REG_IMM)
-        {
-            return std::make_unique<checking::one_operand>(0);
-        }
-        else
-        {
-            return std::make_unique<checking::address_operand>(
-                checking::address_state::UNRES, 0, 0, 0, checking::operand_state::ONE_OP);
-        }
+        return std::make_unique<checking::address_operand>(
+            checking::address_state::UNRES, 0, 0, 0, checking::operand_state::ONE_OP);
+    }
+}
+std::unique_ptr<checking::operand> check_operand(
+    expressions::mach_evaluate_info info, const expressions::mach_expression& expr)
+{
+    auto res = expr.evaluate(info);
+    if (res.value_kind() == context::symbol_value_kind::ABS)
+    {
+        return std::make_unique<checking::one_operand>(std::to_string(res.get_abs()), res.get_abs());
+    }
+    else
+    {
+        return std::make_unique<checking::address_operand>(
+            checking::address_state::UNRES, 0, 0, 0, checking::operand_state::ONE_OP);
     }
 }
-
 //***************** expr_machine_operand *********************
 
 expr_machine_operand::expr_machine_operand(expressions::mach_expr_ptr expression, range operand_range)
@@ -120,7 +128,11 @@ std::unique_ptr<checking::operand> expr_machine_operand::get_operand_value(expre
 std::unique_ptr<checking::operand> expr_machine_operand::get_operand_value(
     expressions::mach_evaluate_info info, checking::machine_operand_type type_hint) const
 {
-    return make_check_operand(info, *expression, type_hint);
+    if (type_hint == checking::machine_operand_type::RELOC_IMM)
+    {
+        return check_operand(info, *expression);
+    }
+    return make_check_operand(info, *expression);
 }
 
 // suppress MSVC warning 'inherits via dominance'