[ASRPass] Wrap all the global symbols into a module

Author: Thirumalai-Shaktivel

integration_tests/CMakeLists.txt

@@ -426,4 +426,5 @@ RUN(NAME comp_01 LABELS cpython llvm wasm wasm_x64)
 RUN(NAME bit_operations_i32 LABELS cpython llvm wasm wasm_x64)
 RUN(NAME bit_operations_i64 LABELS cpython llvm wasm)
 
-RUN(NAME test_argv_01    LABELS llvm) # TODO: Test using CPython
+RUN(NAME test_argv_01      LABELS llvm) # TODO: Test using CPython
+RUN(NAME global_syms_01    LABELS cpython)

integration_tests/global_syms_01.py

@@ -0,0 +1,12 @@
+from ltypes import i32
+
+x: list[i32]
+x = [1, 2]
+i: i32
+i = x[0]
+
+def test_global_symbols():
+    assert i == 1
+    assert x[1] == 2
+
+test_global_symbols()

src/libasr/CMakeLists.txt

@@ -32,6 +32,7 @@ set(SRC
     pass/for_all.cpp
     pass/global_stmts.cpp
     pass/global_stmts_program.cpp
+    pass/global_symbols.cpp
     pass/select_case.cpp
     pass/implied_do_loops.cpp
     pass/array_op.cpp

src/libasr/asr_scopes.cpp

@@ -135,4 +135,104 @@ std::string SymbolTable::get_unique_name(const std::string &name) {
     return unique_name;
 }
 
+void SymbolTable::move_symbols_from_global_scope(Allocator &al,
+        SymbolTable *module_scope, Vec<char *> &syms,
+        Vec<char *> &mod_dependencies) {
+    syms.reserve(al, 4);
+    mod_dependencies.reserve(al, 4);
+    for (auto &a : scope) {
+        switch (a.second->type) {
+            case (ASR::symbolType::Module): {
+                // Pass
+                break;
+            } case (ASR::symbolType::Function) : {
+                ASR::Function_t *fn = ASR::down_cast<ASR::Function_t>(a.second);
+                for (size_t i = 0; i < fn->n_dependencies; i++ ) {
+                    ASR::symbol_t *s = fn->m_symtab->get_symbol(
+                        fn->m_dependencies[i]);
+                    if (s == nullptr) {
+                        std::string block_name = "block";
+                        ASR::symbol_t *block_s = fn->m_symtab->get_symbol(block_name);
+                        int32_t j = 1;
+                        while(block_s != nullptr) {
+                            while(block_s != nullptr) {
+                                ASR::Block_t *b = ASR::down_cast<ASR::Block_t>(block_s);
+                                s = b->m_symtab->get_symbol(fn->m_dependencies[i]);
+                                if (s == nullptr) {
+                                    block_s = b->m_symtab->get_symbol("block");
+                                } else {
+                                    break;
+                                }
+                            }
+                            if (s == nullptr) {
+                                block_s = fn->m_symtab->get_symbol(block_name +
+                                    std::to_string(j));
+                                j++;
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+                    if (s == nullptr) {
+                        s = fn->m_symtab->parent->get_symbol(fn->m_dependencies[i]);
+                    }
+                    if (s != nullptr && ASR::is_a<ASR::ExternalSymbol_t>(*s)) {
+                        char *es_name = ASR::down_cast<
+                            ASR::ExternalSymbol_t>(s)->m_module_name;
+                        if (!present(mod_dependencies, es_name)) {
+                            mod_dependencies.push_back(al, es_name);
+                        }
+                    }
+                }
+                fn->m_symtab->parent = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) fn);
+                syms.push_back(al, s2c(al, a.first));
+                break;
+            } case (ASR::symbolType::GenericProcedure) : {
+                ASR::GenericProcedure_t *es = ASR::down_cast<ASR::GenericProcedure_t>(a.second);
+                es->m_parent_symtab = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) es);
+                syms.push_back(al, s2c(al, a.first));
+                break;
+            } case (ASR::symbolType::ExternalSymbol) : {
+                ASR::ExternalSymbol_t *es = ASR::down_cast<ASR::ExternalSymbol_t>(a.second);
+                if (!present(mod_dependencies, es->m_module_name)) {
+                    mod_dependencies.push_back(al, es->m_module_name);
+                }
+                es->m_parent_symtab = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) es);
+                syms.push_back(al, s2c(al, a.first));
+                break;
+            } case (ASR::symbolType::StructType) : {
+                ASR::StructType_t *st = ASR::down_cast<ASR::StructType_t>(a.second);
+                st->m_symtab->parent = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) st);
+                syms.push_back(al, s2c(al, a.first));
+                break;
+            } case (ASR::symbolType::EnumType) : {
+                ASR::EnumType_t *et = ASR::down_cast<ASR::EnumType_t>(a.second);
+                et->m_symtab->parent = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) et);
+                syms.push_back(al, s2c(al, a.first));
+                break;
+            } case (ASR::symbolType::UnionType) : {
+                ASR::UnionType_t *ut = ASR::down_cast<ASR::UnionType_t>(a.second);
+                ut->m_symtab->parent = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) ut);
+                syms.push_back(al, s2c(al, a.first));
+                break;
+            } case (ASR::symbolType::Variable) : {
+                ASR::Variable_t *v = ASR::down_cast<ASR::Variable_t>(a.second);
+                v->m_parent_symtab = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) v);
+                syms.push_back(al, s2c(al, a.first));
+                break;
+            } default : {
+                throw LCompilersException("Moving the symbol:`" + a.first +
+                    "` from global scope is not implemented yet");
+            };
+        }
+    }
+}
+
 } // namespace LCompilers

src/libasr/asr_scopes.h

@@ -4,6 +4,7 @@
 #include <map>
 
 #include <libasr/alloc.h>
+#include <libasr/containers.h>
 
 namespace LCompilers  {
 
@@ -80,6 +81,10 @@ struct SymbolTable {
         size_t n_scope_names, char **m_scope_names);
 
     std::string get_unique_name(const std::string &name);
+
+    void move_symbols_from_global_scope(Allocator &al,
+        SymbolTable *module_scope, Vec<char *> &syms,
+        Vec<char *> &mod_dependencies);
 };
 
 } // namespace LCompilers

src/libasr/asr_verify.cpp

@@ -578,21 +578,23 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
             require(x_m_module_name == asr_owner_name,
                 "ExternalSymbol::m_module_name `" + x_m_module_name
                 + "` must match external's module name `" + asr_owner_name + "`");
-            ASR::symbol_t *s = nullptr;
-            if( m != nullptr && ((ASR::symbol_t*) m == ASRUtils::get_asr_owner(x.m_external)) ) {
-                s = m->m_symtab->find_scoped_symbol(x.m_original_name, x.n_scope_names, x.m_scope_names);
-            } else if( sm ) {
-                s = sm->m_symtab->resolve_symbol(std::string(x.m_original_name));
-            } else if( em ) {
-                s = em->m_symtab->resolve_symbol(std::string(x.m_original_name));
+            if (asr_owner_name != "_global_symbols") {
+                ASR::symbol_t *s = nullptr;
+                if( m != nullptr && ((ASR::symbol_t*) m == ASRUtils::get_asr_owner(x.m_external)) ) {
+                    s = m->m_symtab->find_scoped_symbol(x.m_original_name, x.n_scope_names, x.m_scope_names);
+                } else if( sm ) {
+                    s = sm->m_symtab->resolve_symbol(std::string(x.m_original_name));
+                } else if( em ) {
+                    s = em->m_symtab->resolve_symbol(std::string(x.m_original_name));
+                }
+                require(s != nullptr,
+                    "ExternalSymbol::m_original_name ('"
+                    + std::string(x.m_original_name)
+                    + "') + scope_names not found in a module '"
+                    + asr_owner_name + "'");
+                require(s == x.m_external,
+                    "ExternalSymbol::m_name + scope_names found but not equal to m_external");
             }
-            require(s != nullptr,
-                "ExternalSymbol::m_original_name ('"
-                + std::string(x.m_original_name)
-                + "') + scope_names not found in a module '"
-                + asr_owner_name + "'");
-            require(s == x.m_external,
-                "ExternalSymbol::m_name + scope_names found but not equal to m_external");
         }
     }
 

src/libasr/codegen/asr_to_c.cpp

@@ -645,6 +645,32 @@ R"(
             array_types_decls += src;
         }
 
+        if (x.m_global_scope->get_symbol("_global_symbols") != nullptr) {
+            struct_dep_graph.clear();
+            SymbolTable *global_symbols = ASR::down_cast<ASR::Module_t>(
+                x.m_global_scope->get_symbol("_global_symbols"))->m_symtab;
+            for (auto &item : global_symbols->get_scope()) {
+                if (ASR::is_a<ASR::StructType_t>(*item.second) ||
+                        ASR::is_a<ASR::EnumType_t>(*item.second) ||
+                        ASR::is_a<ASR::UnionType_t>(*item.second)) {
+                    std::vector<std::string> struct_deps_vec;
+                    std::pair<char**, size_t> struct_deps_ptr = ASRUtils::symbol_dependencies(item.second);
+                    for( size_t i = 0; i < struct_deps_ptr.second; i++ ) {
+                        struct_deps_vec.push_back(std::string(struct_deps_ptr.first[i]));
+                    }
+                    struct_dep_graph[item.first] = struct_deps_vec;
+                }
+            }
+
+            std::vector<std::string> struct_deps = ASRUtils::order_deps(struct_dep_graph);
+
+            for (auto &item : struct_deps) {
+                ASR::symbol_t* struct_sym = global_symbols->get_symbol(item);
+                visit_symbol(*struct_sym);
+                array_types_decls += src;
+            }
+        }
+
         // Topologically sort all global functions
         // and then define them in the right order
         std::vector<std::string> global_func_order = ASRUtils::determine_function_definition_order(x.m_global_scope);

src/libasr/codegen/asr_to_llvm.cpp

@@ -1228,6 +1228,16 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
         fname2arg_type["lbound"] = std::make_pair(bound_arg, bound_arg->getPointerTo());
         fname2arg_type["ubound"] = std::make_pair(bound_arg, bound_arg->getPointerTo());
 
+        if (x.m_global_scope->get_symbol("_global_symbols") != nullptr) {
+            SymbolTable *global_symbols = ASR::down_cast<ASR::Module_t>(
+                x.m_global_scope->get_symbol("_global_symbols"))->m_symtab;
+            for (auto &item : global_symbols->get_scope()) {
+                if (is_a<ASR::EnumType_t>(*item.second)) {
+                    visit_symbol(*item.second);
+                }
+            }
+        }
+
         // Process Variables first:
         for (auto &item : x.m_global_scope->get_scope()) {
             if (is_a<ASR::Variable_t>(*item.second) ||

src/libasr/codegen/asr_to_x86.cpp

@@ -79,6 +79,21 @@ class ASRToX86Visitor : public ASR::BaseVisitor<ASRToX86Visitor>
             visit_symbol(*sym);
         }
 
+        if (x.m_global_scope->get_symbol("_global_symbols") != nullptr) {
+            SymbolTable *global_symbols = ASR::down_cast<ASR::Module_t>(
+                x.m_global_scope->get_symbol("_global_symbols"))->m_symtab;
+            std::vector<std::string> global_func_order
+                = ASRUtils::determine_function_definition_order(global_symbols);
+            for (size_t i = 0; i < global_func_order.size(); i++) {
+                ASR::symbol_t* sym = global_symbols->get_symbol(global_func_order[i]);
+                // Ignore external symbols because they are already defined by the loop above.
+                if( !sym || ASR::is_a<ASR::ExternalSymbol_t>(*sym) ) {
+                    continue;
+                }
+                visit_symbol(*sym);
+            }
+        }
+
         // Then the main program:
         for (auto &item : x.m_global_scope->get_scope()) {
             if (ASR::is_a<ASR::Program_t>(*item.second)) {
@@ -504,7 +519,8 @@ class ASRToX86Visitor : public ASR::BaseVisitor<ASRToX86Visitor>
     }
 
     void visit_SubroutineCall(const ASR::SubroutineCall_t &x) {
-        ASR::Function_t *s = ASR::down_cast<ASR::Function_t>(x.m_name);
+        ASR::Function_t *s = ASR::down_cast<ASR::Function_t>(
+            ASRUtils::symbol_get_past_external(x.m_name));
 
         uint32_t h = get_hash((ASR::asr_t*)s);
         if (x86_symtab.find(h) == x86_symtab.end()) {

src/libasr/pass/global_stmts_program.cpp

@@ -4,6 +4,7 @@
 #include <libasr/asr_utils.h>
 #include <libasr/asr_verify.h>
 #include <libasr/pass/global_stmts.h>
+#include <libasr/pass/global_symbols.h>
 
 
 namespace LCompilers {
@@ -26,12 +27,22 @@ void pass_wrap_global_stmts_into_program(Allocator &al,
     prog_body.reserve(al, 1);
     if (unit.n_items > 0) {
         pass_wrap_global_stmts_into_function(al, unit, pass_options);
-        ASR::symbol_t *fn = unit.m_global_scope->get_symbol(program_fn_name);
-        if (ASR::is_a<ASR::Function_t>(*fn)
-            && ASR::down_cast<ASR::Function_t>(fn)->m_return_var == nullptr) {
+        pass_wrap_global_syms_into_module(al, unit, pass_options);
+        ASR::Module_t *mod = ASR::down_cast<ASR::Module_t>(
+            unit.m_global_scope->get_symbol("_global_symbols"));
+        // Call `_lpython_main_program` function
+        ASR::symbol_t *fn_s = mod->m_symtab->get_symbol(program_fn_name);
+        if (ASR::is_a<ASR::Function_t>(*fn_s)
+            && ASR::down_cast<ASR::Function_t>(fn_s)->m_return_var == nullptr) {
+            ASR::Function_t *fn = ASR::down_cast<ASR::Function_t>(fn_s);
+            fn_s = ASR::down_cast<ASR::symbol_t>(ASR::make_ExternalSymbol_t(
+                al, fn->base.base.loc, current_scope, s2c(al, program_fn_name),
+                fn_s, mod->m_name, nullptr, 0, s2c(al, program_fn_name),
+                ASR::accessType::Public));
+            current_scope->add_symbol(program_fn_name, fn_s);
             ASR::asr_t *stmt = ASR::make_SubroutineCall_t(
                     al, unit.base.base.loc,
-                    fn, nullptr,
+                    fn_s, nullptr,
                     nullptr, 0,
                     nullptr);
             prog_body.push_back(al, ASR::down_cast<ASR::stmt_t>(stmt));

src/libasr/pass/global_symbols.cpp

@@ -0,0 +1,47 @@
+#include <libasr/asr.h>
+#include <libasr/containers.h>
+#include <libasr/exception.h>
+#include <libasr/asr_utils.h>
+#include <libasr/asr_verify.h>
+#include <libasr/pass/global_symbols.h>
+#include <libasr/pass/pass_utils.h>
+
+
+namespace LCompilers {
+
+/*
+ * This ASR pass transforms (in-place) the ASR tree
+ * and wraps all global symbols into a module
+ */
+
+void pass_wrap_global_syms_into_module(Allocator &al,
+        ASR::TranslationUnit_t &unit,
+        const LCompilers::PassOptions& /*pass_options*/) {
+    Location loc = unit.base.base.loc;
+    char *module_name = s2c(al, "_global_symbols");
+    SymbolTable *module_scope = al.make_new<SymbolTable>(unit.m_global_scope);
+    Vec<char *> moved_symbols;
+    Vec<char *> mod_dependencies;
+
+    // Move all the symbols from global into the module scope
+    unit.m_global_scope->move_symbols_from_global_scope(al, module_scope,
+        moved_symbols, mod_dependencies);
+
+    // Erase the symbols that are moved into the module
+    for (auto &sym: moved_symbols) {
+        unit.m_global_scope->erase_symbol(sym);
+    }
+
+    Vec<char *> m_dependencies;
+    m_dependencies.reserve(al, mod_dependencies.size());
+    for( auto &dep: mod_dependencies) {
+        m_dependencies.push_back(al, dep);
+    }
+
+    ASR::symbol_t *module = (ASR::symbol_t *) ASR::make_Module_t(al, loc,
+        module_scope, module_name, m_dependencies.p, m_dependencies.n,
+        false, false);
+    unit.m_global_scope->add_symbol(module_name, module);
+}
+
+} // namespace LCompilers

src/libasr/pass/global_symbols.h

@@ -0,0 +1,15 @@
+#ifndef LFORTRAN_PASS_GLOBAL_SYMBOLS_H
+#define LFORTRAN_PASS_GLOBAL_SYMBOLS_H
+
+#include <libasr/asr.h>
+#include <libasr/utils.h>
+
+namespace LCompilers {
+
+    void pass_wrap_global_syms_into_module(Allocator &al,
+        ASR::TranslationUnit_t &unit,
+        const LCompilers::PassOptions& pass_options);
+
+} // namespace LCompilers
+
+#endif // LFORTRAN_PASS_GLOBAL_SYMBOLS_H