feat: Instruction operand checking utilizes USING map

clients/vscode-hlasmplugin/CHANGELOG.md

@@ -5,6 +5,7 @@
 #### Added
 - USING and DROP support
 - SYSSTMT support
+- Instruction operand checking utilizes USING map
 
 #### Fixed
 - Behavior of currently supported subscripted system variables corrected

parser_library/src/checking/CMakeLists.txt

@@ -23,6 +23,8 @@ target_sources(parser_library PRIVATE
 	instruction_checker.cpp
 	instruction_checker.h
 	operand.h
+	using_label_checker.cpp
+	using_label_checker.h
 )
 
 add_subdirectory(data_definition)

parser_library/src/checking/asm_instr_class.cpp

@@ -179,7 +179,7 @@ bool assembler_instruction::check_optable_operands(const std::vector<std::unique
 
 bool assembler_instruction::check_typecheck_operands(const std::vector<std::unique_ptr<asm_operand>>& input,
     std::string_view instr_name,
-    const std::string,
+    std::string_view,
     const diagnostic_collector& add_diagnostic) const
 {
     const static std::vector<std::string_view> typecheck_operands = {

parser_library/src/checking/asm_instr_class.h

@@ -89,7 +89,7 @@ class assembler_instruction
 
     bool check_typecheck_operands(const std::vector<std::unique_ptr<asm_operand>>& input,
         std::string_view instr_name,
-        const std::string op_name,
+        std::string_view op_name,
         const diagnostic_collector& add_diagnostic) const;
 
     // process instruction functions

parser_library/src/checking/data_definition/data_def_fields.h

@@ -89,6 +89,7 @@ struct data_def_address
     data_def_field<int32_t> base;
     data_def_field<int32_t> displacement;
     bool ignored = false;
+    range total;
 };
 
 using expr_or_address = std::variant<data_def_expr, data_def_address>;

parser_library/src/checking/data_definition/data_def_type_base.cpp

@@ -14,6 +14,8 @@
 
 #include "data_def_type_base.h"
 
+#include <optional>
+
 #include "checking/instr_operand.h"
 #include "data_def_types.h"
 
@@ -258,6 +260,28 @@ bool data_def_type::check_length(const data_def_length_t& length, const diagnost
     }
 }
 
+namespace {
+struct
+{
+    std::optional<range> operator()(const data_def_expr& e) const
+    {
+        if (e.ignored)
+            return std::nullopt;
+        if (e.ex_kind != expr_type::ABS)
+            return e.rng;
+        return std::nullopt;
+    }
+    std::optional<range> operator()(const data_def_address& a) const
+    {
+        if (a.ignored)
+            return std::nullopt;
+        if (!a.displacement.present || !a.base.present)
+            return a.total;
+        return std::nullopt;
+    }
+} const abs_or_addr;
+} // namespace
+
 bool data_def_type::check_nominal_type(
     const data_definition_operand& op, const diagnostic_collector& add_diagnostic) const
 {
@@ -294,6 +318,17 @@ bool data_def_type::check_nominal_type(
                 add_diagnostic(diagnostic_op::error_D017(op.operand_range, type_str));
                 return false;
             }
+            for (const auto& p : std::get<nominal_value_expressions>(op.nominal_value.value))
+            {
+                if (auto range_o = std::visit(abs_or_addr, p); range_o)
+                {
+                    add_diagnostic(diagnostic_op::error_D033(*range_o));
+                    ret = false;
+                }
+            }
+            if (!ret)
+                return false;
+
             break;
         default:
             assert(false);

parser_library/src/checking/data_definition/data_def_type_base.h

@@ -32,7 +32,7 @@ class data_definition_operand;
 enum class data_instr_type
 {
     DC,
-    DS
+    DS,
 };
 
 // Modifier spec specifies allowed values for modifiers.

parser_library/src/checking/data_definition/data_def_types_string.cpp

@@ -15,6 +15,8 @@
 // This file contains implementation of the data_def_type for
 // these types: B, C, G, X
 
+#include <concepts>
+
 #include "checking/checker_helper.h"
 #include "data_def_types.h"
 
@@ -51,7 +53,8 @@ uint32_t get_X_B_length_attr(const std::string& s, uint64_t frac)
 }
 
 // Checks comma separated values. is_valid_digit specifies whether the char is valid character of value.
-bool check_comma_separated(const std::string nom, std::function<bool(char c)> is_valid_digit)
+template</* std::predicate<char> */ typename F>
+bool check_comma_separated(const std::string& nom, F is_valid_digit)
 {
     bool last_valid = false;
     for (char c : nom)

parser_library/src/checking/instr_operand.h

@@ -86,6 +86,8 @@ struct parameter
 
     constexpr bool is_empty() const { return (!is_signed && type == machine_operand_type::NONE && size == 0); }
 
+    bool operator==(const parameter&) const = default;
+
     std::string to_string() const;
 };
 

parser_library/src/checking/using_label_checker.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2021 Broadcom.
+ * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Broadcom, Inc. - initial API and implementation
+ */
+
+#include "using_label_checker.h"
+
+#include "context/ordinary_assembly/section.h"
+
+namespace hlasm_plugin::parser_library::checking {
+
+void using_label_checker::add_diagnostic(diagnostic_op) const {}
+
+void using_label_checker::visit(const expressions::mach_expr_constant&) {}
+void using_label_checker::visit(const expressions::mach_expr_data_attr& attr)
+{
+    if (!attr.value || !attr.qualifier)
+        return;
+    auto symbol = solver.get_symbol(attr.value);
+    if (symbol == nullptr || symbol->kind() != context::symbol_value_kind::RELOC)
+        return;
+    const auto& reloc = symbol->value().get_reloc();
+    if (!reloc.is_simple())
+        return;
+    const auto* section = reloc.bases().front().first.owner;
+    if (!solver.using_active(attr.qualifier, section))
+        diags.add_diagnostic(diagnostic_op::error_ME005(*attr.qualifier, *section->name, attr.get_range()));
+}
+void using_label_checker::visit(const expressions::mach_expr_data_attr_literal& attr) {}
+void using_label_checker::visit(const expressions::mach_expr_symbol& expr)
+{
+    if (!expr.qualifier)
+        return;
+    auto value = expr.evaluate(solver, *this);
+    if (value.value_kind() != context::symbol_value_kind::RELOC)
+        return;
+    const auto& reloc = value.get_reloc();
+    if (!reloc.is_simple())
+        return;
+    const auto* section = reloc.bases().front().first.owner;
+    if (!solver.using_active(expr.qualifier, section))
+        diags.add_diagnostic(diagnostic_op::error_ME005(*expr.qualifier, *section->name, expr.get_range()));
+}
+void using_label_checker::visit(const expressions::mach_expr_location_counter&) {}
+void using_label_checker::visit(const expressions::mach_expr_default&) {}
+void using_label_checker::visit(const expressions::mach_expr_literal& l) { l.get_data_definition().apply(*this); }
+
+} // namespace hlasm_plugin::parser_library::checking

parser_library/src/checking/using_label_checker.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2021 Broadcom.
+ * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Broadcom, Inc. - initial API and implementation
+ */
+
+
+#ifndef HLASMPLUGIN_PARSERLIBRARY_USING_LABEL_CHECKER_H
+#define HLASMPLUGIN_PARSERLIBRARY_USING_LABEL_CHECKER_H
+
+#include "diagnostic_consumer.h"
+#include "expressions/mach_expr_visitor.h"
+
+namespace hlasm_plugin::parser_library::context {
+class dependency_solver;
+} // namespace hlasm_plugin::parser_library::context
+
+namespace hlasm_plugin::parser_library::checking {
+
+class using_label_checker final : public expressions::mach_expr_visitor, diagnostic_consumer<diagnostic_op>
+{
+    context::dependency_solver& solver;
+    diagnostic_consumer<diagnostic_op>& diags;
+
+    void add_diagnostic(diagnostic_op) const override;
+
+public:
+    using_label_checker(context::dependency_solver& solver, diagnostic_consumer<diagnostic_op>& diags)
+        : solver(solver)
+        , diags(diags)
+    {}
+
+    // Inherited via mach_expr_visitor
+    void visit(const expressions::mach_expr_constant&) override;
+    void visit(const expressions::mach_expr_data_attr& attr) override;
+    void visit(const expressions::mach_expr_data_attr_literal& attr) override;
+    void visit(const expressions::mach_expr_symbol& expr) override;
+    void visit(const expressions::mach_expr_location_counter&) override;
+    void visit(const expressions::mach_expr_default&) override;
+    void visit(const expressions::mach_expr_literal& l) override;
+};
+
+} // namespace hlasm_plugin::parser_library::checking
+
+#endif

parser_library/src/context/hlasm_context.cpp

@@ -776,8 +776,8 @@ macro_def_ptr hlasm_context::add_macro(id_index name,
 void hlasm_context::add_macro(macro_def_ptr macro)
 {
     const auto& m = macros_[macro->id] = std::move(macro);
-    // associate mnemonic if previously deleted by OPSYN
-    if (auto m_op = opcode_mnemo_.find(m->id); m_op != opcode_mnemo_.end() && !m_op->second)
+    // override associate mnemonic if exists
+    if (auto m_op = opcode_mnemo_.find(m->id); m_op != opcode_mnemo_.end())
         m_op->second = opcode_t { m->id, m };
 };
 

parser_library/src/context/hlasm_context.h

@@ -310,6 +310,8 @@ class hlasm_context
     void using_resolve(diagnostic_s_consumer&);
     index_t<using_collection> using_current() const;
 
+    const using_collection& usings() const { return *m_usings; }
+
     using name_result = std::pair<bool, context::id_index>;
     name_result try_get_symbol_name(const std::string& symbol);
 };

parser_library/src/context/instruction.cpp

@@ -248,7 +248,7 @@ const ca_instruction& instruction::get_ca_instructions(std::string_view name)
 std::span<const ca_instruction> instruction::all_ca_instructions() { return ca_instructions; }
 
 constexpr assembler_instruction assembler_instructions[] = {
-    { "*PROCESS", 1, -1, true, "" }, // TO DO
+    { "*PROCESS", 1, -1, false, "" }, // TO DO
     { "ACONTROL", 1, -1, false, "<selection>+" },
     { "ADATA", 5, 5, false, "value1,value2,value3,value4,character_string" },
     { "AINSERT", 2, 2, false, "'record',BACK|FRONT" },
@@ -454,7 +454,6 @@ constexpr auto SI_2_s = instruction_format_definition_factory<mach_format::SI, d
 constexpr auto SI_2_u = instruction_format_definition_factory<mach_format::SI, db_12_4_U, imm_8_U>::def();
 constexpr auto SIL_2_s = instruction_format_definition_factory<mach_format::SIL, db_12_4_U, imm_16_S>::def();
 constexpr auto SIL_2_u = instruction_format_definition_factory<mach_format::SIL, db_12_4_U, imm_16_U>::def();
-constexpr auto SIY_2_uu = instruction_format_definition_factory<mach_format::SIY, db_12_4_U, imm_8_U>::def();
 constexpr auto SIY_2_ss = instruction_format_definition_factory<mach_format::SIY, db_20_4_S, imm_8_S>::def();
 constexpr auto SIY_2_su = instruction_format_definition_factory<mach_format::SIY, db_20_4_S, imm_8_U>::def();
 constexpr auto SMI_3 = instruction_format_definition_factory<mach_format::SMI, mask_4_U, rel_addr_imm_16_S, db_12_4_U>::def();
@@ -754,7 +753,7 @@ constexpr machine_instruction machine_instructions[] = {
     { "CLIB", RIS_4, 638 },
     { "CLIH", RIL_a_2, 642 },
     { "CLIJ", RIE_c_4, 638 },
-    { "CLIY", SIY_2_uu, 636 },
+    { "CLIY", SIY_2_su, 636 },
     { "CLM", RS_b_3, 641 },
     { "CLMH", RSY_b_3_us, 641 },
     { "CLMY", RSY_b_3_us, 641 },
@@ -1226,7 +1225,7 @@ constexpr machine_instruction machine_instructions[] = {
     { "MVHHI", SIL_2_s, 773 },
     { "MVHI", SIL_2_s, 773 },
     { "MVI", SI_2_u, 773 },
-    { "MVIY", SIY_2_uu, 773 },
+    { "MVIY", SIY_2_su, 773 },
     { "MVN", SS_a_2_u, 785 },
     { "MVO", SS_b_2, 786 },
     { "MVPG", RRE_2, 1044 },

parser_library/src/context/literal_pool.cpp

@@ -107,7 +107,7 @@ const semantics::instruction_si literal_pool::literal_postponed_statement::empty
 const processing::processing_format literal_pool::literal_postponed_statement::dc_format(
     processing::processing_kind::ORDINARY, processing::processing_form::ASM, processing::operand_occurence::PRESENT);
 
-void literal_pool::generate_pool(diagnosable_ctx& diags)
+void literal_pool::generate_pool(diagnosable_ctx& diags, index_t<using_collection> active_using)
 {
     ordinary_assembly_context& ord_ctx = hlasm_ctx.ord_ctx;
 
@@ -125,8 +125,9 @@ void literal_pool::generate_pool(diagnosable_ctx& diags)
                 it->second.loctr,
                 it->first.generation,
                 it->first.unique_id,
+                active_using,
             });
-        auto bit_length = lit->evaluate_total_length(solver, diags);
+        auto bit_length = lit->evaluate_total_length(solver, checking::data_instr_type::DC, diags);
         if (bit_length < 0)
             continue;
         size = (bit_length + 7) / 8;
@@ -155,6 +156,7 @@ void literal_pool::generate_pool(diagnosable_ctx& diags)
                 lit_val.loctr,
                 lit_key.generation,
                 lit_key.unique_id,
+                active_using,
             });
 
         if (!lit->access_data_def_type()) // unknown type
@@ -179,23 +181,14 @@ void literal_pool::generate_pool(diagnosable_ctx& diags)
 
         if (!cycle_ok)
             diags.add_diagnostic(diagnostic_op::error_E033(it->second.r));
-        else if (lit->get_dependencies(solver).contains_dependencies())
+        else
         {
             auto adder = ord_ctx.symbol_dependencies.add_dependencies(
                 std::make_unique<literal_postponed_statement>(lit, lit_val, hlasm_ctx.ids()),
-                { lit_val.loctr, lit_key.generation, lit_key.unique_id });
+                { lit_val.loctr, lit_key.generation, lit_key.unique_id, active_using });
             adder.add_dependency();
             adder.finish();
         }
-        else
-        {
-            auto ddt = lit->access_data_def_type();
-            if (!ddt) // unknown type
-                continue;
-
-            auto ddo = semantics::data_def_operand::get_operand_value(*lit, solver, diags);
-            ddt->check_DC(ddo, diagnostic_collector(&diags, lit_val.stack));
-        }
     }
 
     m_pending_literals.clear();

parser_library/src/context/literal_pool.h

@@ -22,10 +22,12 @@
 #include "id_storage.h"
 #include "location.h"
 #include "source_context.h"
+#include "tagged_index.h"
 #include "utils/similar.h"
 
 namespace hlasm_plugin::parser_library::context {
 class hlasm_context;
+class using_collection;
 
 class literal_pool
 {
@@ -111,7 +113,7 @@ class literal_pool
     id_index get_literal(
         size_t generation, const std::shared_ptr<const expressions::data_definition>& dd, size_t unique_id) const;
 
-    void generate_pool(diagnosable_ctx& diags);
+    void generate_pool(diagnosable_ctx& diags, index_t<using_collection> active_using);
     size_t current_generation() const { return m_current_literal_pool_generation; }
 
     // testing

parser_library/src/context/ordinary_assembly/address.cpp

@@ -299,7 +299,7 @@ bool address::in_same_loctr(const address& addr) const
 
 bool address::is_simple() const { return bases_.size() == 1 && bases_[0].second == 1; }
 
-bool has_unresolved_spaces(const space_ptr sp)
+bool has_unresolved_spaces(const space_ptr& sp)
 {
     if (!sp->resolved())
         return true;