Support --dump-all-passes, --dump-all-passes-fortran

Author: ubaidsk

src/bin/lpython.cpp

@@ -443,6 +443,45 @@ int emit_wat(const std::string &infile,
     return 0;
 }
 
+int dump_all_passes(const std::string &infile,
+    const std::string &runtime_library_dir,
+    CompilerOptions &compiler_options) {
+    std::string input = LCompilers::read_file(infile);
+
+    Allocator al(4*1024);
+    LCompilers::LocationManager lm;
+    LCompilers::diag::Diagnostics diagnostics;
+    {
+        LCompilers::LocationManager::FileLocations fl;
+        fl.in_filename = infile;
+        lm.files.push_back(fl);
+        lm.file_ends.push_back(input.size());
+    }
+
+    LCompilers::Result<LCompilers::LPython::AST::ast_t*> r = parse_python_file(
+        al, runtime_library_dir, infile, diagnostics, 0, compiler_options.new_parser);
+    std::cerr << diagnostics.render(lm, compiler_options);
+    if (!r.ok) {
+        return 1;
+    }
+    LCompilers::LPython::AST::ast_t* ast = r.result;
+    diagnostics.diagnostics.clear();
+    LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>
+        r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);
+    std::cerr << diagnostics.render(lm, compiler_options);
+    if (r1.ok) {
+        LCompilers::PassManager pass_manager;
+        compiler_options.po.always_run = true;
+        compiler_options.po.run_fun = "f";
+        pass_manager.dump_all_passes(al, r1.result, compiler_options.po, diagnostics, lm);
+        std::cerr << diagnostics.render(lm, compiler_options);
+    } else {
+        LCOMPILERS_ASSERT(diagnostics.has_error())
+        return 1;
+    }
+    return 0;
+}
+
 #ifdef HAVE_LFORTRAN_RAPIDJSON
 
 int get_symbols (const std::string &infile,
@@ -1549,6 +1588,8 @@ int main(int argc, char *argv[])
         app.add_flag("--get-rtl-header-dir", print_rtl_header_dir, "Print the path to the runtime library header file");
         app.add_flag("--get-rtl-dir", print_rtl_dir, "Print the path to the runtime library file");
         app.add_flag("--verbose", compiler_options.po.verbose, "Print debugging statements");
+        app.add_flag("--dump-all-passes", compiler_options.po.dump_all_passes, "Apply all the passes and dump the ASR into a file");
+        app.add_flag("--dump-all-passes-fortran", compiler_options.po.dump_fortran, "Apply all passes and dump the ASR after each pass into fortran file");
         app.add_flag("--cumulative", compiler_options.po.pass_cumulative, "Apply all the passes cumulatively till the given pass");
         app.add_flag("--enable-cpython", compiler_options.enable_cpython, "Enable CPython runtime");
         app.add_flag("--enable-symengine", compiler_options.enable_symengine, "Enable Symengine runtime");
@@ -1726,6 +1767,10 @@ int main(int argc, char *argv[])
             outfile = basename + ".out";
         }
 
+        if (compiler_options.po.dump_fortran || compiler_options.po.dump_all_passes) {
+            dump_all_passes(arg_file, compiler_options);
+        }
+
         // if (arg_E) {
         //     return emit_c_preprocessor(arg_file, compiler_options);
         // }

src/lpython/semantics/python_ast_to_asr.cpp

@@ -23,6 +23,8 @@
 #include <libasr/pass/intrinsic_array_function_registry.h>
 #include <libasr/modfile.h>
 #include <libasr/casting_utils.h>
+#include <libasr/codegen/asr_to_fortran.h>
+#include <libasr/pickle.h>
 
 #include <lpython/python_ast.h>
 #include <lpython/semantics/python_ast_to_asr.h>
@@ -7940,6 +7942,21 @@ Result<ASR::TranslationUnit_t*> python_ast_to_asr(Allocator &al, LocationManager
         return res.error;
     }
     ASR::TranslationUnit_t *tu = ASR::down_cast2<ASR::TranslationUnit_t>(unit);
+    if (compiler_options.po.dump_all_passes) {
+        std::ofstream outfile ("pass_00_initial_asr_01.clj");
+        outfile << ";; ASR after SymbolTable Visitor\n" << pickle(*tu, false, true, compiler_options.po.with_intrinsic_mods) << "\n";
+        outfile.close();
+    }
+    if (compiler_options.po.dump_fortran) {
+        LCompilers::Result<std::string> fortran_code = LCompilers::asr_to_fortran(*tu, diagnostics, false, 4);
+        if (!fortran_code.ok) {
+            LCOMPILERS_ASSERT(diagnostics.has_error());
+            throw LCompilersException("Fortran code could not be generated after symbol_table_visitor");
+        }
+        std::ofstream outfile ("pass_fortran_00_initial_code_01.f90");
+        outfile << "! Fortran code after SymbolTable Visitor\n" << fortran_code.result << "\n";
+        outfile.close();
+    }
 #if defined(WITH_LFORTRAN_ASSERT)
         if (!asr_verify(*tu, true, diagnostics)) {
             std::cerr << diagnostics.render2();
@@ -7955,6 +7972,21 @@ Result<ASR::TranslationUnit_t*> python_ast_to_asr(Allocator &al, LocationManager
         } else {
             return res2.error;
         }
+        if (compiler_options.po.dump_all_passes) {
+            std::ofstream outfile ("pass_00_initial_asr_02.clj");
+            outfile << ";; Initial ASR after Body Visitor\n" << pickle(*tu, false, true, compiler_options.po.with_intrinsic_mods) << "\n";
+            outfile.close();
+        }
+        if (compiler_options.po.dump_fortran) {
+            LCompilers::Result<std::string> fortran_code = LCompilers::asr_to_fortran(*tu, diagnostics, false, 4);
+            if (!fortran_code.ok) {
+                LCOMPILERS_ASSERT(diagnostics.has_error());
+                throw LCompilersException("Fortran code could not be generated after body_visitor");
+            }
+            std::ofstream outfile ("pass_fortran_00_initial_code_02.f90");
+            outfile << "! Fortran code after Body Visitor\n" << fortran_code.result << "\n";
+            outfile.close();
+        }
 #if defined(WITH_LFORTRAN_ASSERT)
         diag::Diagnostics diagnostics;
         if (!asr_verify(*tu, true, diagnostics)) {