diff --git a/sim/BUILD b/sim/BUILD
index dc21c6e..922f393 100644
--- a/sim/BUILD
+++ b/sim/BUILD
@@ -168,6 +168,8 @@
         "@com_google_absl//absl/flags:flag",
         "@com_google_absl//absl/flags:parse",
         "@com_google_absl//absl/flags:usage",
+        "@com_google_absl//absl/log",
+        "@com_google_absl//absl/log:initialize",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/time",
diff --git a/sim/kelvin_sim.cc b/sim/kelvin_sim.cc
index 744be98..b8c3388 100644
--- a/sim/kelvin_sim.cc
+++ b/sim/kelvin_sim.cc
@@ -2,7 +2,10 @@
 
 #include <cstdint>
 #include <cstdlib>
+#include <fstream>
+#include <ios>
 #include <iostream>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -11,6 +14,8 @@
 #include "absl/flags/flag.h"
 #include "absl/flags/parse.h"
 #include "absl/flags/usage.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -25,6 +30,11 @@
 ABSL_FLAG(bool, i, false, "Interactive mode");
 ABSL_FLAG(bool, interactive, false, "Interactive mode");
 
+ABSL_FLAG(uint32_t, bin_memory_offset, 0,
+          "Memory offset to load the binary file");
+ABSL_FLAG(std::optional<uint32_t>, entry_point, std::nullopt,
+          "Optionally set the entry point of the program.");
+
 // Static pointer to the top instance. Used by the control-C handler.
 static kelvin::sim::KelvinTop *top = nullptr;
 
@@ -99,13 +109,27 @@
   return true;
 }
 
+// Use ELF file's magic word to determine if the input file is an ELF file.
+static bool IsElfFile(std::string &file_name) {
+  std::ifstream image_file;
+  image_file.open(file_name, std::ios::in | std::ios::binary);
+  if (image_file.good()) {
+    uint32_t magic_word;
+    image_file.read(reinterpret_cast<char *>(&magic_word), sizeof(magic_word));
+    image_file.close();
+    return magic_word == 0x464c457f;  // little endian ELF magic word.
+  }
+  return false;
+}
+
 int main(int argc, char **argv) {
+  absl::InitializeLog();
   absl::SetProgramUsageMessage("Kelvin MPACT-Sim based CLI tool");
   auto out_args = absl::ParseCommandLine(argc, argv);
   argc = out_args.size();
   argv = &out_args[0];
   if (argc != 2) {
-    std::cerr << "Only a single input file allowed" << std::endl;
+    LOG(ERROR) << "Only a single input file allowed";
     return -1;
   }
   std::string file_name = argv[1];
@@ -121,23 +145,59 @@
   sa.sa_handler = &sim_sigint_handler;
   sigaction(SIGINT, &sa, nullptr);
 
+  bool interactive = absl::GetFlag(FLAGS_i) || absl::GetFlag(FLAGS_interactive);
+  auto is_elf_file = IsElfFile(file_name);
+
+  uint32_t entry_point = 0;
   // Load the elf segments into memory.
   mpact::sim::util::ElfProgramLoader elf_loader(kelvin_top.memory());
-  auto load_result = elf_loader.LoadProgram(file_name);
-  if (!load_result.ok()) {
-    std::cerr << "Error while loading '" << file_name
-              << "': " << load_result.status().message();
+  if (!is_elf_file && interactive) {
+    LOG(ERROR) << "Interactive mode may misbehave without the ELF symbol";
+    return -1;
+  }
+  if (is_elf_file) {
+    auto load_result = elf_loader.LoadProgram(file_name);
+    if (!load_result.ok()) {
+      LOG(ERROR) << "Error while loading '" << file_name
+                 << "': " << load_result.status().message();
+      return -1;
+    }
+    auto elf_entry_point = load_result.value();
+    // Set the program entry point to based on the ELF info but can
+    // be overridden by the `entry_point` flag.
+    entry_point = (absl::GetFlag(FLAGS_entry_point).has_value())
+                      ? absl::GetFlag(FLAGS_entry_point).value()
+                      : elf_entry_point;
+    if (elf_entry_point != entry_point) {
+      LOG(ERROR) << absl::StrFormat(
+          "ELF recorded entry point 0x%08x is different from the flag value "
+          "0x%08x. The program may not start properly",
+          elf_entry_point, entry_point);
+    }
+  } else {  // Load binary file from the specified memory offset.
+    // Required the flag `entry_point` to be specified for binary file.
+    if (!absl::GetFlag(FLAGS_entry_point).has_value()) {
+      LOG(ERROR) << "Need to specify the program entry point";
+      return -1;
+    }
+    entry_point = absl::GetFlag(FLAGS_entry_point).value();
+    auto res =
+        kelvin_top.LoadImage(file_name, absl::GetFlag(FLAGS_bin_memory_offset));
+    if (!res.ok()) {
+      LOG(ERROR) << "Error while loading '" << file_name
+                 << "': " << res.message();
+      return -1;
+    }
   }
 
   // Initialize the PC to the entry point.
-  uint32_t entry_point = load_result.value();
   auto pc_write = kelvin_top.WriteRegister("pc", entry_point);
   if (!pc_write.ok()) {
-    std::cerr << "Error writing to pc: " << pc_write.message();
+    LOG(ERROR) << "Error writing to pc: " << pc_write.message();
+    return -1;
   }
 
   // Determine if this is being run interactively or as a batch job.
-  bool interactive = absl::GetFlag(FLAGS_i) || absl::GetFlag(FLAGS_interactive);
   if (interactive) {
     mpact::sim::riscv::DebugCommandShell cmd_shell(
         {{&kelvin_top, &elf_loader}});
@@ -155,12 +215,12 @@
 
     auto run_status = kelvin_top.Run();
     if (!run_status.ok()) {
-      std::cerr << run_status.message() << std::endl;
+      LOG(ERROR) << run_status.message();
     }
 
     auto wait_status = kelvin_top.Wait();
     if (!wait_status.ok()) {
-      std::cerr << wait_status.message() << std::endl;
+      LOG(ERROR) << wait_status.message();
     }
     auto sec = absl::ToDoubleSeconds(absl::Now() - t0);
     std::cout << "Total cycles: " << kelvin_top.GetCycleCount() << std::endl;
diff --git a/sim/kelvin_top.cc b/sim/kelvin_top.cc
index 9955c3f..b71173d 100644
--- a/sim/kelvin_top.cc
+++ b/sim/kelvin_top.cc
@@ -2,7 +2,9 @@
 
 #include <sys/stat.h>
 
+#include <algorithm>
 #include <cerrno>
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <fstream>
@@ -520,6 +522,11 @@
   if (run_status_ != RunStatus::kHalted) {
     return absl::FailedPreconditionError("ReadMemory: Core must be halted");
   }
+  if (address >= state_->max_physical_address()) {
+    return absl::InvalidArgumentError("Memory address invalid");
+  }
+  length =
+      std::min<size_t>(length, state_->max_physical_address() - address + 1);
   auto *db = db_factory_.Allocate(length);
   // Load bypassing any watch points/semihosting.
   state_->memory()->Load(address, db, nullptr, nullptr);
@@ -534,6 +541,11 @@
   if (run_status_ != RunStatus::kHalted) {
     return absl::FailedPreconditionError("WriteMemory: Core must be halted");
   }
+  if (address >= state_->max_physical_address()) {
+    return absl::InvalidArgumentError("Memory address invalid");
+  }
+  length =
+      std::min<size_t>(length, state_->max_physical_address() - address + 1);
   auto *db = db_factory_.Allocate(length);
   std::memcpy(db->raw_ptr(), buffer, length);
   // Store bypassing any watch points/semihosting.
@@ -620,6 +632,37 @@
   return disasm;
 }
 
+absl::Status KelvinTop::LoadImage(const std::string &image_path,
+                                  uint64_t start_address) {
+  std::ifstream image_file;
+  constexpr size_t kBufferSize = 4096;
+  image_file.open(image_path, std::ios::in | std::ios::binary);
+  char buffer[kBufferSize];
+  size_t gcount = 0;
+  uint64_t load_address = start_address;
+  if (!image_file.good()) {
+    return absl::Status(absl::StatusCode::kInternal, "Failed to open file");
+  }
+  do {
+    // Fill buffer.
+    image_file.read(buffer, kBufferSize);
+    // Get the number of bytes that was read.
+    gcount = image_file.gcount();
+    // Write to the simulator memory.
+    auto res = WriteMemory(load_address, buffer, gcount);
+    // Check that the write succeeded, increment address if it did.
+    if (!res.ok()) {
+      return absl::InternalError("Memory write failed");
+    }
+    if (res.value() != gcount) {
+      return absl::InternalError("Failed to write all the bytes");
+    }
+    load_address += gcount;
+  } while (image_file.good() && (gcount > 0));
+  image_file.close();
+  return absl::OkStatus();
+}
+
 void KelvinTop::RequestHalt(HaltReason halt_reason,
                             const mpact::sim::generic::Instruction *inst) {
   // First set the halt_reason_, then the half flag.
diff --git a/sim/kelvin_top.h b/sim/kelvin_top.h
index b279ebd..551d127 100644
--- a/sim/kelvin_top.h
+++ b/sim/kelvin_top.h
@@ -79,6 +79,8 @@
   void RequestHalt(HaltReason halt_reason,
                    const mpact::sim::generic::Instruction *inst);
 
+  // Load a binary image of the SW program.
+  absl::Status LoadImage(const std::string &image_path, uint64_t start_address);
   // Accessors.
   sim::KelvinState *state() const { return state_; }
   mpact::sim::util::MemoryInterface *memory() const { return memory_; }
diff --git a/sim/renode/kelvin_renode.cc b/sim/renode/kelvin_renode.cc
index a1df4e7..c0ba412 100644
--- a/sim/renode/kelvin_renode.cc
+++ b/sim/renode/kelvin_renode.cc
@@ -97,6 +97,11 @@
   return kelvin_top_->GetDisassembly(address);
 }
 
+absl::Status KelvinRenode::LoadImage(const std::string &image_path,
+                                     uint64_t start_address) {
+  return kelvin_top_->LoadImage(image_path, start_address);
+}
+
 absl::StatusOr<uint64_t> KelvinRenode::ReadRegister(uint32_t reg_id) {
   auto ptr = RiscVDebugInfo::Instance()->debug_register_map().find(reg_id);
   if (ptr == RiscVDebugInfo::Instance()->debug_register_map().end()) {
diff --git a/sim/renode/kelvin_renode.h b/sim/renode/kelvin_renode.h
index e2a5591..0469eed 100644
--- a/sim/renode/kelvin_renode.h
+++ b/sim/renode/kelvin_renode.h
@@ -75,6 +75,9 @@
   absl::Status GetRenodeRegisterInfo(int32_t index, int32_t max_len, char *name,
                                      RenodeCpuRegister &info) override;
 
+  absl::Status LoadImage(const std::string &image_path,
+                         uint64_t start_address) override;
+
  private:
   KelvinTop *kelvin_top_ = nullptr;
 };
diff --git a/sim/renode/renode_debug_interface.h b/sim/renode/renode_debug_interface.h
index 4368763..04c910d 100644
--- a/sim/renode/renode_debug_interface.h
+++ b/sim/renode/renode_debug_interface.h
@@ -2,6 +2,7 @@
 #define LEARNING_BRAIN_RESEARCH_KELVIN_SIM_RENODE_RENODE_DEBUG_INTERFACE_H_
 
 #include <cstdint>
+#include <string>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -34,6 +35,9 @@
   virtual absl::Status GetRenodeRegisterInfo(int32_t index, int32_t max_len,
                                              char *name,
                                              RenodeCpuRegister &info) = 0;
+
+  virtual absl::Status LoadImage(const std::string &image_path,
+                                 uint64_t start_address) = 0;
 };
 
 }  // namespace kelvin::sim::renode
diff --git a/sim/renode/renode_mpact.cc b/sim/renode/renode_mpact.cc
index 51e111e..5a1035d 100644
--- a/sim/renode/renode_mpact.cc
+++ b/sim/renode/renode_mpact.cc
@@ -1,9 +1,6 @@
 #include "sim/renode/renode_mpact.h"
 
-#include <cstddef>
 #include <cstdint>
-#include <fstream>
-#include <ios>
 #include <limits>
 #include <string>
 
@@ -211,35 +208,11 @@
     return -1;
   }
   auto *dbg = dbg_iter->second;
-  // Open up the image file.
-  std::ifstream image_file;
-  image_file.open(file_name, std::ios::in | std::ios::binary);
-  if (!image_file.good()) {
-    LOG(ERROR) << "LoadImage: Input file not in good state";
+  auto res = dbg->LoadImage(std::string(file_name), address);
+  if (!res.ok()) {
+    LOG(ERROR) << "Failed to load image: " << res.message();
     return -1;
   }
-  char buffer[kBufferSize];
-  size_t gcount = 0;
-  uint64_t load_address = address;
-  do {
-    // Fill buffer.
-    image_file.read(buffer, kBufferSize);
-    // Get the number of bytes that was read.
-    gcount = image_file.gcount();
-    // Write to the simulator memory.
-    auto res = dbg->WriteMemory(load_address, buffer, gcount);
-    // Check that the write succeeded, increment address if it did.
-    if (!res.ok()) {
-      LOG(ERROR) << "LoadImage: Memory write failed";
-      return -1;
-    }
-    if (res.value() != gcount) {
-      LOG(ERROR) << "LoadImage: Memory write failed to write all the bytes";
-      return -1;
-    }
-    load_address += gcount;
-  } while (image_file.good() && (gcount > 0));
-  image_file.close();
   return 0;
 }
 
diff --git a/sim/renode/test/BUILD b/sim/renode/test/BUILD
index 50538d3..4b1d191 100644
--- a/sim/renode/test/BUILD
+++ b/sim/renode/test/BUILD
@@ -37,7 +37,6 @@
         "@com_google_googletest//:gtest_main",
         "@com_google_mpact-riscv//riscv:riscv_debug_info",
         "@com_google_mpact-sim//mpact/sim/generic:core",
-        "@com_google_mpact-sim//mpact/sim/generic:core_debug_interface",
         "@com_google_mpact-sim//mpact/sim/util/program_loader:elf_loader",
     ],
 )
diff --git a/sim/renode/test/kelvin_renode_test.cc b/sim/renode/test/kelvin_renode_test.cc
index 82c01e7..397dcf6 100644
--- a/sim/renode/test/kelvin_renode_test.cc
+++ b/sim/renode/test/kelvin_renode_test.cc
@@ -1,9 +1,6 @@
 #include "sim/renode/kelvin_renode.h"
 
-#include <cstddef>
 #include <cstdint>
-#include <fstream>
-#include <ios>
 #include <string>
 
 #include "sim/kelvin_top.h"
@@ -13,7 +10,6 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "riscv/riscv_debug_info.h"
-#include "mpact/sim/generic/core_debug_interface.h"
 #include "mpact/sim/util/program_loader/elf_program_loader.h"
 
 namespace {
@@ -82,26 +78,11 @@
 
 TEST_F(KelvinRenodeTest, RunBinProgram) {
   std::string file_name = absl::StrCat(kDepotPath, "testfiles/", kBinFileName);
-  constexpr uint32_t kBufferSize = 1024;
   constexpr uint64_t kBinFileAddress = 0x0;
   constexpr uint64_t kBinFileEntryPoint = 0x0;
 
-  char buffer[kBufferSize];
-  size_t gcount = 0;
-  uint64_t load_address = kBinFileAddress;
-  std::ifstream image_file;
-  image_file.open(file_name, std::ios::in | std::ios::binary);
-  EXPECT_TRUE(image_file.good());
-  do {
-    image_file.read(buffer, kBufferSize);
-    gcount = image_file.gcount();
-    auto result = top_->WriteMemory(load_address, buffer, gcount);
-    EXPECT_TRUE(result.ok());
-    EXPECT_EQ(result.value(), gcount);
-    load_address += gcount;
-  } while (image_file.good() && (gcount > 0));
-  image_file.close();
-
+  auto res = top_->LoadImage(file_name, kBinFileAddress);
+  EXPECT_TRUE(res.ok());
   // Run the program.
   testing::internal::CaptureStdout();
   EXPECT_TRUE(top_->WriteRegister("pc", kBinFileEntryPoint).ok());
diff --git a/sim/renode/test/renode_mpact_test.cc b/sim/renode/test/renode_mpact_test.cc
index c4fa7d1..d639225 100644
--- a/sim/renode/test/renode_mpact_test.cc
+++ b/sim/renode/test/renode_mpact_test.cc
@@ -111,6 +111,16 @@
   EXPECT_EQ(mem_bytes[0], kBytes[4]);
   res = read_memory(sim_id_, 0x100, reinterpret_cast<char *>(mem_bytes), 8);
   for (int i = 0; i < 8; i++) EXPECT_EQ(kBytes[i], mem_bytes[i]);
+
+  // Read memory from out of bound address
+  constexpr uint64_t kOutOfBoundAddress = 0x3'FFFF'FFFFULL;
+  res = read_memory(sim_id_, kOutOfBoundAddress,
+                    reinterpret_cast<char *>(mem_bytes), 1);
+  EXPECT_EQ(res, 0);
+  // Write to out of bound memory address
+  res = write_memory(sim_id_, kOutOfBoundAddress,
+                     reinterpret_cast<const char *>(mem_bytes), 1);
+  EXPECT_EQ(res, 0);
 }
 
 TEST_F(RenodeMpactTest, LoadImage) {
diff --git a/sim/test/BUILD b/sim/test/BUILD
index 9dbc184..58b2fa5 100644
--- a/sim/test/BUILD
+++ b/sim/test/BUILD
@@ -59,6 +59,7 @@
         "kelvin_top_test.cc",
     ],
     data = [
+        "testfiles/hello_world_mpause.bin",
         "testfiles/hello_world_mpause.elf",
         "testfiles/hello_world_rv32imf.elf",
         "testfiles/kelvin_vldvst.elf",
diff --git a/sim/test/kelvin_top_test.cc b/sim/test/kelvin_top_test.cc
index 2c7b9b7..88f938e 100644
--- a/sim/test/kelvin_top_test.cc
+++ b/sim/test/kelvin_top_test.cc
@@ -26,6 +26,7 @@
 using ::mpact::sim::util::FlatDemandMemory;
 
 using HaltReason = ::mpact::sim::generic::CoreDebugInterface::HaltReason;
+constexpr char kMpauseBinaryFileName[] = "hello_world_mpause.bin";
 constexpr char kMpauseElfFileName[] = "hello_world_mpause.elf";
 constexpr char kRV32imfElfFileName[] = "hello_world_rv32imf.elf";
 constexpr char kRV32iElfFileName[] = "rv32i.elf";
@@ -40,6 +41,8 @@
 // Maximum memory size used by riscv programs build for userspace.
 constexpr uint64_t kRiscv32MaxAddress = 0x3'ffff'ffffULL;
 
+constexpr uint64_t kBinaryAddress = 0;
+
 class KelvinTopTest : public testing::Test {
  protected:
   KelvinTopTest() {
@@ -139,6 +142,70 @@
   EXPECT_EQ("Program exits properly\n", stdout_str);
 }
 
+TEST_F(KelvinTopTest, LoadImageFailed) {
+  const std::string input_file_name =
+      absl::StrCat(kDepotPath, "testfiles/", kMpauseBinaryFileName);
+  auto result = kelvin_top_->LoadImage("wrong_file", kBinaryAddress);
+  EXPECT_FALSE(result.ok());
+  // Set the memory to be smaller than the loaded image
+  kelvin_top_->state()->set_max_physical_address(0);
+  result = kelvin_top_->LoadImage(input_file_name, kBinaryAddress);
+  EXPECT_FALSE(result.ok());
+  kelvin_top_->state()->set_max_physical_address(0xf);
+  result = kelvin_top_->LoadImage(input_file_name, kBinaryAddress);
+  EXPECT_FALSE(result.ok());
+}
+
+// Directly read/write to memory addresses that are out-of-bound
+TEST_F(KelvinTopTest, ReadWriteOutOfBoundMemory) {
+  // Set the machine to have 16-byte physical memory
+  constexpr uint64_t kTestMemerySize = 0x10;
+  kelvin_top_->state()->set_max_physical_address(kTestMemerySize - 1);
+  uint8_t mem_bytes[kTestMemerySize + 4] = {0};
+  // Read the memory with the length greater than the physical memory size. The
+  // read operation is successful within the physical memory size range.
+  auto result =
+      kelvin_top_->ReadMemory(kBinaryAddress, mem_bytes, sizeof(mem_bytes));
+  EXPECT_OK(result);
+  EXPECT_EQ(result.value(), kTestMemerySize);
+  // Read the memory with the staring address out of the physical memory range.
+  // The read operation returns error.
+  result = kelvin_top_->ReadMemory(kTestMemerySize + 4, mem_bytes,
+                                   sizeof(mem_bytes));
+  EXPECT_FALSE(result.ok());
+
+  // Write the memory with the length greater than the physical memory size. The
+  // write operation is successful within the physical memory size range.
+  result =
+      kelvin_top_->WriteMemory(kBinaryAddress, mem_bytes, sizeof(mem_bytes));
+  EXPECT_OK(result);
+  EXPECT_EQ(result.value(), kTestMemerySize);
+  // Write the memory with the staring address out of the physical memory range.
+  // The write operation returns error.
+  result = kelvin_top_->WriteMemory(kTestMemerySize + 4, mem_bytes,
+                                    sizeof(mem_bytes));
+  EXPECT_FALSE(result.ok());
+}
+
+// Runs the binary program from beginning to end
+TEST_F(KelvinTopTest, RunHelloMpauseBinaryProgram) {
+  const std::string input_file_name =
+      absl::StrCat(kDepotPath, "testfiles/", kMpauseBinaryFileName);
+  constexpr uint32_t kBinaryEntryPoint = 0;
+  testing::internal::CaptureStdout();
+  auto result = kelvin_top_->LoadImage(input_file_name, kBinaryAddress);
+  CHECK_OK(result);
+  EXPECT_OK(kelvin_top_->WriteRegister("pc", kBinaryEntryPoint));
+  EXPECT_OK(kelvin_top_->Run());
+  EXPECT_OK(kelvin_top_->Wait());
+  auto halt_result = kelvin_top_->GetLastHaltReason();
+  CHECK_OK(halt_result);
+  EXPECT_EQ(static_cast<int>(halt_result.value()),
+            static_cast<int>(HaltReason::kUserRequest));
+  const std::string stdout_str = testing::internal::GetCapturedStdout();
+  EXPECT_EQ("Program exits properly\n", stdout_str);
+}
+
 // Runs the rv32i program with arm semihosting.
 TEST_F(KelvinTopTest, RunRV32IProgram) {
   absl::SetFlag(&FLAGS_use_semihost, true);