Fix ASR verify pass error while using Interactive

CMakeLists.txt

@@ -120,6 +120,20 @@ if (WITH_LCOMPILERS_FAST_ALLOC)
  add_definitions("-DLCOMPILERS_FAST_ALLOC=1")
 endif()
 
+# copy runtime files
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/lpython/lpython.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/lpython/lpython.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/cmath.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/cmath.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/lpython_builtin.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/lpython_builtin.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/lpython_intrinsic_numpy.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/lpython_intrinsic_numpy.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/lpython_parser.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/lpython_parser.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/math.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/math.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/os.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/os.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/platform.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/platform.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/random.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/random.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/statistics.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/statistics.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/sys.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/sys.py")
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/time.py" "${CMAKE_CURRENT_BINARY_DIR}/src/runtime/time.py")
+
 # LLVM
 set(WITH_LLVM no CACHE BOOL "Build with LLVM support")
 set(WITH_TARGET_AARCH64 no CACHE BOOL "Enable target AARCH64")

src/libasr/asr_scopes.cpp

@@ -3,6 +3,7 @@
 
 #include <libasr/asr_scopes.h>
 #include <libasr/asr_utils.h>
+#include <libasr/pass/pass_utils.h>
 
 std::string lcompilers_unique_ID;
 
@@ -39,9 +40,13 @@ void SymbolTable::mark_all_variables_external(Allocator &al) {
  case (ASR::symbolType::Function) : {
  ASR::Function_t *v = ASR::down_cast<ASR::Function_t>(a.second);
  ASR::FunctionType_t* v_func_type = ASR::down_cast<ASR::FunctionType_t>(v->m_function_signature);
- v_func_type->m_abi = ASR::abiType::Interactive;
- v->m_body = nullptr;
- v->n_body = 0;
+ if (v_func_type->m_abi != ASR::abiType::Interactive) {
+ v_func_type->m_abi = ASR::abiType::Interactive;
+ v->m_body = nullptr;
+ v->n_body = 0;
+ PassUtils::UpdateDependenciesVisitor ud(al);
+ ud.visit_Function(*v);
+ }
  break;
  }
  case (ASR::symbolType::Module) : {

src/libasr/asr_verify.cpp

@@ -420,6 +420,11 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
  }
 
  void visit_Function(const Function_t &x) {
+ ASR::FunctionType_t* x_func_type = ASR::down_cast<ASR::FunctionType_t>(x.m_function_signature);
+ if (x_func_type->m_abi == abiType::Interactive) {
+ require(x.n_body == 0,
+ "The Function::n_body should be 0 if abi set to Interactive");
+ }
  std::vector<std::string> function_dependencies_copy = function_dependencies;
  function_dependencies.clear();
  function_dependencies.reserve(x.n_dependencies);

src/libasr/codegen/KaleidoscopeJIT.h

@@ -26,6 +26,10 @@
 #include "llvm/IR/LLVMContext.h"
 #include <memory>
 
+#if LLVM_VERSION_MAJOR >= 13
+#include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
+#endif
+
 #if LLVM_VERSION_MAJOR >= 16
 # define RM_OPTIONAL_TYPE std::optional
 #else
@@ -37,77 +41,76 @@ namespace orc {
 
 class KaleidoscopeJIT {
 private:
- ExecutionSession ES;
+std::unique_ptr<ExecutionSession> ES;
  RTDyldObjectLinkingLayer ObjectLayer;
  IRCompileLayer CompileLayer;
 
  DataLayout DL;
  MangleAndInterner Mangle;
- ThreadSafeContext Ctx;
  JITDylib &JITDL;
 
- TargetMachine *TM;
-
 public:
- KaleidoscopeJIT(JITTargetMachineBuilder JTMB, DataLayout DL)
+ KaleidoscopeJIT(std::unique_ptr<ExecutionSession> ES, JITTargetMachineBuilder JTMB, DataLayout DL)
  :
-#if LLVM_VERSION_MAJOR >= 13
- ES(cantFail(SelfExecutorProcessControl::Create())),
-#endif
- ObjectLayer(ES,
+ ES(std::move(ES)),
+ ObjectLayer(*this->ES,
  []() { return std::make_unique<SectionMemoryManager>(); }),
- CompileLayer(ES, ObjectLayer, std::make_unique<ConcurrentIRCompiler>(ConcurrentIRCompiler(std::move(JTMB)))),
- DL(std::move(DL)), Mangle(ES, this->DL),
- Ctx(std::make_unique<LLVMContext>()),
+ CompileLayer(*this->ES, ObjectLayer, std::make_unique<ConcurrentIRCompiler>(std::move(JTMB))),
+ DL(std::move(DL)), Mangle(*this->ES, this->DL),
  JITDL(
 #if LLVM_VERSION_MAJOR >= 11
  cantFail
 #endif
- (ES.createJITDylib("Main"))) {
+ (this->ES->createJITDylib("Main"))) {
  JITDL.addGenerator(
  cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
  DL.getGlobalPrefix())));
-
- std::string Error;
- auto TargetTriple = sys::getDefaultTargetTriple();
- auto Target = TargetRegistry::lookupTarget(TargetTriple, Error);
- if (!Target) {
- throw std::runtime_error("Failed to lookup the target");
+ if (JTMB.getTargetTriple().isOSBinFormatCOFF()) {
+ ObjectLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
+ ObjectLayer.setAutoClaimResponsibilityForObjectSymbols(true);
  }
- auto CPU = "generic";
- auto Features = "";
- TargetOptions opt;
- auto RM = RM_OPTIONAL_TYPE<Reloc::Model>();
- TM = Target->createTargetMachine(TargetTriple, CPU, Features, opt, RM);
  }
 
  static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
- auto JTMB = JITTargetMachineBuilder::detectHost();
+#if LLVM_VERSION_MAJOR >= 13
+ auto EPC = SelfExecutorProcessControl::Create();
+ if (!EPC)
+ return EPC.takeError();
 
- if (!JTMB)
- return JTMB.takeError();
+ auto ES = std::make_unique<ExecutionSession>(std::move(*EPC));
 
- auto DL = JTMB->getDefaultDataLayoutForTarget();
+ JITTargetMachineBuilder JTMB(
+ ES->getExecutorProcessControl().getTargetTriple());
+#else
+ auto ES = std::make_unique<ExecutionSession>();
+
+ auto JTMB_P = JITTargetMachineBuilder::detectHost();
+ if (!JTMB_P)
+ return JTMB_P.takeError();
+
+ auto JTMB = *JTMB_P;
+#endif
+
+ auto DL = JTMB.getDefaultDataLayoutForTarget();
  if (!DL)
  return DL.takeError();
 
- return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
+ return std::make_unique<KaleidoscopeJIT>(std::move(ES), std::move(JTMB),
+ std::move(*DL));
  }
 
  const DataLayout &getDataLayout() const { return DL; }
 
-LLVMContext &getContext() { return *Ctx.getContext(); }
-
-Error addModule(std::unique_ptr<Module> M) {
-return CompileLayer.add(JITDL,
- ThreadSafeModule(std::move(M), Ctx));
+Error addModule(std::unique_ptr<Module> M, std::unique_ptr<LLVMContext> &Ctx) {
+ auto res = CompileLayer.add(JITDL,
+ ThreadSafeModule(std::move(M), std::move(Ctx)));
+Ctx = std::make_unique<LLVMContext>();
+return res;
  }
 
  Expected<JITEvaluatedSymbol> lookup(StringRef Name) {
- return ES.lookup({&JITDL}, Mangle(Name.str()));
+ return ES->lookup({&JITDL}, Mangle(Name.str()));
  }
-
- TargetMachine &getTargetMachine() { return *TM; }
 };
 
 } // end namespace orc

src/libasr/codegen/evaluator.cpp

@@ -212,7 +212,7 @@ std::unique_ptr<llvm::Module> LLVMEvaluator::parse_module(const std::string &sou
  throw LCompilersException("parse_module(): module failed verification.");
  };
  module->setTargetTriple(target_triple);
- module->setDataLayout(jit->getTargetMachine().createDataLayout());
+ module->setDataLayout(jit->getDataLayout());
  return module;
 }
 
@@ -234,7 +234,7 @@ void LLVMEvaluator::add_module(std::unique_ptr<llvm::Module> mod) {
  // cases when the Module was constructed directly, not via parse_module().
  mod->setTargetTriple(target_triple);
  mod->setDataLayout(jit->getDataLayout());
- llvm::Error err = jit->addModule(std::move(mod));
+ llvm::Error err = jit->addModule(std::move(mod), context);
  if (err) {
  llvm::SmallVector<char, 128> buf;
  llvm::raw_svector_ostream dest(buf);
@@ -354,7 +354,7 @@ std::string LLVMEvaluator::get_asm(llvm::Module &m)
  llvm::CodeGenFileType ft = llvm::CGFT_AssemblyFile;
  llvm::SmallVector<char, 128> buf;
  llvm::raw_svector_ostream dest(buf);
- if (jit->getTargetMachine().addPassesToEmitFile(pass, dest, nullptr, ft)) {
+ if (TM->addPassesToEmitFile(pass, dest, nullptr, ft)) {
  throw std::runtime_error("TargetMachine can't emit a file of this type");
  }
  pass.run(m);

src/libasr/string_utils.cpp

@@ -116,7 +116,7 @@ std::string read_file(const std::string &filename)
  std::vector<char> bytes(filesize);
  ifs.read(&bytes[0], filesize);
 
- return std::string(&bytes[0], filesize);
+ return replace(std::string(&bytes[0], filesize), "\r\n", "\n");
 }
 
 std::string parent_path(const std::string &path) {

src/lpython/tests/test_llvm.cpp

@@ -624,6 +624,25 @@ TEST_CASE("PythonCompiler 1") {
  CHECK(r.result.i32 == 1);
 }
 
+TEST_CASE("PythonCompiler 2") {
+ CompilerOptions cu;
+ cu.po.disable_main = true;
+ cu.emit_debug_line_column = false;
+ cu.generate_object_code = false;
+ cu.interactive = true;
+ cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
+ PythonCompiler e(cu);
+ LCompilers::Result<PythonCompiler::EvalResult>
+
+ r = e.evaluate2("i: i32 = 3 % 2");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::none);
+ r = e.evaluate2("i");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::integer4);
+ CHECK(r.result.i32 == 1);
+}
+
 TEST_CASE("PythonCompiler i32 expressions") {
  CompilerOptions cu;
  cu.po.disable_main = true;
@@ -845,6 +864,7 @@ TEST_CASE("PythonCompiler u32 declaration") {
  r = e.evaluate2("i: u32");
  CHECK(r.ok);
  CHECK(r.result.type == PythonCompiler::EvalResult::none);
+
  r = e.evaluate2("i = u32(5)");
  CHECK(r.ok);
  CHECK(r.result.type == PythonCompiler::EvalResult::statement);
@@ -1358,3 +1378,113 @@ def my_concat(x: str, y: str) -> str:
  CHECK(r.result.type == PythonCompiler::EvalResult::string);
  CHECK(std::strcmp(r.result.str, "Python REPL") == 0);
 }
+
+TEST_CASE("PythonCompiler asr verify 1") {
+ CompilerOptions cu;
+ cu.po.disable_main = true;
+ cu.emit_debug_line_column = false;
+ cu.generate_object_code = false;
+ cu.interactive = true;
+ cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
+ PythonCompiler e(cu);
+ LCompilers::Result<PythonCompiler::EvalResult>
+
+ r = e.evaluate2("i: i32 = 3 % 2");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::none);
+ r = e.evaluate2("i");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::integer4);
+ CHECK(r.result.i32 == 1);
+}
+
+TEST_CASE("PythonCompiler asr verify 2") {
+ CompilerOptions cu;
+ cu.po.disable_main = true;
+ cu.emit_debug_line_column = false;
+ cu.generate_object_code = false;
+ cu.interactive = true;
+ cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
+ PythonCompiler e(cu);
+ LCompilers::Result<PythonCompiler::EvalResult>
+ r = e.evaluate2(R"(
+def is_even(x: i32) -> i32:
+ if x % 2 == 0:
+ return 1
+ return 0
+)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::none);
+ r = e.evaluate2("is_even(4)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::integer4);
+ CHECK(r.result.i32 == 1);
+ r = e.evaluate2("is_even(3)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::integer4);
+ CHECK(r.result.i32 == 0);
+}
+
+TEST_CASE("PythonCompiler asr verify 3") {
+ CompilerOptions cu;
+ cu.po.disable_main = true;
+ cu.emit_debug_line_column = false;
+ cu.generate_object_code = false;
+ cu.interactive = true;
+ cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
+ PythonCompiler e(cu);
+ LCompilers::Result<PythonCompiler::EvalResult>
+
+ r = e.evaluate2(R"(
+def addi(x: i32, y: i32) -> i32:
+ return x + y
+)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::none);
+ r = e.evaluate2(R"(
+def subi(x: i32, y: i32) -> i32:
+ return addi(x, -y)
+)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::none);
+ r = e.evaluate2("addi(2, 3)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::integer4);
+ CHECK(r.result.i32 == 5);
+ r = e.evaluate2("subi(2, 3)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::integer4);
+ CHECK(r.result.i32 == -1);
+}
+
+TEST_CASE("PythonCompiler asr verify 4") {
+ CompilerOptions cu;
+ cu.po.disable_main = true;
+ cu.emit_debug_line_column = false;
+ cu.generate_object_code = false;
+ cu.interactive = true;
+ cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
+ PythonCompiler e(cu);
+ LCompilers::Result<PythonCompiler::EvalResult>
+
+ r = e.evaluate2(R"(
+def addr(x: f64, y: f64) -> f64:
+ return x + y
+)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::none);
+ r = e.evaluate2(R"(
+def subr(x: f64, y: f64) -> f64:
+ return addr(x, -y)
+)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::none);
+ r = e.evaluate2("addr(2.5, 3.5)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::real8);
+ CHECK(r.result.f64 == 6);
+ r = e.evaluate2("subr(2.5, 3.5)");
+ CHECK(r.ok);
+ CHECK(r.result.type == PythonCompiler::EvalResult::real8);
+ CHECK(r.result.f64 == -1);
+}

src/runtime/lpython_builtin.py

@@ -1143,4 +1143,3 @@ def list(s: str) -> list[str]:
  for i in range(len(s)):
  l.append(s[i])
  return l
-

src/runtime/platform.py

@@ -2,4 +2,4 @@ def python_implementation() -> str:
  return "LPython"
 
 def python_version() -> str:
- return __LPYTHON_VERSION__
+ return __LPYTHON_VERSION__