feat: Literal support

language_server/test/telemetry_test.cpp

@@ -112,7 +112,7 @@ TEST(telemetry, telemetry_broker)
 
     //"textDocument/hover",R"#({"textDocument":{"uri":"file:///c%3A/test/stability.hlasm"},"position":{"line":0,"character":7}})#"_json),
 
-    std::thread lsp_thread([&broker, &lsp_server]() {
+    std::thread lsp_thread([&lsp_server]() {
         lsp_server.message_received(
             R"({"jsonrpc":"2.0","id":48,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///test_file"},"position":{"line":0,"character":2} }})"_json);
     });

parser_library/src/context/CMakeLists.txt

@@ -24,6 +24,8 @@ target_sources(parser_library PRIVATE
 	instruction.cpp
 	instruction.h
 	instruction_type.h
+	literal_pool.cpp
+	literal_pool.h
 	macro.cpp
 	macro.h
 	macro_param_data.cpp

parser_library/src/context/hlasm_context.cpp

@@ -273,6 +273,8 @@ hlasm_context::hlasm_context(std::string file_name, asm_option asm_options, std:
     add_global_system_vars();
 }
 
+hlasm_context::~hlasm_context() = default;
+
 void hlasm_context::set_source_position(position pos) { source_stack_.back().current_instruction.pos = pos; }
 
 void hlasm_context::set_source_indices(size_t begin_index, size_t end_index, size_t end_line)
@@ -647,7 +649,7 @@ C_t hlasm_context::get_type_attr(var_sym_ptr var_symbol, const std::vector<size_
     if (value.empty())
         return "O";
 
-    expressions::ca_symbol_attribute::try_extract_leading_symbol(value);
+    value = expressions::ca_symbol_attribute::try_extract_leading_symbol(value);
 
     auto res = expressions::ca_constant::try_self_defining_term(value);
     if (res)

parser_library/src/context/hlasm_context.h

@@ -26,7 +26,6 @@
 #include "ordinary_assembly/ordinary_assembly_context.h"
 #include "processing_context.h"
 
-
 namespace hlasm_plugin::parser_library::context {
 
 // class helping to perform semantic analysis of hlasm source code
@@ -83,6 +82,7 @@ class hlasm_context
     // last AINSERT virtual file id
     size_t m_ainsert_id = 0;
     bool m_end_reached = false;
+
     void add_system_vars_to_scope();
     void add_global_system_vars();
 
@@ -92,6 +92,7 @@ class hlasm_context
     hlasm_context(std::string file_name = "",
         asm_option asm_opts = {},
         std::shared_ptr<id_storage> init_ids = std::make_shared<id_storage>());
+    ~hlasm_context();
 
     // gets name of file where is open-code located
     const std::string& opencode_file_name() const;

parser_library/src/context/id_storage.h

@@ -67,8 +67,8 @@ class id_storage
         const std::string* AGO;
         const std::string* ACTR;
         const std::string* AREAD;
-        const std::string* END;
         const std::string* ALIAS;
+        const std::string* END;
         well_known_strings(std::unordered_set<std::string>& ptr);
 
     } const well_known;

parser_library/src/context/literal_pool.cpp

@@ -0,0 +1,197 @@
+/*
+ * 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 "literal_pool.h"
+
+#include <algorithm>
+#include <functional>
+
+#include "context/ordinary_assembly/ordinary_assembly_context.h"
+#include "context/ordinary_assembly/postponed_statement.h"
+#include "diagnosable_ctx.h"
+#include "ebcdic_encoding.h"
+#include "hlasm_context.h"
+#include "processing/statement.h"
+#include "semantics/operand_impls.h"
+
+namespace hlasm_plugin::parser_library::context {
+
+id_index literal_pool::add_literal(const std::string& literal_text,
+    const std::shared_ptr<const expressions::data_definition>& dd,
+    range r,
+    size_t unique_id,
+    std::optional<address> loctr,
+    bool align_on_halfword)
+{
+    unique_id = dd->references_loctr ? unique_id : 0;
+    if (auto lit = get_literal(m_current_literal_pool_generation, dd, unique_id))
+        return lit;
+
+    auto [it, inserted] = m_literals.try_emplace(
+        literal_id { m_current_literal_pool_generation, unique_id, dd }, literal_text, std::move(r), std::move(loctr));
+    // even if we end up inserting a duplicate
+    // we need to try to insert const expressions::data_definition->iterator relation
+    // because a single literal may be referenced by independent data_definitions
+    m_literals_genmap.try_emplace(literal_id { m_current_literal_pool_generation, unique_id, dd }, it);
+    // but we should not try to put logical duplicates on the pending queue
+    if (inserted)
+    {
+        m_pending_literals.emplace_back(it);
+        it->second.stack = hlasm_ctx.processing_stack();
+    }
+    it->second.align_on_halfword |= align_on_halfword;
+
+    return &it->second.text;
+}
+
+id_index literal_pool::get_literal(
+    size_t generation, const std::shared_ptr<const expressions::data_definition>& dd, size_t unique_id) const
+{
+    unique_id = dd->references_loctr ? unique_id : 0;
+    auto it = m_literals_genmap.find(literal_id { generation, unique_id, dd });
+    if (it == m_literals_genmap.end())
+        return nullptr;
+    return &it->second->second.text;
+}
+
+
+class literal_pool::literal_postponed_statement : public context::postponed_statement,
+                                                  public processing::resolved_statement
+{
+    const literal_pool::literal_details* details;
+    semantics::operands_si op;
+    processing::op_code op_code;
+
+    static const semantics::remarks_si empty_remarks;
+    static const semantics::label_si empty_label;
+    static const semantics::instruction_si empty_instr;
+    static const processing::processing_format dc_format;
+
+public:
+    literal_postponed_statement(const std::shared_ptr<const expressions::data_definition>& dd,
+        const literal_pool::literal_details& details,
+        id_storage& ids)
+        : details(&details)
+        , op(details.r, {})
+        , op_code(ids.add("DC"), instruction_type::ASM)
+    {
+        op.value.push_back(std::make_unique<semantics::data_def_operand>(dd, details.r));
+    }
+    const processing_stack_t& location_stack() const override { return details->stack; }
+    const processing::resolved_statement* resolved_stmt() const override { return this; }
+    const processing::op_code& opcode_ref() const override { return op_code; }
+    processing::processing_format format_ref() const override { return dc_format; }
+    const semantics::operands_si& operands_ref() const override { return op; }
+    const semantics::remarks_si& remarks_ref() const override { return empty_remarks; }
+    const range& stmt_range_ref() const override { return details->r; }
+    const semantics::label_si& label_ref() const override { return empty_label; }
+    const semantics::instruction_si& instruction_ref() const override { return empty_instr; }
+    std::pair<const diagnostic_op*, const diagnostic_op*> diagnostics() const override { return {}; };
+};
+const semantics::remarks_si literal_pool::literal_postponed_statement::empty_remarks({}, {});
+const semantics::label_si literal_pool::literal_postponed_statement::empty_label(range {});
+const semantics::instruction_si literal_pool::literal_postponed_statement::empty_instr(range {});
+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(dependency_solver& solver, const diagnosable_ctx& diags)
+{
+    ordinary_assembly_context& ord_ctx = hlasm_ctx.ord_ctx;
+
+    if (m_pending_literals.empty())
+        return;
+
+    for (auto& [it, size, alignment] : m_pending_literals)
+    {
+        const auto& lit = it->first.lit;
+        if (!lit->access_data_def_type()) // unknown type
+            continue;
+
+        size = (semantics::data_def_operand::get_operand_value(*lit, solver).get_length() + 7) / 8;
+        if (size == 0)
+            continue;
+
+        auto top_alignment = size | 16; // 16B length alignment is the top
+        alignment = (~top_alignment & top_alignment - 1) + 1;
+    }
+
+    std::stable_sort(m_pending_literals.begin(), m_pending_literals.end(), [](const auto& l, const auto& r) {
+        return l.alignment > r.alignment;
+    });
+
+    constexpr auto sectalign = doubleword;
+    ord_ctx.align(sectalign);
+
+    for (const auto& [it, size, alignment] : m_pending_literals)
+    {
+        const auto& lit_key = it->first;
+        const auto& lit = lit_key.lit;
+        const auto& lit_val = it->second;
+
+        if (!lit->access_data_def_type()) // unknown type
+            continue;
+
+        // TODO: warn on align > sectalign
+
+        bool cycle_ok = ord_ctx.create_symbol(&lit_val.text,
+            ord_ctx.align(lit_val.align_on_halfword ? halfword : no_align),
+            symbol_attributes(symbol_origin::DAT,
+                ebcdic_encoding::a2e[(unsigned char)lit->get_type_attribute()],
+                lit->get_length_attribute(solver)),
+            {});
+
+        if (size == 0)
+        {
+            diags.add_diagnostic(diagnostic_op::error_D031(it->second.r));
+            continue;
+        }
+
+        ord_ctx.reserve_storage_area(size, no_align);
+
+        if (!cycle_ok)
+            diags.add_diagnostic(diagnostic_op::error_E033(it->second.r));
+        else if (lit->get_dependencies(solver).contains_dependencies())
+        {
+            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 });
+            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);
+            ddt->check_DC(ddo, diagnostic_collector(&diags, lit_val.stack));
+        }
+    }
+
+    m_pending_literals.clear();
+    ++m_current_literal_pool_generation;
+}
+
+bool literal_pool::literal_id::is_similar(const literal_id& ld) const noexcept
+{
+    return generation == ld.generation && unique_id == ld.unique_id && utils::is_similar(lit, ld.lit);
+}
+
+size_t literal_pool::literal_definition_hasher::operator()(const literal_id& ld) const noexcept
+{
+    return ld.lit->hash() ^ ld.generation ^ ld.unique_id;
+}
+
+} // namespace hlasm_plugin::parser_library::context

parser_library/src/context/literal_pool.h

@@ -0,0 +1,123 @@
+/*
+ * 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_LITERAL_POOL_H
+#define HLASMPLUGIN_PARSERLIBRARY_LITERAL_POOL_H
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "expressions/data_definition.h"
+#include "id_storage.h"
+#include "location.h"
+#include "processing_context.h"
+#include "utils/similar.h"
+
+namespace hlasm_plugin::parser_library::context {
+class hlasm_context;
+
+class literal_pool
+{
+    struct literal_id
+    {
+        size_t generation;
+        size_t unique_id;
+        std::shared_ptr<const expressions::data_definition> lit;
+
+        bool is_similar(const literal_id&) const noexcept;
+    };
+    struct literal_details
+    {
+        std::string text;
+        range r;
+        std::optional<address> loctr;
+        processing_stack_t stack;
+        bool align_on_halfword = false;
+
+        literal_details(std::string text, range r, std::optional<address> loctr)
+            : text(std::move(text))
+            , r(r)
+            , loctr(std::move(loctr))
+        {}
+
+        literal_details(std::string text, range r, std::optional<address> loctr, processing_stack_t stack)
+            : text(std::move(text))
+            , r(r)
+            , loctr(std::move(loctr))
+            , stack(std::move(stack))
+        {}
+    };
+    class literal_postponed_statement;
+    struct literal_definition_hasher
+    {
+        size_t operator()(const literal_id&) const noexcept;
+    };
+    size_t m_current_literal_pool_generation = 0;
+
+    struct literal_id_helper
+    {
+        size_t operator()(const literal_id& p) const noexcept
+        {
+            return std::hash<size_t>()(p.generation) ^ std::hash<size_t>()(p.unique_id)
+                ^ std::hash<const expressions::data_definition*>()(p.lit.get());
+        }
+        bool operator()(const literal_id& l, const literal_id& r) const noexcept
+        {
+            return l.lit == r.lit && l.generation == r.generation && l.unique_id == r.unique_id;
+        }
+    };
+
+    std::unordered_map<literal_id, literal_details, literal_definition_hasher, decltype(utils::is_similar)> m_literals;
+    std::unordered_map<literal_id, decltype(m_literals)::const_iterator, literal_id_helper, literal_id_helper>
+        m_literals_genmap;
+
+    struct pending_literal
+    {
+        decltype(m_literals)::const_iterator literal;
+        size_t size = 0;
+        size_t alignment = 0;
+
+        explicit pending_literal(decltype(m_literals)::const_iterator l) noexcept
+            : literal(l)
+        {}
+    };
+
+    std::vector<pending_literal> m_pending_literals;
+
+    hlasm_context& hlasm_ctx;
+
+public:
+    explicit literal_pool(hlasm_context& hlasm_ctx)
+        : hlasm_ctx(hlasm_ctx)
+    {}
+
+    id_index add_literal(const std::string& literal_text,
+        const std::shared_ptr<const expressions::data_definition>& dd,
+        range r,
+        size_t unique_id,
+        std::optional<address> loctr,
+        bool align_on_halfword);
+    id_index get_literal(
+        size_t generation, const std::shared_ptr<const expressions::data_definition>& dd, size_t unique_id) const;
+
+    void generate_pool(dependency_solver& solver, const diagnosable_ctx& diags);
+    size_t current_generation() const { return m_current_literal_pool_generation; }
+
+    // testing
+    size_t get_pending_count() const { return m_pending_literals.size(); }
+};
+
+} // namespace hlasm_plugin::parser_library::context
+
+#endif